Update script to fetch new WebCore IDL

third_party/WebCore/bindings/scripts/test/TestObj.idl

Index: third_party/WebCore/bindings/scripts/test/TestObj.idl
diff --git a/third_party/WebCore/bindings/scripts/test/TestObj.idl b/third_party/WebCore/bindings/scripts/test/TestObj.idl
new file mode 100644
index 0000000000000000000000000000000000000000..ed849ad891a3a113aa0758d02479c6f45eda39c3
--- /dev/null
+++ b/third_party/WebCore/bindings/scripts/test/TestObj.idl
@@ -0,0 +1,244 @@
+/*
+ * 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 Computer, 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 WARRANTIEstrArg, 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.
+module test {
+    interface [
+        Constructor(in [Callback] TestCallback testCallback),
+        InterfaceName=TestObject
+    ] TestObj {
+        // Attributes
+        readonly attribute long            readOnlyIntAttr;
+        readonly attribute DOMString       readOnlyStringAttr;
+        readonly attribute TestObj         readOnlyTestObjAttr;
+        attribute short                    shortAttr;
+        attribute unsigned short           unsignedShortAttr;
+        attribute long                     intAttr;
+        attribute long long                longLongAttr;
+        attribute unsigned long long       unsignedLongLongAttr;
+        attribute DOMString                stringAttr;
+        attribute TestObj                  testObjAttr;
+        attribute sequence<ScriptProfile>  sequenceAttr;
+
+        JS, V8
+        // WK_ucfirst, WK_lcfirst exceptional cases.
+        attribute TestObj                  XMLObjAttr;
+        attribute boolean                  create;
+
+        // Reflected DOM attributes
+        attribute [Reflect] DOMString reflectedStringAttr;
+        attribute [Reflect] long reflectedIntegralAttr;
+        attribute [Reflect] unsigned long reflectedUnsignedIntegralAttr;
+        attribute [Reflect] boolean reflectedBooleanAttr;
+        attribute [Reflect, URL] DOMString reflectedURLAttr;
+        attribute [Reflect=customContentStringAttr] DOMString reflectedStringAttr;
+        attribute [Reflect=customContentIntegralAttr] long reflectedCustomIntegralAttr;
+        attribute [Reflect=customContentBooleanAttr] boolean reflectedCustomBooleanAttr;
+        attribute [Reflect=customContentURLAttr, URL] DOMString reflectedCustomURLAttr;
+
+        // Methods
+        void    voidMethod();
+        void    voidMethodWithArgs(in long intArg, in DOMString strArg, in TestObj objArg);
+        long    intMethod();
+        long    intMethodWithArgs(in long intArg, in DOMString strArg, in TestObj objArg);
+        TestObj objMethod();
+        TestObj objMethodWithArgs(in long intArg, in DOMString strArg, in TestObj objArg);
+
+        void methodWithSequenceArg(in sequence<ScriptProfile> sequenceArg);
+        sequence<ScriptProfile> methodReturningSequence(in long intArg);
+
+        TestObj methodThatRequiresAllArgsAndThrows(in DOMString strArg, in TestObj objArg)
+            raises(DOMException);
+
+        void serializedValue(in SerializedScriptValue serializedArg);
+        void idbKey(in IDBKey key);
+        void optionsObject(in Dictionary oo, in [Optional] Dictionary ooo);
+
+        // Exceptions
+        void methodWithException() raises(DOMException);
+        attribute long attrWithGetterException getter raises(DOMException);
+        attribute long attrWithSetterException setter raises(DOMException);
+        attribute DOMString stringAttrWithGetterException getter raises(DOMException);
+        attribute DOMString stringAttrWithSetterException setter raises(DOMException);
+
+        // 'Custom' extended attribute
+        attribute [Custom] long            customAttr;
+        [Custom] void customMethod();
+        [Custom] void customMethodWithArgs(in long intArg, in DOMString strArg, in TestObj objArg);
+
+        void addEventListener(in DOMString type, 
+                              in EventListener listener, 
+                              in [Optional] boolean useCapture);
+        void removeEventListener(in DOMString type, 
+                                 in EventListener listener, 
+                                 in [Optional] boolean useCapture);
+
+        // 'CallWith' extended attribute
+        [CallWith=ScriptState] void withScriptStateVoid();
+        [CallWith=ScriptState] TestObj withScriptStateObj();
+        [CallWith=ScriptState] void withScriptStateVoidException()
+            raises(DOMException);
+        [CallWith=ScriptState] TestObj withScriptStateObjException()
+            raises(DOMException);
+        [CallWith=ScriptExecutionContext] void withScriptExecutionContext();
+        [CallWith=ScriptExecutionContext|ScriptState] void withScriptExecutionContextAndScriptState();
+        [CallWith=ScriptExecutionContext|ScriptState] TestObj withScriptExecutionContextAndScriptStateObjException()
+            raises(DOMException);
+        [CallWith=  ScriptExecutionContext  |  ScriptState  ] TestObj withScriptExecutionContextAndScriptStateWithSpaces();
+        [CallWith=ScriptArguments|CallStack] void withScriptArgumentsAndCallStack();
+
+        attribute [CallWith=ScriptState] long withScriptStateAttribute;
+        attribute [CallWith=ScriptExecutionContext] TestObj withScriptExecutionContextAttribute;
+        attribute [CallWith=ScriptState] TestObj withScriptStateAttributeRaises
+            getter raises(DOMException);
+        attribute [CallWith=ScriptExecutionContext] TestObj withScriptExecutionContextAttributeRaises
+            getter raises(DOMException);
+        attribute [CallWith=ScriptExecutionContext|ScriptState] TestObj withScriptExecutionContextAndScriptStateAttribute;
+        attribute [CallWith=ScriptExecutionContext|ScriptState] TestObj withScriptExecutionContextAndScriptStateAttributeRaises
+            getter raises(DOMException);
+        attribute [CallWith=  ScriptExecutionContext  |  ScriptState  ] TestObj withScriptExecutionContextAndScriptStateWithSpacesAttribute;
+        attribute [CallWith=ScriptArguments|CallStack] TestObj withScriptArgumentsAndCallStackAttribute;
+
+        // 'Optional' extended attribute
+        void    methodWithOptionalArg(in [Optional] long opt);
+        void    methodWithNonOptionalArgAndOptionalArg(in long nonOpt, in [Optional] long opt);
+        void    methodWithNonOptionalArgAndTwoOptionalArgs(in long nonOpt, in [Optional] long opt1, in [Optional] long opt2);
+        void    methodWithOptionalString(in [Optional] DOMString str);
+        void    methodWithOptionalStringIsUndefined(in [Optional=DefaultIsUndefined] DOMString str);
+        void    methodWithOptionalStringIsNullString(in [Optional=DefaultIsNullString] DOMString str);
+
+#if defined(TESTING_V8) || defined(TESTING_JS)
+        // 'Callback' extended attribute
+        void    methodWithCallbackArg(in [Callback] TestCallback callback);
+        void    methodWithNonCallbackArgAndCallbackArg(in long nonCallback, in [Callback] TestCallback callback);
+        void    methodWithCallbackAndOptionalArg(in [Callback, Optional] TestCallback callback);
+#endif
+
+        // 'Conditional' extended attribute
+        attribute [Conditional=Condition1] long conditionalAttr1;
+        attribute [Conditional=Condition1&Condition2] long conditionalAttr2;
+        attribute [Conditional=Condition1|Condition2] long conditionalAttr3;
+
+        // 'Conditional' extended method
+        [Conditional=Condition1] DOMString conditionalMethod1();
+        [Conditional=Condition1&Condition2] void conditionalMethod2();
+        [Conditional=Condition1|Condition2] void conditionalMethod3();
+
+        attribute [Conditional=Condition1] TestObjectAConstructor conditionalAttr4;
+        attribute [Conditional=Condition1&Condition2] TestObjectBConstructor conditionalAttr5;
+        attribute [Conditional=Condition1|Condition2] TestObjectCConstructor conditionalAttr6;
+
+        [Conditional=Condition1] const unsigned short CONDITIONAL_CONST = 0;
+
+#if defined(TESTING_V8) || defined(TESTING_JS)
+        readonly attribute [CachedAttribute] any cachedAttribute1;
+        readonly attribute [CachedAttribute] any cachedAttribute2;
+#endif
+
+#if defined(TESTING_V8) || defined(TESTING_JS)
+        // Overloads
+        void    overloadedMethod(in TestObj objArg, in DOMString strArg);
+        void    overloadedMethod(in TestObj objArg, in [Optional] long intArg);
+        void    overloadedMethod(in DOMString strArg);
+        void    overloadedMethod(in long intArg);
+        void    overloadedMethod(in [Callback] TestCallback callback);
+        void    overloadedMethod(in DOMStringList listArg);
+        void    overloadedMethod(in DOMString[] arrayArg);
+#endif
+
+        // Class methods within JavaScript (like what's used for IDBKeyRange).
+        static void classMethod();
+        static long classMethodWithOptional(in [Optional] long arg);
+        [Custom] static void classMethod2(in long arg);
+
+        // Static method with conditional on overloaded methods
+        [Conditional=Condition1] static void overloadedMethod1(in long arg);
+        [Conditional=Condition1] static void overloadedMethod1(in DOMString type);
+
+#if defined(TESTING_V8)
+        // 'V8EnabledAtRuntime' methods and attributes.
+        [V8EnabledAtRuntime] void enabledAtRuntimeMethod1(in int intArg);
+        [V8EnabledAtRuntime=FeatureName] void enabledAtRuntimeMethod2(in int intArg);
+        attribute [V8EnabledAtRuntime] long enabledAtRuntimeAttr1;
+        attribute [V8EnabledAtRuntime=FeatureName] long enabledAtRuntimeAttr2;
+#endif
+
+
+#if defined(TESTING_V8)
+        attribute float[]                   floatArray;
+        attribute double[]                  doubleArray;
+#endif
+
+#if defined(TESTING_JS)
+        void methodWithUnsignedLongArray(in unsigned long[] unsignedLongArray);
+#endif
+
+        readonly attribute [CheckSecurityForNode] Document contentDocument;
+        [CheckSecurityForNode] SVGDocument getSVGDocument()
+            raises(DOMException);
+
+        void convert1(in [TreatReturnedNullStringAs=Null] a);
+        void convert2(in [TreatReturnedNullStringAs=Undefined] b);
+        void convert3(in [TreatReturnedNullStringAs=False] c);
+        void convert4(in [TreatNullAs=NullString] d);
+        void convert5(in [TreatNullAs=NullString, TreatUndefinedAs=NullString] e);
+
+        attribute SVGPoint mutablePoint;
+        attribute [Immutable] SVGPoint immutablePoint;
+        SVGPoint mutablePointFunction();
+        [Immutable] SVGPoint immutablePointFunction();
+
+        [ImplementedAs=banana] void orange();
+        attribute [ImplementedAs=blueberry] int strawberry;
+
+        attribute [StrictTypeChecking] float strictFloat;
+        [StrictTypeChecking] bool strictFunction(in DOMString str, in float a, in int b)
+            raises(DOMException);
+
+        // 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 DOMString CONST_VALUE_10 = "my constant string";
+        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;
+    };
+}