/* * Copyright (C) 2009 Google Inc. All rights reserved. * Copyright (C) 2010 Apple Inc. All rights reserved. * * Redistribution and use in source and binary formstrArg, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ // This IDL file is for testing the bindings code generator and for tracking // changes in its ouput. enum TestEnumType { "", "enumValue1", "EnumValue2", "EnumValue3" }; // Leading underscore on an enum should be removed. enum _optional { "", "OptionalValue1", "OptionalValue2", "OptionalValue3" }; [Conditional=Condition1] enum TestEnumA { "A" }; [Conditional=Condition1&Condition2] enum TestEnumB { "B" }; [Conditional=Condition1|Condition2] enum TestEnumC { "C" }; enum TestObjKind { "quick", "dead" }; enum ObjSize { "small", "much-much-larger" }; enum TestConfidence { "high", "kinda-low" }; [ Constructor(TestCallback testCallback, TestCallbackFunction testCallbackFunction), InterfaceName=TestObject ] interface TestObj { // Attributes readonly attribute long readOnlyLongAttr; readonly attribute DOMString readOnlyStringAttr; readonly attribute TestObj readOnlyTestObjAttr; static readonly attribute long staticReadOnlyLongAttr; static attribute DOMString staticStringAttr; static readonly attribute TestSubObjConstructor TestSubObj; [EnabledBySetting=TestSetting] attribute TestSubObjConstructor TestSubObjEnabledBySetting; attribute TestEnumType enumAttr; attribute byte byteAttr; attribute octet octetAttr; attribute short shortAttr; [Clamp] attribute short clampedShortAttr; [EnforceRange] attribute short enforceRangeShortAttr; attribute unsigned short unsignedShortAttr; attribute long longAttr; attribute long long longLongAttr; attribute unsigned long long unsignedLongLongAttr; attribute DOMString stringAttr; attribute TestObj testObjAttr; attribute TestObj? testNullableObjAttr; [LenientThis] attribute TestObj lenientTestObjAttr; [Unforgeable] readonly attribute DOMString unforgeableAttr; [TreatNullAs=EmptyString] attribute DOMString stringAttrTreatingNullAsEmptyString; // WK_ucfirst, WK_lcfirst exceptional cases. attribute TestObj XMLObjAttr; attribute boolean create; // Reflected DOM attributes [Reflect] attribute DOMString reflectedStringAttr; [Reflect] attribute long reflectedIntegralAttr; [Reflect] attribute unsigned long reflectedUnsignedIntegralAttr; [Reflect] attribute boolean reflectedBooleanAttr; [Reflect, URL] attribute DOMString reflectedURLAttr; [Reflect=customContentStringAttr] attribute DOMString reflectedStringAttr; [Reflect=customContentIntegralAttr] attribute long reflectedCustomIntegralAttr; [Reflect=customContentBooleanAttr] attribute boolean reflectedCustomBooleanAttr; [Reflect=customContentURLAttr, URL] attribute DOMString reflectedCustomURLAttr; // [EnabledAtRuntime] attributes and operations. [Conditional=TEST_FEATURE, EnabledAtRuntime=TestFeature] attribute DOMString enabledAtRuntimeAttribute; [Conditional=TEST_FEATURE, EnabledAtRuntime=TestFeature] void enabledAtRuntimeOperation(DOMString testParam); [Conditional=TEST_FEATURE, EnabledAtRuntime=TestFeature] void enabledAtRuntimeOperation(long testParam); // TypedArray attribute attribute Float32Array typedArrayAttr; [EnabledAtRuntime=DOMIterator] iterable; // Methods void voidMethod(); void voidMethodWithArgs(long longArg, DOMString strArg, TestObj objArg); byte byteMethod(); byte byteMethodWithArgs(byte byteArg, DOMString strArg, TestObj objArg); octet octetMethod(); octet octetMethodWithArgs(octet octetArg, DOMString strArg, TestObj objArg); long longMethod(); long longMethodWithArgs(long longArg, DOMString strArg, TestObj objArg); TestObj objMethod(); TestObj objMethodWithArgs(long longArg, DOMString strArg, TestObj objArg); [Unforgeable] long unforgeableMethod(); void methodWithArgTreatingNullAsEmptyString([TreatNullAs=EmptyString] DOMString arg); void methodWithXPathNSResolverParameter(XPathNSResolver resolver); // Nullable String return values. DOMString? nullableStringMethod(); static DOMString? nullableStringStaticMethod(); getter DOMString? nullableStringSpecialMethod(unsigned long index); void methodWithEnumArg(TestEnumType enumArg); void methodWithOptionalEnumArg(optional TestEnumType enumArg); void methodWithOptionalEnumArgAndDefaultValue(optional TestEnumType enumArg = "EnumValue1"); [RaisesException] TestObj methodThatRequiresAllArgsAndThrows(DOMString strArg, TestObj objArg); void serializedValue(SerializedScriptValue serializedArg); void optionsObject(Dictionary oo, optional Dictionary ooo); // Exceptions [RaisesException] void methodWithException(); [RaisesExceptionWithMessage] void methodWithExceptionWithMessage(); [GetterRaisesException] attribute long attrWithGetterException; [GetterRaisesExceptionWithMessage] attribute long attrWithGetterExceptionWithMessage; [SetterRaisesException] attribute long attrWithSetterException; [SetterRaisesExceptionWithMessage] attribute long attrWithSetterExceptionWithMessage; [GetterRaisesException] attribute DOMString stringAttrWithGetterException; [SetterRaisesException] attribute DOMString stringAttrWithSetterException; // Strict type checking. [StrictTypeChecking] attribute TestObj? strictTypeCheckingAttribute; // 'Custom' extended attribute [Custom] attribute long customAttr; [Custom] void customMethod(); [Custom] void customMethodWithArgs(long longArg, DOMString strArg, TestObj objArg); // 'JSBuiltin' extended attribute [Conditional=Condition3, JSBuiltin] void jsBuiltinMethod(); [Conditional=Condition3, JSBuiltin] void jsBuiltinMethodWithArgs(long longArg, DOMString strArg, TestObj objArg); [Conditional=Condition4, JSBuiltin] attribute TestObj jsBuiltinAttribute; [Conditional=Condition4, JSBuiltin] readonly attribute TestObj jsBuiltinReadOnlyAttribute; // Private extended attribute [PrivateIdentifier] DOMString privateMethod(DOMString argument); [PrivateIdentifier, PublicIdentifier] DOMString publicAndPrivateMethod(DOMString argument); void addEventListener(DOMString type, EventListener listener, optional boolean useCapture = false); void removeEventListener(DOMString type, EventListener listener, optional boolean useCapture = false); attribute EventHandler onfoo; [ImplementedAs=onfoo] attribute EventHandler onwebkitfoo; // 'CallWith' extended attribute [CallWith=ScriptState] void withScriptStateVoid(); [CallWith=ScriptState] TestObj withScriptStateObj(); [CallWith=ScriptState, RaisesException] void withScriptStateVoidException(); [CallWith=ScriptState, RaisesException] TestObj withScriptStateObjException(); [CallWith=ScriptExecutionContext] void withScriptExecutionContext(); [CallWith=ScriptExecutionContext&ScriptState] void withScriptExecutionContextAndScriptState(); [CallWith=ScriptExecutionContext&ScriptState, RaisesException] TestObj withScriptExecutionContextAndScriptStateObjException(); [CallWith= ScriptExecutionContext & ScriptState ] TestObj withScriptExecutionContextAndScriptStateWithSpaces(); [CallWith=ScriptArguments&CallStack] void withScriptArgumentsAndCallStack(); [CallWith=Document] void withDocumentArgument(); [CallWith=CallerDocument] void withCallerDocumentArgument(); [CallWith=CallerWindow] void withCallerWindowArgument(); [CallWith=ScriptState] attribute long withScriptStateAttribute; [CallWith=ScriptState, SetterCallWith=ActiveWindow&FirstWindow] attribute long withCallWithAndSetterCallWithAttribute; [CallWith=ScriptExecutionContext] attribute TestObj withScriptExecutionContextAttribute; [CallWith=ScriptState, GetterRaisesException] attribute TestObj withScriptStateAttributeRaises; [CallWith=ScriptExecutionContext, GetterRaisesException] attribute TestObj withScriptExecutionContextAttributeRaises; [CallWith=ScriptExecutionContext&ScriptState] attribute TestObj withScriptExecutionContextAndScriptStateAttribute; [CallWith=ScriptExecutionContext&ScriptState,GetterRaisesException] attribute TestObj withScriptExecutionContextAndScriptStateAttributeRaises; [CallWith= ScriptExecutionContext & ScriptState ] attribute TestObj withScriptExecutionContextAndScriptStateWithSpacesAttribute; [CallWith=ScriptArguments&CallStack] attribute TestObj withScriptArgumentsAndCallStackAttribute; // Optional parameters. void methodWithOptionalArg(optional long opt); void methodWithOptionalArgAndDefaultValue(optional long opt = 666); void methodWithNonOptionalArgAndOptionalArg(long nonOpt, optional long opt); void methodWithNonOptionalArgAndTwoOptionalArgs(long nonOpt, optional long opt1, optional long opt2); void methodWithOptionalString(optional DOMString str); void methodWithOptionalAtomicString([AtomicString] optional DOMString str); void methodWithOptionalStringAndDefaultValue(optional DOMString str = "foo"); void methodWithOptionalAtomicStringAndDefaultValue([AtomicString] optional DOMString str = "foo"); void methodWithOptionalStringIsNull(optional DOMString str = null); void methodWithOptionalStringIsUndefined(optional DOMString str = "undefined"); void methodWithOptionalAtomicStringIsNull([AtomicString] optional DOMString str = null); void methodWithOptionalStringIsEmptyString(optional DOMString str = ""); void methodWithOptionalAtomicStringIsEmptyString([AtomicString] optional DOMString str = ""); void methodWithOptionalDoubleIsNaN(optional unrestricted double number = NaN); void methodWithOptionalFloatIsNaN(optional unrestricted float number = NaN); void methodWithOptionalSequence(optional sequence sequence = []); void methodWithOptionalLongLong(optional long long number); void methodWithOptionalLongLongIsZero(optional long long number = 0); void methodWithOptionalUnsignedLongLong(optional unsigned long long number); void methodWithOptionalUnsignedLongLongIsZero(optional unsigned long long number = 0); void methodWithOptionalArray(optional DOMString[] array); void methodWithOptionalArrayIsEmpty(optional DOMString[] array = []); void methodWithOptionalBoolean(optional boolean b); void methodWithOptionalBooleanIsFalse(optional boolean b = false); void methodWithOptionalAny(optional any a); void methodWithOptionalNullableWrapper(optional TestObj? obj); void methodWithOptionalNullableWrapperIsNull(optional TestObj? obj = null); void methodWithOptionalXPathNSResolver(optional XPathNSResolver? resolver); #if defined(TESTING_JS) // Callback interface parameters. void methodWithCallbackArg(TestCallback callback); void methodWithNonCallbackArgAndCallbackArg(long nonCallback, TestCallback callback); void methodWithCallbackAndOptionalArg(optional TestCallback? callback); // Callback function parameters. void methodWithCallbackFunctionArg(TestCallbackFunction callback); void methodWithNonCallbackArgAndCallbackFunctionArg(long nonCallback, TestCallbackFunction callback); void methodWithCallbackFunctionAndOptionalArg(optional TestCallbackFunction? callback); // static methods with 'Callback' extended attribute static void staticMethodWithCallbackAndOptionalArg(optional TestCallback? callback); static void staticMethodWithCallbackArg(TestCallback callback); #endif // 'Conditional' extended attribute [Conditional=Condition1] attribute long conditionalAttr1; [Conditional=Condition1&Condition2] attribute long conditionalAttr2; [Conditional=Condition1|Condition2] attribute long conditionalAttr3; // 'Conditional' extended method [Conditional=Condition1] DOMString conditionalMethod1(); [Conditional=Condition1&Condition2] void conditionalMethod2(); [Conditional=Condition1|Condition2] void conditionalMethod3(); [Conditional=Condition1] attribute TestObjectAConstructor conditionalAttr4; [Conditional=Condition1&Condition2] attribute TestObjectBConstructor conditionalAttr5; [Conditional=Condition1|Condition2] attribute TestObjectCConstructor conditionalAttr6; [Conditional=Condition1] const unsigned short CONDITIONAL_CONST = 0; #if defined(TESTING_JS) [CachedAttribute] readonly attribute any cachedAttribute1; [CachedAttribute] readonly attribute any cachedAttribute2; #endif attribute any anyAttribute; #if defined(TESTING_JS) // Overloads void overloadedMethod(TestObj? objArg, [StrictTypeChecking] DOMString strArg); void overloadedMethod(TestObj? objArg, optional long longArg); void overloadedMethod([StrictTypeChecking] DOMString strArg); void overloadedMethod(long longArg); void overloadedMethod(TestCallback callback); void overloadedMethod(DOMStringList? listArg); void overloadedMethod(DOMString[]? arrayArg); void overloadedMethod(TestObj objArg); void overloadedMethod(DOMString[] arrayArg); void overloadedMethod(sequence arrayArg); void overloadedMethod(DOMString strArg); // FIXME: Implement support for overloaded functions with variadic arguments. void overloadedMethod(Blob... blobArgs); void overloadedMethodWithOptionalParameter(TestObj? objArg1, optional TestObj? objArg2 = null); void overloadedMethodWithOptionalParameter(TestObj? objArg, optional long longArg); #endif // Class methods within JavaScript (like what's used for IDBKeyRange). static void classMethod(); static long classMethodWithOptional(optional long arg); [Custom] static void classMethod2(long arg); // Static method with conditional on overloaded methods [Conditional=Condition1] static void overloadedMethod1(long arg); [Conditional=Condition1] static void overloadedMethod1([StrictTypeChecking] DOMString type); void classMethodWithClamp([Clamp] unsigned short objArgsShort, [Clamp] unsigned long objArgsLong); void classMethodWithEnforceRange([EnforceRange] unsigned short objArgsShort, [EnforceRange] unsigned long objArgsLong); #if defined(TESTING_JS) void methodWithUnsignedLongSequence(sequence unsignedLongSequence); [RaisesException] DOMString[] stringArrayFunction(DOMString[] values); [RaisesException] DOMStringList domStringListFunction(DOMStringList values); void methodWithAndWithoutNullableSequence(sequence arrayArg, sequence? nullableArrayArg); void methodWithAndWithoutNullableSequence2(unsigned long[] arrayArg, unsigned long[]? nullableArrayArg); Element? getElementById([RequiresExistingAtomicString] DOMString elementId); #endif [CheckSecurityForNode] readonly attribute Document contentDocument; [CheckSecurityForNode, RaisesException] SVGDocument getSVGDocument(); void convert1(TestNode value); void convert2(TestNode? value); void convert3(DOMString value); void convert4(DOMString? value); attribute SVGPoint mutablePoint; [Immutable] attribute SVGPoint immutablePoint; SVGPoint mutablePointFunction(); [Immutable] SVGPoint immutablePointFunction(); [ImplementedAs=banana] void orange(); [ImplementedAs=blueberry] attribute long strawberry; [StrictTypeChecking] attribute unrestricted float strictFloat; [StrictTypeChecking, RaisesException] boolean strictFunction(DOMString str, unrestricted float a, long b); [StrictTypeChecking, RaisesException] boolean strictFunctionWithSequence(TestObj? objArg, sequence a); [StrictTypeChecking, RaisesException] boolean strictFunctionWithArray(TestObj objArg, long[] array); // ObjectiveC reserved words. readonly attribute long description; attribute long id; readonly attribute DOMString hash; // Check constants and enums. const unsigned short CONST_VALUE_0 = 0; const unsigned short CONST_VALUE_1 = 1; const unsigned short CONST_VALUE_2 = 2; const unsigned short CONST_VALUE_4 = 4; const unsigned short CONST_VALUE_8 = 8; const short CONST_VALUE_9 = -1; const unsigned short CONST_VALUE_11 = 0xffffffff; const unsigned short CONST_VALUE_12 = 0x01; const unsigned short CONST_VALUE_13 = 0X20; const unsigned short CONST_VALUE_14 = 0x1abc; [Reflect=CONST_IMPL] const unsigned short CONST_JAVASCRIPT = 15; [Replaceable] readonly attribute long replaceableAttribute; void variadicStringMethod(DOMString head, DOMString... tail); void variadicDoubleMethod(unrestricted double head, unrestricted double... tail); void variadicNodeMethod(Node head, Node... tail); // Nullable attributes. readonly attribute unrestricted double? nullableDoubleAttribute; readonly attribute long? nullableLongAttribute; readonly attribute boolean? nullableBooleanAttribute; readonly attribute DOMString? nullableStringAttribute; attribute long? nullableLongSettableAttribute; attribute DOMString? nullableStringSettableAttribute; [GetterRaisesException] attribute long? nullableStringValue; // Identifiers with a leading underscore, which should be removed. const unsigned short _readonly = 0; readonly attribute DOMString _attribute; attribute _optional attributeWithReservedEnumType; void _any(unrestricted float a, long b); // Promise function Promise testPromiseFunction(); Promise testPromiseFunctionWithFloatArgument(float a); [RaisesException] Promise testPromiseFunctionWithException(); Promise testPromiseFunctionWithOptionalIntArgument(optional long a); Promise testPromiseOverloadedFunction(float a); Promise testPromiseOverloadedFunction(FetchRequest request); static Promise testStaticPromiseFunction(); [RaisesException] static Promise testStaticPromiseFunctionWithException(); // PutForwards [PutForwards=name] readonly attribute TestNode putForwardsAttribute; [PutForwards=name] readonly attribute TestNode? putForwardsNullableAttribute; #if defined(TESTING_JS) [InvokesCustomElementLifecycleCallbacks] void methodWithNeedsLifecycleProcessingStack(); #endif void attachShadowRoot(TestDictionary init); }; // The following comment should not generate any code. // TestObj implements TestImplements; dictionary TestDictionary { TestEnumType enumerationValueWithoutDefault; TestEnumType enumerationValueWithDefault = "enumValue1"; TestEnumType enumerationValueWithEmptyStringDefault = ""; DOMString stringWithDefault = "defaultString"; DOMString stringWithoutDefault; boolean booleanWithDefault = false; boolean booleanWithoutDefault; sequence sequenceOfStrings; double restrictedDouble; unrestricted double unrestrictedDouble; double restrictedDoubleWithDefault = 0; unrestricted double unrestrictedDoubleWithDefault = 0; float restrictedFloat; unrestricted float unrestrictedFloat; float restrictedFloatWithDefault = 0; unrestricted float unrestrictedFloatWithDefault = 0; [Clamp] byte smallIntegerClamped; byte smallIntegerWithDefault; [EnforceRange] octet smallUnsignedIntegerEnforcedRange; octet smallUnsignedIntegerWithDefault = 0; long integer; long integerWithDefault = 0; unsigned long unsignedInteger; unsigned long unsignedIntegerWithDefault = 0; long long largeInteger; long long largeIntegerWithDefault = 0; unsigned long long unsignedLargeInteger; unsigned long long unsignedLargeIntegerWithDefault = 0; }; dictionary TestDictionaryThatShouldNotTolerateNull { required TestEnumType requiredEnumerationValue; boolean booleanWithoutDefault; }; dictionary TestDictionaryThatShouldTolerateNull { TestEnumType enumerationValue; boolean booleanWithoutDefault; };