Rebaseline bindings test results after r150554.

Source/bindings/tests/results/V8TestObject.cpp

 /*
     This file is part of the Blink open source project.
     This file has been auto-generated by CodeGeneratorV8.pm. DO NOT MODIFY!
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
@@ skipping 2310 matching lines @@
 static v8::Handle<v8::Value> voidMethodMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::voidMethodMethod(args);
 }
 
 static v8::Handle<v8::Value> voidMethodWithArgsMethod(const v8::Arguments& args)
 {
     if (args.Length() < 3)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]);
     V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[2], args.GetIsolate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Object>::Cast(args[2])) : 0);
     imp->voidMethodWithArgs(longArg, strArg, objArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> voidMethodWithArgsMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::voidMethodWithArgsMethod(args);
 }
 
 static v8::Handle<v8::Value> longMethodMethod(const v8::Arguments& args)
 {
     TestObj* imp = V8TestObject::toNative(args.Holder());
     return v8Integer(imp->longMethod(), args.GetIsolate());
 }
 
 static v8::Handle<v8::Value> longMethodMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::longMethodMethod(args);
 }
 
 static v8::Handle<v8::Value> longMethodWithArgsMethod(const v8::Arguments& args)
 {
     if (args.Length() < 3)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]);
     V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[2], args.GetIsolate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Object>::Cast(args[2])) : 0);
     return v8Integer(imp->longMethodWithArgs(longArg, strArg, objArg), args.GetIsolate());
 }
 
 static v8::Handle<v8::Value> longMethodWithArgsMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::longMethodWithArgsMethod(args);
 }
 
 static v8::Handle<v8::Value> objMethodMethod(const v8::Arguments& args)
 {
     TestObj* imp = V8TestObject::toNative(args.Holder());
     return toV8(imp->objMethod(), args.Holder(), args.GetIsolate());
 }
 
 static v8::Handle<v8::Value> objMethodMethodCallback(const v8::Arguments& args)
 {
     UseCounter::count(activeDOMWindow(), UseCounter::TestFeature);
     return TestObjV8Internal::objMethodMethod(args);
 }
 
 static v8::Handle<v8::Value> objMethodWithArgsMethod(const v8::Arguments& args)
 {
     if (args.Length() < 3)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]);
     V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[2], args.GetIsolate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Object>::Cast(args[2])) : 0);
     return toV8(imp->objMethodWithArgs(longArg, strArg, objArg), args.Holder(), args.GetIsolate());
 }
 
 static v8::Handle<v8::Value> objMethodWithArgsMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::objMethodWithArgsMethod(args);
 }
 
 static v8::Handle<v8::Value> methodWithSequenceArgMethod(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(Vector<RefPtr<ScriptProfile> >, sequenceArg, (toRefPtrNativeArray<ScriptProfile, V8ScriptProfile>(args[0], args.GetIsolate())));
     imp->methodWithSequenceArg(sequenceArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> methodWithSequenceArgMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodWithSequenceArgMethod(args);
 }
 
 static v8::Handle<v8::Value> methodReturningSequenceMethod(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     return v8Array(imp->methodReturningSequence(longArg), args.GetIsolate());
 }
 
 static v8::Handle<v8::Value> methodReturningSequenceMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodReturningSequenceMethod(args);
 }
 
 static v8::Handle<v8::Value> methodWithEnumArgMethod(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, enumArg, args[0]);
     String string = enumArg;
     if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || string == "EnumValue3"))
         return throwTypeError(0, args.GetIsolate());
     imp->methodWithEnumArg(enumArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> methodWithEnumArgMethodCallback(const v8::Arguments& args)
 {
@@ skipping 17 matching lines @@
 static v8::Handle<v8::Value> methodThatRequiresAllArgsAndThrowsMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodThatRequiresAllArgsAndThrowsMethod(args);
 }
 
 static v8::Handle<v8::Value> serializedValueMethod(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     bool serializedArgDidThrow = false;
     RefPtr<SerializedScriptValue> serializedArg = SerializedScriptValue::create(args[0], 0, 0, serializedArgDidThrow, args.GetIsolate());
     if (serializedArgDidThrow)
         return v8Undefined();
     imp->serializedValue(serializedArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> serializedValueMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::serializedValueMethod(args);
 }
 
 static v8::Handle<v8::Value> optionsObjectMethod(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(Dictionary, oo, Dictionary(args[0], args.GetIsolate()));
     if (!oo.isUndefinedOrNull() && !oo.isObject())
         return throwTypeError("Not an object.", args.GetIsolate());
     V8TRYCATCH(Dictionary, ooo, Dictionary(args[1], args.GetIsolate()));
     if (!ooo.isUndefinedOrNull() && !ooo.isObject())
         return throwTypeError("Not an object.", args.GetIsolate());
     imp->optionsObject(oo, ooo);
     return v8Undefined();
 }
 
@@ skipping 228 matching lines @@
 }
 
 static v8::Handle<v8::Value> withScriptExecutionContextAndScriptStateWithSpacesMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::withScriptExecutionContextAndScriptStateWithSpacesMethod(args);
 }
 
 static v8::Handle<v8::Value> methodWithOptionalArgMethod(const v8::Arguments& args)
 {
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     if (args.Length() <= 0) {
         imp->methodWithOptionalArg();
         return v8Undefined();
     }
     V8TRYCATCH(int, opt, toInt32(args[0]));
     imp->methodWithOptionalArg(opt);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> methodWithOptionalArgMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodWithOptionalArgMethod(args);
 }
 
 static v8::Handle<v8::Value> methodWithNonOptionalArgAndOptionalArgMethod(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, nonOpt, toInt32(args[0]));
     if (args.Length() <= 1) {
         imp->methodWithNonOptionalArgAndOptionalArg(nonOpt);
         return v8Undefined();
     }
     V8TRYCATCH(int, opt, toInt32(args[1]));
     imp->methodWithNonOptionalArgAndOptionalArg(nonOpt, opt);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> methodWithNonOptionalArgAndOptionalArgMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodWithNonOptionalArgAndOptionalArgMethod(args);
 }
 
 static v8::Handle<v8::Value> methodWithNonOptionalArgAndTwoOptionalArgsMethod(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, nonOpt, toInt32(args[0]));
     if (args.Length() <= 1) {
         imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt);
         return v8Undefined();
     }
     V8TRYCATCH(int, opt1, toInt32(args[1]));
     if (args.Length() <= 2) {
         imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt, opt1);
         return v8Undefined();
     }
     V8TRYCATCH(int, opt2, toInt32(args[2]));
     imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt, opt1, opt2);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> methodWithNonOptionalArgAndTwoOptionalArgsMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodWithNonOptionalArgAndTwoOptionalArgsMethod(args);
 }
 
 static v8::Handle<v8::Value> methodWithOptionalStringMethod(const v8::Arguments& args)
 {
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     if (args.Length() <= 0) {
         imp->methodWithOptionalString();
         return v8Undefined();
     }
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, args[0]);
     imp->methodWithOptionalString(str);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> methodWithOptionalStringMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodWithOptionalStringMethod(args);
 }
 
 static v8::Handle<v8::Value> methodWithOptionalStringIsUndefinedMethod(const v8::Arguments& args)
 {
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, args[0]);
     imp->methodWithOptionalStringIsUndefined(str);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> methodWithOptionalStringIsUndefinedMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodWithOptionalStringIsUndefinedMethod(args);
 }
 
 static v8::Handle<v8::Value> methodWithOptionalStringIsNullStringMethod(const v8::Arguments& args)
 {
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, argumentOrNull(args, 0));
     imp->methodWithOptionalStringIsNullString(str);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> methodWithOptionalStringIsNullStringMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodWithOptionalStringIsNullStringMethod(args);
 }
 
@@ skipping 12 matching lines @@
 static v8::Handle<v8::Value> methodWithCallbackArgMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodWithCallbackArgMethod(args);
 }
 
 static v8::Handle<v8::Value> methodWithNonCallbackArgAndCallbackArgMethod(const v8::Arguments& args)
 {
     if (args.Length() < 2)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, nonCallback, toInt32(args[0]));
     if (args.Length() <= 1 || !args[1]->IsFunction())
         return throwTypeError(0, args.GetIsolate());
     RefPtr<TestCallback> callback = V8TestCallback::create(args[1], getScriptExecutionContext());
     imp->methodWithNonCallbackArgAndCallbackArg(nonCallback, callback);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> methodWithNonCallbackArgAndCallbackArgMethodCallback(const v8::Arguments& args)
 {
@@ skipping 49 matching lines @@
 static v8::Handle<v8::Value> staticMethodWithCallbackArgMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::staticMethodWithCallbackArgMethod(args);
 }
 
 static v8::Handle<v8::Value> methodWithEnforceRangeInt32Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH_WITH_TYPECHECK(int, value, toInt32(args[0], EnforceRange, ok), args.GetIsolate());
     imp->methodWithEnforceRangeInt32(value);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> methodWithEnforceRangeInt32MethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodWithEnforceRangeInt32Method(args);
 }
 
 static v8::Handle<v8::Value> methodWithEnforceRangeUInt32Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH_WITH_TYPECHECK(unsigned, value, toUInt32(args[0], EnforceRange, ok), args.GetIsolate());
     imp->methodWithEnforceRangeUInt32(value);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> methodWithEnforceRangeUInt32MethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodWithEnforceRangeUInt32Method(args);
 }
 
 static v8::Handle<v8::Value> methodWithEnforceRangeInt64Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH_WITH_TYPECHECK(long long, value, toInt64(args[0], EnforceRange, ok), args.GetIsolate());
     imp->methodWithEnforceRangeInt64(value);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> methodWithEnforceRangeInt64MethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodWithEnforceRangeInt64Method(args);
 }
 
 static v8::Handle<v8::Value> methodWithEnforceRangeUInt64Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH_WITH_TYPECHECK(unsigned long long, value, toUInt64(args[0], EnforceRange, ok), args.GetIsolate());
     imp->methodWithEnforceRangeUInt64(value);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> methodWithEnforceRangeUInt64MethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodWithEnforceRangeUInt64Method(args);
 }
 
@@ skipping 54 matching lines @@
     return TestObjV8Internal::conditionalMethod3Method(args);
 }
 
 #endif // ENABLE(Condition1) || ENABLE(Condition2)
 
 static v8::Handle<v8::Value> overloadedMethod1Method(const v8::Arguments& args)
 {
     if (args.Length() < 2)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]);
     imp->overloadedMethod(objArg, strArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedMethod2Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
     if (args.Length() <= 1) {
         imp->overloadedMethod(objArg);
         return v8Undefined();
     }
     V8TRYCATCH(int, longArg, toInt32(args[1]));
     imp->overloadedMethod(objArg, longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedMethod3Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]);
     imp->overloadedMethod(strArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedMethod4Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     imp->overloadedMethod(longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedMethod5Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
     if (args.Length() <= 0 || !args[0]->IsFunction())
         return throwTypeError(0, args.GetIsolate());
     RefPtr<TestCallback> callback = V8TestCallback::create(args[0], getScriptExecutionContext());
     imp->overloadedMethod(callback);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedMethod6Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(RefPtr<DOMStringList>, listArg, toDOMStringList(args[0], args.GetIsolate()));
     imp->overloadedMethod(listArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedMethod7Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(Vector<String>, arrayArg, toNativeArray<String>(args[0]));
     imp->overloadedMethod(arrayArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedMethod8Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
     imp->overloadedMethod(objArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedMethod9Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(Vector<String>, arrayArg, toNativeArray<String>(args[0]));
     imp->overloadedMethod(arrayArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedMethod10Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(Vector<unsigned>, arrayArg, toNativeArray<unsigned>(args[0]));
     imp->overloadedMethod(arrayArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedMethod11Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]);
     imp->overloadedMethod(strArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedMethodMethod(const v8::Arguments& args)
 {
     if ((args.Length() == 2 && (args[0]->IsNull() || V8TestObject::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate()))) && (args[1]->IsNull() || args[1]->IsUndefined() || args[1]->IsString() || args[1]->IsObject())))
         return overloadedMethod1Method(args);
     if ((args.Length() == 1 && (args[0]->IsNull() || V8TestObject::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())))) || (args.Length() == 2 && (args[0]->IsNull() || V8TestObject::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())))))
@@ skipping 32 matching lines @@
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> classMethodMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::classMethodMethod(args);
 }
 
 static v8::Handle<v8::Value> classMethodWithOptionalMethod(const v8::Arguments& args)
 {
-    ExceptionCode ec = 0;
     if (args.Length() <= 0)
         return v8Integer(TestObj::classMethodWithOptional(), args.GetIsolate());
 
     V8TRYCATCH(int, arg, toInt32(args[0]));
     return v8Integer(TestObj::classMethodWithOptional(arg), args.GetIsolate());
 }
 
 static v8::Handle<v8::Value> classMethodWithOptionalMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::classMethodWithOptionalMethod(args);
 }
 
 static v8::Handle<v8::Value> classMethod2MethodCallback(const v8::Arguments& args)
 {
     return V8TestObject::classMethod2MethodCustom(args);
 }
 
 #if ENABLE(Condition1)
 
 static v8::Handle<v8::Value> overloadedMethod11Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, arg, toInt32(args[0]));
     TestObj::overloadedMethod1(arg);
     return v8Undefined();
 }
 
 #endif // ENABLE(Condition1)
 
 #if ENABLE(Condition1)
 
 static v8::Handle<v8::Value> overloadedMethod12Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
-    ExceptionCode ec = 0;
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, args[0]);
     TestObj::overloadedMethod1(type);
     return v8Undefined();
 }
 
 #endif // ENABLE(Condition1)
 
 #if ENABLE(Condition1)
 
 static v8::Handle<v8::Value> overloadedMethod1Method(const v8::Arguments& args)
@@ skipping 16 matching lines @@
     return TestObjV8Internal::overloadedMethod1Method(args);
 }
 
 #endif // ENABLE(Condition1)
 
 static v8::Handle<v8::Value> classMethodWithClampMethod(const v8::Arguments& args)
 {
     if (args.Length() < 2)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     unsigned short objArgsShort = 0;
     V8TRYCATCH(double, objArgsShortNativeValue, args[0]->NumberValue());
     if (!std::isnan(objArgsShortNativeValue))
         objArgsShort = clampTo<unsigned short>(objArgsShortNativeValue);
     unsigned long objArgsLong = 0;
     V8TRYCATCH(double, objArgsLongNativeValue, args[1]->NumberValue());
     if (!std::isnan(objArgsLongNativeValue))
         objArgsLong = clampTo<unsigned long>(objArgsLongNativeValue);
     imp->classMethodWithClamp(objArgsShort, objArgsLong);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> classMethodWithClampMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::classMethodWithClampMethod(args);
 }
 
 static v8::Handle<v8::Value> enabledAtRuntimeMethod1Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     imp->enabledAtRuntimeMethod1(longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> enabledAtRuntimeMethod1MethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::enabledAtRuntimeMethod1Method(args);
 }
 
 static v8::Handle<v8::Value> enabledAtRuntimeMethod2Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     imp->enabledAtRuntimeMethod2(longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> enabledAtRuntimeMethod2MethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::enabledAtRuntimeMethod2Method(args);
 }
 
 static v8::Handle<v8::Value> enabledPerContextMethod1Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     imp->enabledPerContextMethod1(longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> enabledPerContextMethod1MethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::enabledPerContextMethod1Method(args);
 }
 
 static v8::Handle<v8::Value> enabledPerContextMethod2Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     imp->enabledPerContextMethod2(longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> enabledPerContextMethod2MethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::enabledPerContextMethod2Method(args);
 }
 
 static v8::Handle<v8::Value> methodWithUnsignedLongSequenceMethod(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(Vector<unsigned>, unsignedLongSequence, toNativeArray<unsigned>(args[0]));
     imp->methodWithUnsignedLongSequence(unsignedLongSequence);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> methodWithUnsignedLongSequenceMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::methodWithUnsignedLongSequenceMethod(args);
 }
 
@@ skipping 48 matching lines @@
 static v8::Handle<v8::Value> getSVGDocumentMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::getSVGDocumentMethod(args);
 }
 
 static v8::Handle<v8::Value> convert1Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(TestNode*, value, V8TestNode::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())) ? V8TestNode::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
     imp->convert1(value);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> convert1MethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::convert1Method(args);
 }
 
 static v8::Handle<v8::Value> convert2Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(TestNode*, value, V8TestNode::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())) ? V8TestNode::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
     imp->convert2(value);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> convert2MethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::convert2Method(args);
 }
 
 static v8::Handle<v8::Value> convert4Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(TestNode*, value, V8TestNode::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())) ? V8TestNode::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
     imp->convert4(value);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> convert4MethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::convert4Method(args);
 }
 
 static v8::Handle<v8::Value> convert5Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(TestNode*, value, V8TestNode::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())) ? V8TestNode::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
     imp->convert5(value);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> convert5MethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::convert5Method(args);
 }
 
@@ skipping 49 matching lines @@
 static v8::Handle<v8::Value> strictFunctionMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::strictFunctionMethod(args);
 }
 
 static v8::Handle<v8::Value> variadicStringMethodMethod(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, head, args[0]);
     V8TRYCATCH(Vector<String>, tail, toNativeArguments<String>(args, 1));
     imp->variadicStringMethod(head, tail);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> variadicStringMethodMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::variadicStringMethodMethod(args);
 }
 
 static v8::Handle<v8::Value> variadicDoubleMethodMethod(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(double, head, static_cast<double>(args[0]->NumberValue()));
     V8TRYCATCH(Vector<double>, tail, toNativeArguments<double>(args, 1));
     imp->variadicDoubleMethod(head, tail);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> variadicDoubleMethodMethodCallback(const v8::Arguments& args)
 {
     return TestObjV8Internal::variadicDoubleMethodMethod(args);
 }
 
 static v8::Handle<v8::Value> variadicNodeMethodMethod(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(Node*, head, V8Node::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
     Vector<RefPtr<Node> > tail;
     for (int i = 1; i < args.Length(); ++i) {
         if (!V8Node::HasInstance(args[i], args.GetIsolate(), worldType(args.GetIsolate())))
             return throwTypeError(0, args.GetIsolate());
         tail.append(V8Node::toNative(v8::Handle<v8::Object>::Cast(args[i])));
     }
     imp->variadicNodeMethod(head, tail);
     return v8Undefined();
 }
@@ skipping 25 matching lines @@
 static v8::Handle<v8::Value> perWorldMethodMethodCallbackForMainWorld(const v8::Arguments& args)
 {
     return TestObjV8Internal::perWorldMethodMethodForMainWorld(args);
 }
 
 static v8::Handle<v8::Value> overloadedPerWorldMethod1Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     imp->overloadedPerWorldMethod(longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedPerWorldMethod1MethodForMainWorld(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     imp->overloadedPerWorldMethod(longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedPerWorldMethod2Method(const v8::Arguments& args)
 {
     if (args.Length() < 2)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]);
     V8TRYCATCH(int, longArg, toInt32(args[1]));
     imp->overloadedPerWorldMethod(strArg, longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedPerWorldMethod2MethodForMainWorld(const v8::Arguments& args)
 {
     if (args.Length() < 2)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]);
     V8TRYCATCH(int, longArg, toInt32(args[1]));
     imp->overloadedPerWorldMethod(strArg, longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedPerWorldMethodMethod(const v8::Arguments& args)
 {
     if (args.Length() == 1)
         return overloadedPerWorldMethod1Method(args);
@@ skipping 23 matching lines @@
 static v8::Handle<v8::Value> overloadedPerWorldMethodMethodCallbackForMainWorld(const v8::Arguments& args)
 {
     return TestObjV8Internal::overloadedPerWorldMethodMethodForMainWorld(args);
 }
 
 static v8::Handle<v8::Value> activityLoggedMethod1Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     imp->activityLoggedMethod1(longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> activityLoggedMethod1MethodCallback(const v8::Arguments& args)
 {
     V8PerContextData* contextData = V8PerContextData::from(args.GetIsolate()->GetCurrentContext());
     if (contextData && contextData->activityLogger()) {
         Vector<v8::Handle<v8::Value> > loggerArgs = toVectorOfArguments(args);
         contextData->activityLogger()->log("TestObject.activityLoggedMethod1", args.Length(), loggerArgs.data(), "Method");
     }
     return TestObjV8Internal::activityLoggedMethod1Method(args);
 }
 
 static v8::Handle<v8::Value> activityLoggedMethod2Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     imp->activityLoggedMethod2(longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> activityLoggedMethod2MethodForMainWorld(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     imp->activityLoggedMethod2(longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> activityLoggedMethod2MethodCallback(const v8::Arguments& args)
 {
     V8PerContextData* contextData = V8PerContextData::from(args.GetIsolate()->GetCurrentContext());
     if (contextData && contextData->activityLogger()) {
         Vector<v8::Handle<v8::Value> > loggerArgs = toVectorOfArguments(args);
@@ skipping 10 matching lines @@
         contextData->activityLogger()->log("TestObject.activityLoggedMethod2", args.Length(), loggerArgs.data(), "Method");
     }
     return TestObjV8Internal::activityLoggedMethod2MethodForMainWorld(args);
 }
 
 static v8::Handle<v8::Value> activityLoggedInIsolatedWorldMethodMethod(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     imp->activityLoggedInIsolatedWorldMethod(longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> activityLoggedInIsolatedWorldMethodMethodForMainWorld(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     imp->activityLoggedInIsolatedWorldMethod(longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> activityLoggedInIsolatedWorldMethodMethodCallback(const v8::Arguments& args)
 {
     V8PerContextData* contextData = V8PerContextData::from(args.GetIsolate()->GetCurrentContext());
     if (contextData && contextData->activityLogger()) {
         Vector<v8::Handle<v8::Value> > loggerArgs = toVectorOfArguments(args);
         contextData->activityLogger()->log("TestObject.activityLoggedInIsolatedWorldMethod", args.Length(), loggerArgs.data(), "Method");
     }
     return TestObjV8Internal::activityLoggedInIsolatedWorldMethodMethod(args);
 }
 
 static v8::Handle<v8::Value> activityLoggedInIsolatedWorldMethodMethodCallbackForMainWorld(const v8::Arguments& args)
 {
     return TestObjV8Internal::activityLoggedInIsolatedWorldMethodMethodForMainWorld(args);
 }
 
 static v8::Handle<v8::Value> overloadedActivityLoggedMethod1Method(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     imp->overloadedActivityLoggedMethod(longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedActivityLoggedMethod1MethodForMainWorld(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH(int, longArg, toInt32(args[0]));
     imp->overloadedActivityLoggedMethod(longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedActivityLoggedMethod2Method(const v8::Arguments& args)
 {
     if (args.Length() < 2)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]);
     V8TRYCATCH(int, longArg, toInt32(args[1]));
     imp->overloadedActivityLoggedMethod(strArg, longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedActivityLoggedMethod2MethodForMainWorld(const v8::Arguments& args)
 {
     if (args.Length() < 2)
         return throwNotEnoughArgumentsError(args.GetIsolate());
     TestObj* imp = V8TestObject::toNative(args.Holder());
-    ExceptionCode ec = 0;
     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]);
     V8TRYCATCH(int, longArg, toInt32(args[1]));
     imp->overloadedActivityLoggedMethod(strArg, longArg);
     return v8Undefined();
 }
 
 static v8::Handle<v8::Value> overloadedActivityLoggedMethodMethod(const v8::Arguments& args)
 {
     if (args.Length() == 1)
         return overloadedActivityLoggedMethod1Method(args);
@@ skipping 576 matching lines @@
     installPerContextProperties(wrapper, impl.get(), isolate);
     V8DOMWrapper::associateObjectWithWrapper(impl, &info, wrapper, isolate, WrapperConfiguration::Independent);
     return wrapper;
 }
 void V8TestObject::derefObject(void* object)
 {
     static_cast<TestObj*>(object)->deref();
 }
 
 } // namespace WebCore