LayoutTests/ChangeLog

2011-09-09  Kentaro Hara  <haraken@google.com>

        Generate a WebKitCSSMatrix constructor of V8 using the IDL 'Constructor' extended attribute

        https://bugs.webkit.org/show_bug.cgi?id=67458

        Reviewed by NOBODY (OOPS!).

        Added a test case for "new WebKitCSSMatrix(null)" and "new WebKitCSSMatrix(undefined)".

        * fast/dom/Window/custom-constructors-expected.txt:

        * fast/dom/Window/custom-constructors.html:

2011-09-09  Cary Clark  <caryclark@google.com>

        Unreviewed; new baselines (Skia on Mac, GPU edition)

LayoutTests/fast/dom/Window/custom-constructors-expected.txt

@@PASS Image.prototype.toString.call(new Image) is '[object HTMLImageElement]'

PASS Option.prototype.toString.call(new Option) is '[object HTMLOptionElement]'

PASS WebKitPoint.prototype.toString.call(new WebKitPoint) is '[object WebKitPoint]'

PASS WebKitCSSMatrix.prototype.toString.call(new WebKitCSSMatrix) is 'matrix(1.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000)'

PASS WebKitCSSMatrix.prototype.toString.call(new WebKitCSSMatrix()) is 'matrix(1.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000)'

PASS new WebKitCSSMatrix(null) threw exception Error: SYNTAX_ERR: DOM Exception 12.

PASS new WebKitCSSMatrix(undefined) threw exception Error: SYNTAX_ERR: DOM Exception 12.

PASS XMLHttpRequest.prototype.toString.call(new XMLHttpRequest) is '[object XMLHttpRequest]'

PASS XSLTProcessor.prototype.toString.call(new XSLTProcessor) is '[object XSLTProcessor]'

PASS successfullyParsed is true

LayoutTests/fast/dom/Window/custom-constructors.html

    shouldBe("Option.prototype.toString.call(new Option)", "'[object HTMLOptionElement]'");

    shouldBe("WebKitPoint.prototype.toString.call(new WebKitPoint)", "'[object WebKitPoint]'");

    shouldBe("WebKitCSSMatrix.prototype.toString.call(new WebKitCSSMatrix)", "'matrix(1.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000)'");

    shouldBe("WebKitCSSMatrix.prototype.toString.call(new WebKitCSSMatrix())", "'matrix(1.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000)'");

    shouldThrow("new WebKitCSSMatrix(null)");

    shouldThrow("new WebKitCSSMatrix(undefined)");

    shouldBe("XMLHttpRequest.prototype.toString.call(new XMLHttpRequest)", "'[object XMLHttpRequest]'");

    shouldBe("XSLTProcessor.prototype.toString.call(new XSLTProcessor)", "'[object XSLTProcessor]'");

Source/WebCore/ChangeLog

2011-09-09  Kentaro Hara  <haraken@google.com>

        Generate a WebKitCSSMatrix constructor of V8 using the IDL 'Constructor' extended attribute

        https://bugs.webkit.org/show_bug.cgi?id=67458

        Reviewed by NOBODY (OOPS!).

        Added a 'CallWithNullValue' extended attribute.

        If a parameter is optional and missing, 'CallWithDefaultValue'

        handles it as a string "undefined". On the other hand,

        'CallWithNullValue' handles it as a null string

        (Note: not a string "null", but a null string).

        Tests: fast/dom/Window/custom-constructors.html

               transforms/svg-vs-css.xhtml

               transforms/cssmatrix-2d-interface.xhtml

               transforms/cssmatrix-3d-interface.xhtmlGenerate a WebKitCSSMatrix constructor

        * WebCore.gypi: Removed V8WebKitCSSMatrixConstructor.cpp.

        * WebCore.pro: Removed V8WebKitCSSMatrixConstructor.cpp.

        * bindings/scripts/CodeGeneratorV8.pm:

        (GenerateParametersCheck): If the 'CallWithNullValue' extended attribute is set, we call MAYBE_MISSING_PARAMETER() with MISSING_IS_EMPTY mode to obtain a maybe missing parameter. Otherwise, we call MAYBE_MISSING_PARAMETER() with MISSING_IS_UNDEFINED mode.

        (RequiresCustomSignature):

        * bindings/scripts/test/V8/V8TestInterface.cpp: Updated test results.

        (WebCore::V8TestInterface::constructorCallback):

        * bindings/scripts/test/V8/V8TestMediaQueryListListener.cpp: Ditto.

        (WebCore::TestMediaQueryListListenerInternal::methodCallback):

        * bindings/scripts/test/V8/V8TestObj.cpp: Ditto.

        (WebCore::TestObjInternal::voidMethodWithArgsCallback):

        (WebCore::TestObjInternal::intMethodWithArgsCallback):

        (WebCore::TestObjInternal::objMethodWithArgsCallback):

        (WebCore::TestObjInternal::methodThatRequiresAllArgsCallback):

        (WebCore::TestObjInternal::methodThatRequiresAllArgsAndThrowsCallback):

        (WebCore::TestObjInternal::optionsObjectCallback):

        (WebCore::TestObjInternal::customArgsAndExceptionCallback):

        (WebCore::TestObjInternal::withDynamicFrameAndArgCallback):

        (WebCore::TestObjInternal::withDynamicFrameAndOptionalArgCallback):

        (WebCore::TestObjInternal::withDynamicFrameAndUserGestureCallback):

        (WebCore::TestObjInternal::withDynamicFrameAndUserGestureASADCallback):

        (WebCore::TestObjInternal::methodWithOptionalArgCallback):

        (WebCore::TestObjInternal::methodWithNonOptionalArgAndOptionalArgCallback):

        (WebCore::TestObjInternal::methodWithNonOptionalArgAndTwoOptionalArgsCallback):

        (WebCore::TestObjInternal::methodWithNonCallbackArgAndCallbackArgCallback):

        (WebCore::TestObjInternal::overloadedMethod1Callback):

        (WebCore::TestObjInternal::overloadedMethod2Callback):

        (WebCore::TestObjInternal::overloadedMethod3Callback):

        (WebCore::TestObjInternal::overloadedMethod4Callback):

        (WebCore::TestObjInternal::classMethodWithOptionalCallback):

        (WebCore::TestObjInternal::enabledAtRuntimeMethod1Callback):

        (WebCore::TestObjInternal::enabledAtRuntimeMethod2Callback):

        * bindings/v8/V8Binding.h:

        (WebCore::V8ParameterBase::prepareBase): The fact that V8ParameterBase does not have any object means that we do not need to prepare anything, i.e. we should just return true in this case.

        (WebCore::::prepare): If V8ParameterBase does not have any object, then we set a null string.

        * bindings/v8/custom/V8BindingMacros.h: MAYBE_MISSING_PARAMETER() returns the parameter of a given index if the parameter exists. If the parameter does not exist and MISSING_IS_UNDEFINED is set, this macro returns an object that represents undefined. If the parameter does not exist and MISSING_IS_EMPTY is set, this macro returns an empty object.

        * bindings/v8/custom/V8WebKitCSSMatrixConstructor.cpp: Removed.

        * css/WebKitCSSMatrix.idl: Added the 'Constructor' extended attribute.

2011-09-09  Pavel Podivilov  <podivilov@chromium.org>

        Web Inspector: introduce JavaScriptSourceFrame class.

Source/WebCore/WebCore.gypi

            'bindings/v8/custom/V8Uint8ArrayCustom.cpp',

            'bindings/v8/custom/V8WebGLRenderingContextCustom.cpp',

            'bindings/v8/custom/V8WebKitAnimationCustom.cpp',

2224 'bindings/v8/custom/V8WebKitCSSMatrixConstructor.cpp',

            'bindings/v8/custom/V8WebKitPointConstructor.cpp',

            'bindings/v8/custom/V8WebSocketCustom.cpp',

            'bindings/v8/custom/V8WorkerContextCustom.cpp',

Source/WebCore/WebCore.pro

@@v8 {

        bindings/v8/custom/V8StyleSheetCustom.cpp \

        bindings/v8/custom/V8StyleSheetListCustom.cpp \

        bindings/v8/custom/V8WebKitAnimationCustom.cpp \

211 bindings/v8/custom/V8WebKitCSSMatrixConstructor.cpp \

        bindings/v8/custom/V8WebKitPointConstructor.cpp \

        bindings/v8/custom/V8WorkerContextCustom.cpp \

        bindings/v8/custom/V8WorkerCustom.cpp \

Source/WebCore/bindings/scripts/CodeGeneratorV8.pm

@@sub GenerateParametersCheck

        # Optional callbacks should be treated differently, because they always have a default value (0),

        # and we can reduce the number of overloaded functions that take a different number of parameters.

1419 # Optional arguments with default values [Optional=CallWithDefaultValue] should not generate an early call.

1419 # Optional arguments with default values [Optional=CallWithDefaultValue] or [Optional=CallWithNullValue] should not generate an early call.

14201420 my $optional = $parameter->extendedAttributes->{"Optional"};

1421 if ($optional && $optional ne "CallWithDefaultValue" && !$parameter->extendedAttributes->{"Callback"}) {

1421 if ($optional && $optional ne "CallWithDefaultValue" && $optional ne "CallWithNullValue" && !$parameter->extendedAttributes->{"Callback"}) {

            # Generate early call if there are not enough parameters.

            $parameterCheckString .= "    if (args.Length() <= $paramIndex) {\n";

            my $functionCall = GenerateFunctionCallString($function, $paramIndex, "    " x 2, $implClassName);

@@sub GenerateParametersCheck

            $parameterCheckString .= "    }\n";

        }

        my $parameterMissingPolicy = "MISSING_IS_UNDEFINED";

        if ($optional && $optional eq "CallWithNullValue") {

            $parameterMissingPolicy = "MISSING_IS_EMPTY";

        }

        AddToImplIncludes("ExceptionCode.h");

        my $nativeType = GetNativeTypeFromSignature($parameter, $paramIndex);

        if ($parameter->extendedAttributes->{"Callback"}) {

@@sub GenerateParametersCheck

            $parameterCheckString .= "        goto fail;\n";

            $parameterCheckString .= "    }\n";

        } elsif ($nativeType =~ /^V8Parameter/) {

1460 my $value = JSValueToNative($parameter, "args[$paramIndex]");

1465 my $value = JSValueToNative($parameter, "MAYBE_MISSING_PARAMETER(args, $paramIndex, $parameterMissingPolicy)");

            $parameterCheckString .= "    " . ConvertToV8Parameter($parameter, $nativeType, $parameterName, $value) . "\n";

        } else {

            AddToImplIncludes("V8BindingMacros.h");

@@sub GenerateParametersCheck

                }

            }

            $parameterCheckString .= "    EXCEPTION_BLOCK($nativeType, $parameterName, " .

1481 JSValueToNative($parameter, "args[$paramIndex]") . ");\n";

1486 JSValueToNative($parameter, "MAYBE_MISSING_PARAMETER(args, $paramIndex, $parameterMissingPolicy)") . ");\n";

        }

        if ($parameter->extendedAttributes->{"IsIndex"}) {

@@sub RequiresCustomSignature

    }

    foreach my $parameter (@{$function->parameters}) {

        my $optional = $parameter->extendedAttributes->{"Optional"};

3271 if (($optional && ($optional ne "CallWithDefaultValue")) || $parameter->extendedAttributes->{"Callback"}) {

3276 if (($optional && $optional ne "CallWithDefaultValue" && $optional ne "CallWithNullValue") || $parameter->extendedAttributes->{"Callback"}) {

            return 0;

        }

    }

Source/WebCore/bindings/scripts/test/V8/V8TestInterface.cpp

@@v8::Handle<v8::Value> V8TestInterface::constructorCallback(const v8::Arguments&

        return throwError("Not enough arguments", V8Proxy::TypeError);

    ExceptionCode ec = 0;

57 STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, str1, args[0]);

58 STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, str2, args[1]);

57 STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, str1, MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED));

58 STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, str2, MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED));

    ScriptExecutionContext* context = getScriptExecutionContext();

    if (!context)

Source/WebCore/bindings/scripts/test/V8/V8TestMediaQueryListListener.cpp

@@static v8::Handle<v8::Value> methodCallback(const v8::Arguments& args)

{

    INC_STATS("DOM.TestMediaQueryListListener.method");

    TestMediaQueryListListener* imp = V8TestMediaQueryListListener::toNative(args.Holder());

46 EXCEPTION_BLOCK(RefPtr<MediaQueryListListener>, listener, MediaQueryListListener::create(args[0]));

46 EXCEPTION_BLOCK(RefPtr<MediaQueryListListener>, listener, MediaQueryListListener::create(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)));

    imp->method(listener);

    return v8::Handle<v8::Value>();

}

Source/WebCore/bindings/scripts/test/V8/V8TestObj.cpp

@@static v8::Handle<v8::Value> voidMethodWithArgsCallback(const v8::Arguments& arg

{

    INC_STATS("DOM.TestObj.voidMethodWithArgs");

    TestObj* imp = V8TestObj::toNative(args.Holder());

    EXCEPTION_BLOCK(int, intArg, toInt32(args[0]));

    STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, args[1]);

    EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(args[2]) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[2])) : 0);

    EXCEPTION_BLOCK(int, intArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)));

    STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED));

    EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 2, MISSING_IS_UNDEFINED)) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 2, MISSING_IS_UNDEFINED))) : 0);

    imp->voidMethodWithArgs(intArg, strArg, objArg);

    return v8::Handle<v8::Value>();

}

@@static v8::Handle<v8::Value> intMethodWithArgsCallback(const v8::Arguments& args

{

    INC_STATS("DOM.TestObj.intMethodWithArgs");

    TestObj* imp = V8TestObj::toNative(args.Holder());

    EXCEPTION_BLOCK(int, intArg, toInt32(args[0]));

    STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, args[1]);

    EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(args[2]) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[2])) : 0);

    EXCEPTION_BLOCK(int, intArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)));

    STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED));

    EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 2, MISSING_IS_UNDEFINED)) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 2, MISSING_IS_UNDEFINED))) : 0);

    return v8::Integer::New(imp->intMethodWithArgs(intArg, strArg, objArg));

}

@@static v8::Handle<v8::Value> objMethodWithArgsCallback(const v8::Arguments& args

{

    INC_STATS("DOM.TestObj.objMethodWithArgs");

    TestObj* imp = V8TestObj::toNative(args.Holder());

    EXCEPTION_BLOCK(int, intArg, toInt32(args[0]));

    STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, args[1]);

    EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(args[2]) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[2])) : 0);

    EXCEPTION_BLOCK(int, intArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)));

    STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED));

    EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 2, MISSING_IS_UNDEFINED)) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 2, MISSING_IS_UNDEFINED))) : 0);

    return toV8(imp->objMethodWithArgs(intArg, strArg, objArg));

}

@@static v8::Handle<v8::Value> methodThatRequiresAllArgsCallback(const v8::Argumen

    if (args.Length() < 2)

        return v8::Handle<v8::Value>();

    TestObj* imp = V8TestObj::toNative(args.Holder());

712 STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, args[0]);

713 EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(args[1]) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[1])) : 0);

712 STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED));

713 EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED)) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED))) : 0);

    return toV8(imp->methodThatRequiresAllArgs(strArg, objArg));

}

@@static v8::Handle<v8::Value> methodThatRequiresAllArgsAndThrowsCallback(const v8

    TestObj* imp = V8TestObj::toNative(args.Holder());

    ExceptionCode ec = 0;

    {

725 STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, args[0]);

726 EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(args[1]) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[1])) : 0);

725 STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED));

726 EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED)) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED))) : 0);

    RefPtr<TestObj> result = imp->methodThatRequiresAllArgsAndThrows(strArg, objArg, ec);

    if (UNLIKELY(ec))

        goto fail;

@@static v8::Handle<v8::Value> optionsObjectCallback(const v8::Arguments& args)

{

    INC_STATS("DOM.TestObj.optionsObject");

    TestObj* imp = V8TestObj::toNative(args.Holder());

772 EXCEPTION_BLOCK(OptionsObject, oo, args[0]);

772 EXCEPTION_BLOCK(OptionsObject, oo, MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED));

    if (args.Length() <= 1) {

        imp->optionsObject(oo);

        return v8::Handle<v8::Value>();

    }

777 EXCEPTION_BLOCK(OptionsObject, ooo, args[1]);

777 EXCEPTION_BLOCK(OptionsObject, ooo, MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED));

    imp->optionsObject(oo, ooo);

    return v8::Handle<v8::Value>();

}

@@static v8::Handle<v8::Value> customArgsAndExceptionCallback(const v8::Arguments&

    RefPtr<ScriptCallStack> callStack(createScriptCallStack(maxStackSize));

    if (!callStack)

        return v8::Undefined();

809 EXCEPTION_BLOCK(log*, intArg, V8log::HasInstance(args[0]) ? V8log::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);

809 EXCEPTION_BLOCK(log*, intArg, V8log::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)) ? V8log::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED))) : 0);

    imp->customArgsAndException(intArg, scriptArguments, callStack, ec);

    if (UNLIKELY(ec))

        goto fail;

@@static v8::Handle<v8::Value> withDynamicFrameAndArgCallback(const v8::Arguments&

{

    INC_STATS("DOM.TestObj.withDynamicFrameAndArg");

    TestObj* imp = V8TestObj::toNative(args.Holder());

857 EXCEPTION_BLOCK(int, intArg, toInt32(args[0]));

857 EXCEPTION_BLOCK(int, intArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)));

    Frame* enteredFrame = V8Proxy::retrieveFrameForEnteredContext();

    if (!enteredFrame)

        return v8::Undefined();

@@static v8::Handle<v8::Value> withDynamicFrameAndOptionalArgCallback(const v8::Ar

{

    INC_STATS("DOM.TestObj.withDynamicFrameAndOptionalArg");

    TestObj* imp = V8TestObj::toNative(args.Holder());

869 EXCEPTION_BLOCK(int, intArg, toInt32(args[0]));

869 EXCEPTION_BLOCK(int, intArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)));

    if (args.Length() <= 1) {

        Frame* enteredFrame = V8Proxy::retrieveFrameForEnteredContext();

        if (!enteredFrame)

@@static v8::Handle<v8::Value> withDynamicFrameAndOptionalArgCallback(const v8::Ar

        imp->withDynamicFrameAndOptionalArg(enteredFrame, intArg);

        return v8::Handle<v8::Value>();

    }

877 EXCEPTION_BLOCK(int, optionalArg, toInt32(args[1]));

877 EXCEPTION_BLOCK(int, optionalArg, toInt32(MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED)));

    Frame* enteredFrame = V8Proxy::retrieveFrameForEnteredContext();

    if (!enteredFrame)

        return v8::Undefined();

@@static v8::Handle<v8::Value> withDynamicFrameAndUserGestureCallback(const v8::Ar

{

    INC_STATS("DOM.TestObj.withDynamicFrameAndUserGesture");

    TestObj* imp = V8TestObj::toNative(args.Holder());

889 EXCEPTION_BLOCK(int, intArg, toInt32(args[0]));

889 EXCEPTION_BLOCK(int, intArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)));

    Frame* enteredFrame = V8Proxy::retrieveFrameForEnteredContext();

    if (!enteredFrame)

        return v8::Undefined();

@@static v8::Handle<v8::Value> withDynamicFrameAndUserGestureASADCallback(const v8

{

    INC_STATS("DOM.TestObj.withDynamicFrameAndUserGestureASAD");

    TestObj* imp = V8TestObj::toNative(args.Holder());

901 EXCEPTION_BLOCK(int, intArg, toInt32(args[0]));

901 EXCEPTION_BLOCK(int, intArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)));

    if (args.Length() <= 1) {

        Frame* enteredFrame = V8Proxy::retrieveFrameForEnteredContext();

        if (!enteredFrame)

@@static v8::Handle<v8::Value> withDynamicFrameAndUserGestureASADCallback(const v8

        imp->withDynamicFrameAndUserGestureASAD(enteredFrame, intArg, ScriptController::processingUserGesture());

        return v8::Handle<v8::Value>();

    }

909 EXCEPTION_BLOCK(int, optionalArg, toInt32(args[1]));

909 EXCEPTION_BLOCK(int, optionalArg, toInt32(MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED)));

    Frame* enteredFrame = V8Proxy::retrieveFrameForEnteredContext();

    if (!enteredFrame)

        return v8::Undefined();

@@static v8::Handle<v8::Value> methodWithOptionalArgCallback(const v8::Arguments&

        imp->methodWithOptionalArg();

        return v8::Handle<v8::Value>();

    }

996 EXCEPTION_BLOCK(int, opt, toInt32(args[0]));

996 EXCEPTION_BLOCK(int, opt, toInt32(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)));

    imp->methodWithOptionalArg(opt);

    return v8::Handle<v8::Value>();

}

@@static v8::Handle<v8::Value> methodWithNonOptionalArgAndOptionalArgCallback(cons

{

    INC_STATS("DOM.TestObj.methodWithNonOptionalArgAndOptionalArg");

    TestObj* imp = V8TestObj::toNative(args.Holder());

1005 EXCEPTION_BLOCK(int, nonOpt, toInt32(args[0]));

1005 EXCEPTION_BLOCK(int, nonOpt, toInt32(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)));

    if (args.Length() <= 1) {

        imp->methodWithNonOptionalArgAndOptionalArg(nonOpt);

        return v8::Handle<v8::Value>();

    }

1010 EXCEPTION_BLOCK(int, opt, toInt32(args[1]));

1010 EXCEPTION_BLOCK(int, opt, toInt32(MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED)));

    imp->methodWithNonOptionalArgAndOptionalArg(nonOpt, opt);

    return v8::Handle<v8::Value>();

}

@@static v8::Handle<v8::Value> methodWithNonOptionalArgAndTwoOptionalArgsCallback(

{

    INC_STATS("DOM.TestObj.methodWithNonOptionalArgAndTwoOptionalArgs");

    TestObj* imp = V8TestObj::toNative(args.Holder());

1019 EXCEPTION_BLOCK(int, nonOpt, toInt32(args[0]));

1019 EXCEPTION_BLOCK(int, nonOpt, toInt32(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)));

    if (args.Length() <= 1) {

        imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt);

        return v8::Handle<v8::Value>();

    }

1024 EXCEPTION_BLOCK(int, opt1, toInt32(args[1]));

1025 EXCEPTION_BLOCK(int, opt2, toInt32(args[2]));

1024 EXCEPTION_BLOCK(int, opt1, toInt32(MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED)));

1025 EXCEPTION_BLOCK(int, opt2, toInt32(MAYBE_MISSING_PARAMETER(args, 2, MISSING_IS_UNDEFINED)));

    imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt, opt1, opt2);

    return v8::Handle<v8::Value>();

}

@@static v8::Handle<v8::Value> methodWithNonCallbackArgAndCallbackArgCallback(cons

{

    INC_STATS("DOM.TestObj.methodWithNonCallbackArgAndCallbackArg");

    TestObj* imp = V8TestObj::toNative(args.Holder());

1045 EXCEPTION_BLOCK(int, nonCallback, toInt32(args[0]));

1045 EXCEPTION_BLOCK(int, nonCallback, toInt32(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)));

    if (args.Length() <= 1 || !args[1]->IsObject())

        return throwError(TYPE_MISMATCH_ERR);

    RefPtr<TestCallback> callback = V8TestCallback::create(args[1], getScriptExecutionContext());

@@static v8::Handle<v8::Value> overloadedMethod1Callback(const v8::Arguments& args

{

    INC_STATS("DOM.TestObj.overloadedMethod1");

    TestObj* imp = V8TestObj::toNative(args.Holder());

1094 EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(args[0]) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);

1095 STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, args[1]);

1094 EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED))) : 0);

1095 STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED));

    imp->overloadedMethod(objArg, strArg);

    return v8::Handle<v8::Value>();

}

@@static v8::Handle<v8::Value> overloadedMethod2Callback(const v8::Arguments& args

{

    INC_STATS("DOM.TestObj.overloadedMethod2");

    TestObj* imp = V8TestObj::toNative(args.Holder());

1104 EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(args[0]) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);

1104 EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED))) : 0);

    if (args.Length() <= 1) {

        imp->overloadedMethod(objArg);

        return v8::Handle<v8::Value>();

    }

1109 EXCEPTION_BLOCK(int, intArg, toInt32(args[1]));

1109 EXCEPTION_BLOCK(int, intArg, toInt32(MAYBE_MISSING_PARAMETER(args, 1, MISSING_IS_UNDEFINED)));

    imp->overloadedMethod(objArg, intArg);

    return v8::Handle<v8::Value>();

}

@@static v8::Handle<v8::Value> overloadedMethod3Callback(const v8::Arguments& args

{

    INC_STATS("DOM.TestObj.overloadedMethod3");

    TestObj* imp = V8TestObj::toNative(args.Holder());

1118 STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, args[0]);

1118 STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED));

    imp->overloadedMethod(strArg);

    return v8::Handle<v8::Value>();

}

@@static v8::Handle<v8::Value> overloadedMethod4Callback(const v8::Arguments& args

{

    INC_STATS("DOM.TestObj.overloadedMethod4");

    TestObj* imp = V8TestObj::toNative(args.Holder());

1127 EXCEPTION_BLOCK(int, intArg, toInt32(args[0]));

1127 EXCEPTION_BLOCK(int, intArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)));

    imp->overloadedMethod(intArg);

    return v8::Handle<v8::Value>();

}

@@static v8::Handle<v8::Value> classMethodWithOptionalCallback(const v8::Arguments

    if (args.Length() <= 0) {

        return v8::Integer::New(TestObj::classMethodWithOptional());

    }

1173 EXCEPTION_BLOCK(int, arg, toInt32(args[0]));

1173 EXCEPTION_BLOCK(int, arg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)));

    return v8::Integer::New(TestObj::classMethodWithOptional(arg));

}

@@static v8::Handle<v8::Value> enabledAtRuntimeMethod1Callback(const v8::Arguments

{

    INC_STATS("DOM.TestObj.enabledAtRuntimeMethod1");

    TestObj* imp = V8TestObj::toNative(args.Holder());

1181 EXCEPTION_BLOCK(int, intArg, V8int::HasInstance(args[0]) ? V8int::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);

1181 EXCEPTION_BLOCK(int, intArg, V8int::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)) ? V8int::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED))) : 0);

    imp->enabledAtRuntimeMethod1(intArg);

    return v8::Handle<v8::Value>();

}

@@static v8::Handle<v8::Value> enabledAtRuntimeMethod2Callback(const v8::Arguments

{

    INC_STATS("DOM.TestObj.enabledAtRuntimeMethod2");

    TestObj* imp = V8TestObj::toNative(args.Holder());

1190 EXCEPTION_BLOCK(int, intArg, V8int::HasInstance(args[0]) ? V8int::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);

1190 EXCEPTION_BLOCK(int, intArg, V8int::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED)) ? V8int::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, MISSING_IS_UNDEFINED))) : 0);

    imp->enabledAtRuntimeMethod2(intArg);

    return v8::Handle<v8::Value>();

}

Source/WebCore/bindings/v8/V8Binding.h

@@namespace WebCore {

        bool prepareBase()

        {

            if (m_v8Object.IsEmpty())

                return true;

            if (LIKELY(m_v8Object->IsString()))

                return true;

@@namespace WebCore {

                block.ReThrow();

                return false;

            }

            // This path is unexpected.  However there is hypothesis that it

            // might be combination of v8 and v8 bindings bugs.  For now

            // just bailout as we'll crash if attempt to convert empty handle into a string.

            if (m_v8Object.IsEmpty()) {

                ASSERT_NOT_REACHED();

                return false;

            }

            return true;

        }

@@namespace WebCore {

    template<> inline bool V8Parameter<WithNullCheck>::prepare()

    {

463 if (object()->IsNull()) {

457 if (object().IsEmpty() || object()->IsNull()) {

            setString(String());

            return true;

        }

@@namespace WebCore {

    template<> inline bool V8Parameter<WithUndefinedOrNullCheck>::prepare()

    {

473 if (object()->IsNull() || object()->IsUndefined()) {

467 if (object().IsEmpty() || object()->IsNull() || object()->IsUndefined()) {

            setString(String());

            return true;

        }

@@namespace WebCore {

        return V8ParameterBase::prepareBase();

    }

    enum ParameterMissingPolicy {

        MISSING_IS_UNDEFINED,

        MISSING_IS_EMPTY

    };

} // namespace WebCore

#endif // V8Binding_h

Source/WebCore/bindings/v8/custom/V8BindingMacros.h

    type var(value);                                                 \

    if (!var.prepare())                                              \

        return;

#define MAYBE_MISSING_PARAMETER(args, index, policy) \

    (((policy) == MISSING_IS_EMPTY && (index) >= (args).Length()) ? (v8::Local<v8::Value>()) : ((args)[(index)]))

Source/WebCore/bindings/v8/custom/V8WebKitCSSMatrixConstructor.cpp

/*

 * Copyright (C) 2009 Google Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are

 * met:

 *

 *     * Redistributions of source code must retain the above copyright

 * notice, this list of conditions and the following disclaimer.

 *     * 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.

 *     * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT

 * OWNER OR 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.

 */

#include "config.h"

#include "V8WebKitCSSMatrix.h"

#include "Document.h"

#include "DocumentFragment.h"

#include "Node.h"

#include "V8Binding.h"

#include "V8Document.h"

#include "V8Node.h"

#include "V8Proxy.h"

#include <wtf/RefPtr.h>

namespace WebCore {

v8::Handle<v8::Value> V8WebKitCSSMatrix::constructorCallback(const v8::Arguments& args)

{

    INC_STATS("DOM.WebKitCSSMatrix.Constructor");

    if (!args.IsConstructCall())

        return throwError("DOM object constructor cannot be called as a function.", V8Proxy::TypeError);

    // FIXME: The logic here is almost exact duplicate of V8::constructDOMObject.

    // Consider refactoring to reduce duplication.

    String cssValue;

    if (args.Length() >= 1)

        cssValue = toWebCoreString(args[0]);

    ExceptionCode ec = 0;

    RefPtr<WebKitCSSMatrix> matrix = WebKitCSSMatrix::create(cssValue, ec);

    if (ec)

        throwError(ec);

    // Transform the holder into a wrapper object for the matrix.

    V8DOMWrapper::setDOMWrapper(args.Holder(), &info, matrix.get());

    return toV8(matrix.release(), args.Holder());

}

} // namespace WebCore

Source/WebCore/css/WebKitCSSMatrix.idl

@@module css {

        CanBeConstructed,

        CustomConstructFunction,

        ConstructorParameters=1,

33 V8CustomConstructor

33 Constructor(in [Optional=CallWithNullValue] DOMString cssValue),

34 ConstructorRaisesException,

    ] WebKitCSSMatrix {

        // These attributes are simple aliases for certain elements of the 4x4 matrix