move constructors to new style callbacks

Source/bindings/scripts/CodeGeneratorV8.pm

 # Copyright (C) 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
 # Copyright (C) 2006 Anders Carlsson <andersca@mac.com>
 # Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
 # Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
 # Copyright (C) 2006 Apple Computer, Inc.
 # Copyright (C) 2007, 2008, 2009, 2012 Google Inc.
 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
 # Copyright (C) Research In Motion Limited 2010. All rights reserved.
 # Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
 # Copyright (C) 2012 Ericsson AB. All rights reserved.
@@ skipping 681 matching lines @@
     static v8::Handle<v8::Value> ${name}MethodCustom(const v8::Arguments&);
 END
             $header{classPublic}->add("#endif // ${conditionalString}\n") if $conditionalString;
         }
         if ($attrExt->{"EnabledPerContext"}) {
             push(@enabledPerContextFunctions, $function);
         }
     }
 
     if (IsConstructable($interface)) {
-        $header{classPublic}->add("    static v8::Handle<v8::Value> constructorCallback(const v8::Arguments&);\n");
+        $header{classPublic}->add("    static void constructorCallback(const v8::FunctionCallbackInfo<v8::Value>&);\n");
 END
     }
     if (HasCustomConstructor($interface)) {
-        $header{classPublic}->add("    static v8::Handle<v8::Value> constructorCustom(const v8::Arguments&);\n");
+        $header{classPublic}->add("    static void constructorCustom(const v8::FunctionCallbackInfo<v8::Value>&);\n");
     }
 
     my @enabledPerContextAttributes;
     foreach my $attribute (@{$interface->attributes}) {
         my $name = $attribute->signature->name;
         my $attrExt = $attribute->signature->extendedAttributes;
         my $conditionalString = GenerateConditionalString($attribute->signature);
         if (HasCustomGetter($attrExt) && !$attrExt->{"ImplementedBy"}) {
             $header{classPublic}->add("#if ${conditionalString}\n") if $conditionalString;
             $header{classPublic}->add(<<END);
@@ skipping 1398 matching lines @@
     }
     return v8Undefined();
 }
 
 END
         $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
         $implementation{nameSpaceInternal}->add($code);
         return;
     }
 
-    $code .= GenerateArgumentsCountCheck($function, $interface);
+    $code .= GenerateArgumentsCountCheckOldStyle($function, $interface);
 
     if ($name eq "set" and $interface->extendedAttributes->{"TypedArray"}) {
         AddToImplIncludes("bindings/v8/custom/V8ArrayBufferViewCustom.h");
         $code .= <<END;
     return setWebGLArrayHelper<$implClassName, ${v8ClassName}>(args);
 }
 
 END
         $implementation{nameSpaceInternal}->add($code);
         return;
@@ skipping 47 matching lines @@
         $code .= "    ExceptionCode ec = 0;\n";
     }
 
     if ($function->signature->extendedAttributes->{"CheckSecurityForNode"}) {
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         $code .= "    if (!BindingSecurity::shouldAllowAccessToNode(imp->" . GetImplName($function->signature) . "(ec)))\n";
         $code .= "        return v8::Handle<v8::Value>(v8Null(args.GetIsolate()));\n";
 END
     }
 
-    my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface, $forMainWorldSuffix);
+    my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheckOldStyle($function, $interface, $forMainWorldSuffix);
     $code .= $parameterCheckString;
 
     # Build the function call string.
     $code .= GenerateFunctionCallString($function, $paramIndex, "    ", $interface, $forMainWorldSuffix, %replacements);
     $code .= "}\n\n";
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateCallWith
@@ skipping 25 matching lines @@
     }
     if (ExtendedAttributeContains($callWith, "ActiveWindow")) {
         push(@callWithArgs, "activeDOMWindow()");
     }
     if (ExtendedAttributeContains($callWith, "FirstWindow")) {
         push(@callWithArgs, "firstDOMWindow()");
     }
     return ([@callWithArgs], $code);
 }
 
+sub GenerateArgumentsCountCheckOldStyle
+{
+    my $function = shift;
+    my $interface = shift;
+    GenerateArgumentsCountCheck($function, $interface, "old");
+}
+
 sub GenerateArgumentsCountCheck
 {
     my $function = shift;
     my $interface = shift;
+    my $style = shift || "new";
 
     my $numMandatoryParams = 0;
     my $allowNonOptional = 1;
     foreach my $param (@{$function->parameters}) {
         if ($param->isOptional or $param->isVariadic) {
             $allowNonOptional = 0;
         } else {
             die "An argument must not be declared to be optional unless all subsequent arguments to the operation are also optional." if !$allowNonOptional;
             $numMandatoryParams++;
         }
     }
 
     my $argumentsCountCheckString = "";
     if ($numMandatoryParams >= 1) {
-        $argumentsCountCheckString .= "    if (args.Length() < $numMandatoryParams)\n";
-        $argumentsCountCheckString .= "        return throwNotEnoughArgumentsError(args.GetIsolate());\n";
+        if ("old" eq $style) {

[jochen (gone - plz use gerrit), 2013/05/23 14:20:19]

nit $style eq "old"

+            $argumentsCountCheckString .= "    if (args.Length() < $numMandatoryParams)\n";
+            $argumentsCountCheckString .= "        return throwNotEnoughArgumentsError(args.GetIsolate());\n";
+        } else {
+            $argumentsCountCheckString .= "    if (args.Length() < $numMandatoryParams) {\n";
+            $argumentsCountCheckString .= "        throwNotEnoughArgumentsError(args.GetIsolate());\n";
+            $argumentsCountCheckString .= "        return;\n";
+            $argumentsCountCheckString .= "    }\n";
+        }
     }
     return $argumentsCountCheckString;
 }
 
+sub GenerateParametersCheckOldStyle
+{
+    my $function = shift;
+    my $interface = shift;
+    my $forMainWorldSuffix = shift;
+    GenerateParametersCheck($function, $interface, $forMainWorldSuffix, "old");
+}
+
 sub GenerateParametersCheck
 {
     my $function = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
+    my $style = shift || "new";
+
+    my $isOld = "old" eq $style;

[jochen (gone - plz use gerrit), 2013/05/23 14:20:19]

same here

+    my $trySuffix = "_VOID";
+    if ($isOld) {
+        $trySuffix = "";
+    }
 
     my $parameterCheckString = "";
     my $paramIndex = 0;
     my %replacements = ();
 
     foreach my $parameter (@{$function->parameters}) {
         my $nativeType = GetNativeTypeFromSignature($parameter, $paramIndex);
 
         # Optional arguments without [Default=...] should generate an early call with fewer arguments.
         # Optional arguments with [Optional=...] should not generate the early call.
@@ skipping 14 matching lines @@
         }
 
         my $parameterName = $parameter->name;
         AddToImplIncludes("core/dom/ExceptionCode.h");
         if (IsCallbackInterface($parameter->type)) {
             my $v8ClassName = "V8" . $parameter->type;
             AddToImplIncludes("$v8ClassName.h");
             if ($parameter->isOptional) {
                 $parameterCheckString .= "    RefPtr<" . $parameter->type . "> $parameterName;\n";
                 $parameterCheckString .= "    if (args.Length() > $paramIndex && !args[$paramIndex]->IsNull() && !args[$paramIndex]->IsUndefined()) {\n";
-                $parameterCheckString .= "        if (!args[$paramIndex]->IsFunction())\n";
-                $parameterCheckString .= "            return throwTypeError(0, args.GetIsolate());\n";
+                $parameterCheckString .= "        if (!args[$paramIndex]->IsFunction()) {\n";
+                if ($isOld) {
+                    $parameterCheckString .= "            return throwTypeError(0, args.GetIsolate());\n";
+                } else {
+                    $parameterCheckString .= "            throwTypeError(0, args.GetIsolate());\n";
+                    $parameterCheckString .= "            return;\n";
+                }
+                $parameterCheckString .= "        }\n";
                 $parameterCheckString .= "        $parameterName = ${v8ClassName}::create(args[$paramIndex], getScriptExecutionContext());\n";
                 $parameterCheckString .= "    }\n";
             } else {
                 $parameterCheckString .= "    if (args.Length() <= $paramIndex || !args[$paramIndex]->IsFunction())\n";
                 $parameterCheckString .= "        return throwTypeError(0, args.GetIsolate());\n";
                 $parameterCheckString .= "    RefPtr<" . $parameter->type . "> $parameterName = ${v8ClassName}::create(args[$paramIndex], getScriptExecutionContext());\n";
             }
         } elsif ($parameter->extendedAttributes->{"Clamp"}) {
                 my $nativeValue = "${parameterName}NativeValue";
                 my $paramType = $parameter->type;
                 $parameterCheckString .= "    $paramType $parameterName = 0;\n";
-                $parameterCheckString .= "    V8TRYCATCH(double, $nativeValue, args[$paramIndex]->NumberValue());\n";
+                $parameterCheckString .= "    V8TRYCATCH$trySuffix(double, $nativeValue, args[$paramIndex]->NumberValue());\n";
                 $parameterCheckString .= "    if (!std::isnan($nativeValue))\n";
                 $parameterCheckString .= "        $parameterName = clampTo<$paramType>($nativeValue);\n";
         } elsif ($parameter->type eq "SerializedScriptValue") {
             AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
             $parameterCheckString .= "    bool ${parameterName}DidThrow = false;\n";
             $parameterCheckString .= "    $nativeType $parameterName = SerializedScriptValue::create(args[$paramIndex], 0, 0, ${parameterName}DidThrow, args.GetIsolate());\n";
-            $parameterCheckString .= "    if (${parameterName}DidThrow)\n";
-            $parameterCheckString .= "        return v8Undefined();\n";
+            $parameterCheckString .= "    if (${parameterName}DidThrow) {\n";
+            if ($isOld) {
+                $parameterCheckString .= "        return v8Undefined();\n";
+            } else {
+                $parameterCheckString .= "        return;\n";
+            }
+            $parameterCheckString .= "    }\n";
         } elsif ($parameter->isVariadic) {
             my $nativeElementType = GetNativeType($parameter->type);
             if ($nativeElementType =~ />$/) {
                 $nativeElementType .= " ";
             }
 
             my $argType = $parameter->type;
             if (IsWrapperType($argType)) {
                 $parameterCheckString .= "    Vector<$nativeElementType> $parameterName;\n";
                 $parameterCheckString .= "    for (int i = $paramIndex; i < args.Length(); ++i) {\n";
-                $parameterCheckString .= "        if (!V8${argType}::HasInstance(args[i], args.GetIsolate(), worldType(args.GetIsolate())))\n";
-                $parameterCheckString .= "            return throwTypeError(0, args.GetIsolate());\n";
+                $parameterCheckString .= "        if (!V8${argType}::HasInstance(args[i], args.GetIsolate(), worldType(args.GetIsolate()))) {\n";
+                if ($isOld) {
+                    $parameterCheckString .= "            return throwTypeError(0, args.GetIsolate());\n";
+                } else {
+                    $parameterCheckString .= "            throwTypeError(0, args.GetIsolate());\n";
+                    $parameterCheckString .= "            return;\n";
+                }
+                $parameterCheckString .= "        }\n";
                 $parameterCheckString .= "        $parameterName.append(V8${argType}::toNative(v8::Handle<v8::Object>::Cast(args[i])));\n";
                 $parameterCheckString .= "    }\n";
             } else {
-                $parameterCheckString .= "    V8TRYCATCH(Vector<$nativeElementType>, $parameterName, toNativeArguments<$nativeElementType>(args, $paramIndex));\n";
+                $parameterCheckString .= "    V8TRYCATCH$trySuffix(Vector<$nativeElementType>, $parameterName, toNativeArguments<$nativeElementType>(args, $paramIndex));\n";
             }
         } elsif ($nativeType =~ /^V8StringResource/) {
             my $default = defined $parameter->extendedAttributes->{"Default"} ? $parameter->extendedAttributes->{"Default"} : "";
             my $value = JSValueToNative($parameter, $parameter->isOptional && $default eq "NullString" ? "argumentOrNull(args, $paramIndex)" : "args[$paramIndex]", "args.GetIsolate()");
-            $parameterCheckString .= "    " . ConvertToV8StringResource($parameter, $nativeType, $parameterName, $value) . "\n";
+            my $suffix = $isOld ? "" : "VOID";
+            $parameterCheckString .= "    " . ConvertToV8StringResource($parameter, $nativeType, $parameterName, $value, $suffix) . "\n";
             if (IsEnumType($parameter->type)) {
                 my @enumValues = ValidEnumValues($parameter->type);
                 my @validEqualities = ();
                 foreach my $enumValue (@enumValues) {
                     push(@validEqualities, "string == \"$enumValue\"");
                 }
                 my $enumValidationExpression = join(" || ", @validEqualities);
                 $parameterCheckString .=  "    String string = $parameterName;\n";
-                $parameterCheckString .=  "    if (!($enumValidationExpression))\n";
-                $parameterCheckString .=  "        return throwTypeError(0, args.GetIsolate());\n";
+                $parameterCheckString .=  "    if (!($enumValidationExpression)) {\n";
+                if ($isOld) {
+                    $parameterCheckString .= "        return throwTypeError(0, args.GetIsolate());\n";
+                } else {
+                    $parameterCheckString .= "        throwTypeError(0, args.GetIsolate());\n";
+                    $parameterCheckString .= "        return;\n";
+                }
+                $parameterCheckString .= "    }\n";
             }
         } else {
             # If the "StrictTypeChecking" extended attribute is present, and the argument's type is an
             # interface type, then if the incoming value does not implement that interface, a TypeError
             # is thrown rather than silently passing NULL to the C++ code.
             # Per the Web IDL and ECMAScript specifications, incoming values can always be converted
             # to both strings and numbers, so do not throw TypeError if the argument is of these
             # types.
             if ($function->signature->extendedAttributes->{"StrictTypeChecking"}) {
                 my $argValue = "args[$paramIndex]";
                 my $argType = $parameter->type;
                 if (IsWrapperType($argType)) {
-                    $parameterCheckString .= "    if (args.Length() > $paramIndex && !isUndefinedOrNull($argValue) && !V8${argType}::HasInstance($argValue, args.GetIsolate(), worldType(args.GetIsolate())))\n";
-                    $parameterCheckString .= "        return throwTypeError(0, args.GetIsolate());\n";
+                    $parameterCheckString .= "    if (args.Length() > $paramIndex && !isUndefinedOrNull($argValue) && !V8${argType}::HasInstance($argValue, args.GetIsolate(), worldType(args.GetIsolate()))) {\n";
+                    if ($isOld) {
+                        $parameterCheckString .= "        return throwTypeError(0, args.GetIsolate());\n";
+                    } else {
+                        $parameterCheckString .= "        throwTypeError(0, args.GetIsolate());\n";
+                        $parameterCheckString .= "        return;\n";
+                    }
+                    $parameterCheckString .= "    }\n";
                 }
             }
             my $default = defined $parameter->extendedAttributes->{"Default"} ? $parameter->extendedAttributes->{"Default"} : "";
             my $value = JSValueToNative($parameter, $parameter->isOptional && $default eq "NullString" ? "argumentOrNull(args, $paramIndex)" : "args[$paramIndex]", "args.GetIsolate()");
             if ($parameter->extendedAttributes->{"EnforceRange"}) {
-                $parameterCheckString .= "    V8TRYCATCH_WITH_TYPECHECK($nativeType, $parameterName, $value, args.GetIsolate());\n";
+                $parameterCheckString .= "    V8TRYCATCH_WITH_TYPECHECK$trySuffix($nativeType, $parameterName, $value, args.GetIsolate());\n";
             } else {
-                $parameterCheckString .= "    V8TRYCATCH($nativeType, $parameterName, $value);\n";
+                $parameterCheckString .= "    V8TRYCATCH$trySuffix($nativeType, $parameterName, $value);\n";
             }
             if ($nativeType eq 'Dictionary') {
-               $parameterCheckString .= "    if (!$parameterName.isUndefinedOrNull() && !$parameterName.isObject())\n";
-               $parameterCheckString .= "        return throwTypeError(\"Not an object.\", args.GetIsolate());\n";
+               $parameterCheckString .= "    if (!$parameterName.isUndefinedOrNull() && !$parameterName.isObject()) {\n";
+                if ($isOld) {
+                    $parameterCheckString .= "        return throwTypeError(\"Not an object.\", args.GetIsolate());\n";
+                } else {
+                    $parameterCheckString .= "        throwTypeError(\"Not an object.\", args.GetIsolate());\n";
+                    $parameterCheckString .= "        return;\n";
+                }
+               $parameterCheckString .= "    }\n";
             }
         }
 
         if ($parameter->extendedAttributes->{"IsIndex"}) {
-            $parameterCheckString .= "    if (UNLIKELY($parameterName < 0))\n";
-            $parameterCheckString .= "        return setDOMException(INDEX_SIZE_ERR, args.GetIsolate());\n";
+            $parameterCheckString .= "    if (UNLIKELY($parameterName < 0)) {\n";
+            if ($isOld) {
+                $parameterCheckString .= "        return setDOMException(INDEX_SIZE_ERR, args.GetIsolate());\n";
+            } else {
+                $parameterCheckString .= "        setDOMException(INDEX_SIZE_ERR, args.GetIsolate());\n";
+                $parameterCheckString .= "        return;\n";
+            }
+            $parameterCheckString .= "    }\n";
         }
 
         $paramIndex++;
     }
     return ($parameterCheckString, $paramIndex, %replacements);
 }
 
 sub GenerateOverloadedConstructorCallback
 {
     my $interface = shift;
     my $implClassName = GetImplName($interface);
 
+

[jochen (gone - plz use gerrit), 2013/05/23 14:20:19]

why the empty line?

     my $code = "";
     $code .= <<END;
-static v8::Handle<v8::Value> constructor(const v8::Arguments& args)
+static void constructor(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
 END
     my $leastNumMandatoryParams = 255;
     foreach my $constructor (@{$interface->constructors}) {
         my $name = "constructor" . $constructor->{overloadedIndex};
         my ($numMandatoryParams, $parametersCheck) = GenerateFunctionParametersCheck($constructor);
         $leastNumMandatoryParams = $numMandatoryParams if ($numMandatoryParams < $leastNumMandatoryParams);
-        $code .= "    if ($parametersCheck)\n";
-        $code .= "        return ${implClassName}V8Internal::${name}(args);\n";
+        $code .= "    if ($parametersCheck) {\n";
+        $code .= "        ${implClassName}V8Internal::${name}(args);\n";
+        $code .= "        return;\n";
+        $code .= "    }\n";
     }
     if ($leastNumMandatoryParams >= 1) {
-        $code .= "    if (args.Length() < $leastNumMandatoryParams)\n";
-        $code .= "        return throwNotEnoughArgumentsError(args.GetIsolate());\n";
+        $code .= "    if (args.Length() < $leastNumMandatoryParams) {\n";
+        $code .= "        throwNotEnoughArgumentsError(args.GetIsolate());\n";
+        $code .= "        return;";
+        $code .= "    }\n";
     }
     $code .= <<END;
-    return throwTypeError(0, args.GetIsolate());
+    throwTypeError(0, args.GetIsolate());
+    return;
 END
     $code .= "}\n\n";
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateSingleConstructorCallback
 {
     my $interface = shift;
     my $function = shift;
 
@@ skipping 13 matching lines @@
             if ($parameter->extendedAttributes->{"IsIndex"}) {
                 $raisesExceptions = 1;
             }
         }
     }
 
     my @beforeArgumentList;
     my @afterArgumentList;
     my $code = "";
     $code .= <<END;
-static v8::Handle<v8::Value> constructor${overloadedIndexString}(const v8::Arguments& args)
+static void constructor${overloadedIndexString}(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
 END
 
     if ($function->{overloadedIndex} == 0) {
         $code .= GenerateArgumentsCountCheck($function, $interface);
     }
 
     if ($raisesExceptions) {
         AddToImplIncludes("core/dom/ExceptionCode.h");
         $code .= "    ExceptionCode ec = 0;\n";
@@ skipping 26 matching lines @@
         }
         $index++;
     }
 
     my $argumentString = join(", ", @beforeArgumentList, @argumentList, @afterArgumentList);
     $code .= "\n";
     $code .= "    RefPtr<${implClassName}> impl = ${implClassName}::create(${argumentString});\n";
     $code .= "    v8::Handle<v8::Object> wrapper = args.Holder();\n";
 
     if ($interface->extendedAttributes->{"RaisesException"}) {
-        $code .= "    if (ec)\n";
-        $code .= "        return setDOMException(ec, args.GetIsolate());\n";
+        $code .= "    if (ec) {\n";
+        $code .= "        setDOMException(ec, args.GetIsolate());\n";
+        $code .= "        return;\n";
+        $code .= "    }\n";
     }
 
     $code .= <<END;
 
     V8DOMWrapper::associateObjectWithWrapper(impl.release(), &${v8ClassName}::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
-    return wrapper;
+    args.GetReturnValue().Set(wrapper);
 }
 
 END
     $implementation{nameSpaceInternal}->add($code);
 }
 
 # The Web IDL specification states that Interface objects for interfaces MUST have a property named
 # "length" that returns the length of the shortest argument list of the entries in the effective
 # overload set for constructors. In other words, use the lowest number of mandatory arguments among
 # all constructors.
@@ skipping 17 matching lines @@
     return $leastConstructorLength;
 }
 
 sub GenerateConstructorCallback
 {
     my $interface = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $code = "";
-    $code .= "v8::Handle<v8::Value> ${v8ClassName}::constructorCallback(const v8::Arguments& args)\n";
+    $code .= "void ${v8ClassName}::constructorCallback(const v8::FunctionCallbackInfo<v8::Value>& args)\n";
     $code .= "{\n";
     $code .= GenerateFeatureObservation($interface->extendedAttributes->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($interface->extendedAttributes->{"DeprecateAs"});
     $code .= GenerateConstructorHeader();
     if (HasCustomConstructor($interface)) {
-        $code .= "    return ${v8ClassName}::constructorCustom(args);\n";
+        $code .= "    ${v8ClassName}::constructorCustom(args);\n";
     } else {
-        $code .= "    return ${implClassName}V8Internal::constructor(args);\n";
+        $code .= "    ${implClassName}V8Internal::constructor(args);\n";
     }
     $code .= "}\n\n";
     $implementation{nameSpaceWebCore}->add($code);
 }
 
 sub GenerateConstructor
 {
     my $interface = shift;
 
     if (@{$interface->constructors} == 1) {
         GenerateSingleConstructorCallback($interface, @{$interface->constructors}[0]);
     } else {
         foreach my $constructor (@{$interface->constructors}) {
             GenerateSingleConstructorCallback($interface, $constructor);
         }
         GenerateOverloadedConstructorCallback($interface);
     }
 }
 
 sub GenerateEventConstructor
 {
     my $interface = shift;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
 
     AddToImplIncludes("bindings/v8/Dictionary.h");
     $implementation{nameSpaceInternal}->add(<<END);
-static v8::Handle<v8::Value> constructor(const v8::Arguments& args)
+static void constructor(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
-    if (args.Length() < 1)
-        return throwNotEnoughArgumentsError(args.GetIsolate());
+    if (args.Length() < 1) {
+        throwNotEnoughArgumentsError(args.GetIsolate());
+        return;
+    }
 
-    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, args[0]);
+    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, type, args[0]);
     ${implClassName}Init eventInit;
     if (args.Length() >= 2) {
-        V8TRYCATCH(Dictionary, options, Dictionary(args[1], args.GetIsolate()));
+        V8TRYCATCH_VOID(Dictionary, options, Dictionary(args[1], args.GetIsolate()));
         if (!fill${implClassName}Init(eventInit, options))
-            return v8Undefined();
+            return;
     }
 
     RefPtr<${implClassName}> event = ${implClassName}::create(type, eventInit);
 
     v8::Handle<v8::Object> wrapper = args.Holder();
     V8DOMWrapper::associateObjectWithWrapper(event.release(), &${v8ClassName}::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
-    return wrapper;
+    args.GetReturnValue().Set(wrapper);
 }
 END
 
     my $code = "";
     $code .= <<END;
 bool fill${implClassName}Init(${implClassName}Init& eventInit, const Dictionary& options)
 {
 END
 
     foreach my $interfaceBase (@{$interface->parents}) {
@@ skipping 24 matching lines @@
 {
     my $interface = shift;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
 
     my $viewType = GetTypeNameOfExternalTypedArray($interface);
     my $type = $interface->extendedAttributes->{"TypedArray"};
     AddToImplIncludes("bindings/v8/custom/V8ArrayBufferViewCustom.h");
 
     $implementation{nameSpaceInternal}->add(<<END);
-static v8::Handle<v8::Value> constructor(const v8::Arguments& args)
+static void constructor(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
-    return constructWebGLArray<$implClassName, ${v8ClassName}, $type>(args, &${v8ClassName}::info, $viewType);
+    constructWebGLArray<$implClassName, ${v8ClassName}, $type>(args, &${v8ClassName}::info, $viewType);
 }
 
 END
 }
 
 sub GenerateNamedConstructor
 {
     my $function = shift;
     my $interface = shift;
 
@@ skipping 28 matching lines @@
     }
 
     AddToImplIncludes("core/page/Frame.h");
     $implementation{nameSpaceWebCore}->add(<<END);
 WrapperTypeInfo ${v8ClassName}Constructor::info = { ${v8ClassName}Constructor::GetTemplate, ${v8ClassName}::derefObject, $toActiveDOMObject, $toEventTarget, 0, ${v8ClassName}::installPerContextPrototypeProperties, 0, WrapperTypeObjectPrototype };
 
 END
 
     my $code = "";
     $code .= <<END;
-static v8::Handle<v8::Value> ${v8ClassName}ConstructorCallback(const v8::Arguments& args)
+static void ${v8ClassName}ConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& args)

[haraken, 2013/05/23 15:04:38]

Are you going to use FunctionCallbackInfo for DOM attributes as well? The
difference between AccessorInfo and Arguments has complicated the current V8
bindings. It would be better if we can unify them.

[dcarney, 2013/05/24 08:11:48]

No.

Unification is not easy, since they are very different structures, but they have
a similar interfaces, which means they can be passed easily to templates that
use that interface, as is done in toV8Fast.  There is no reason the differences
should complicate bindings much.

 {
 END
     $code .= $maybeObserveFeature if $maybeObserveFeature;
     $code .= $maybeDeprecateFeature if $maybeDeprecateFeature;
     $code .= GenerateConstructorHeader();
     AddToImplIncludes("V8Document.h");
     $code .= <<END;
     Document* document = currentDocument();
 
     // Make sure the document is added to the DOM Node map. Otherwise, the ${implClassName} instance
@@ skipping 29 matching lines @@
         }
         $index++;
     }
 
     my $argumentString = join(", ", @beforeArgumentList, @argumentList, @afterArgumentList);
     $code .= "\n";
     $code .= "    RefPtr<${implClassName}> impl = ${implClassName}::createForJSConstructor(${argumentString});\n";
     $code .= "    v8::Handle<v8::Object> wrapper = args.Holder();\n";
 
     if ($interface->extendedAttributes->{"RaisesException"}) {
-        $code .= "    if (ec)\n";
-        $code .= "        return setDOMException(ec, args.GetIsolate());\n";
+        $code .= "    if (ec) {\n";
+        $code .= "        setDOMException(ec, args.GetIsolate());\n";
+        $code .= "        return;\n";
+        $code .= "    }\n";
     }
 
     $code .= <<END;
 
     V8DOMWrapper::associateObjectWithWrapper(impl.release(), &${v8ClassName}Constructor::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
-    return wrapper;
+    args.GetReturnValue().Set(wrapper);

[haraken, 2013/05/23 15:04:38]

Can't we write this as args.SetReturnValue(wrapper)?

[dcarney, 2013/05/24 08:11:48]

The ReturnValue is mean to be stack passable, and has 5 or 6 Set functions.  We
wouldn't get much out of copying all the setters to FunctionCallbackInfo and
PropertyCallbackInfo

 }
 
 END
     $implementation{nameSpaceWebCore}->add($code);
 
     $code = <<END;
 v8::Persistent<v8::FunctionTemplate> ${v8ClassName}Constructor::GetTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     static v8::Persistent<v8::FunctionTemplate> cachedTemplate;
     if (!cachedTemplate.IsEmpty())
@@ skipping 12 matching lines @@
 }
 
 END
     $implementation{nameSpaceWebCore}->add($code);
 }
 
 sub GenerateConstructorHeader
 {
     AddToImplIncludes("bindings/v8/V8ObjectConstructor.h");
     my $content = <<END;
-    if (!args.IsConstructCall())
-        return throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate());
+    if (!args.IsConstructCall()) {
+        throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate());
+        return;
+    }
 
-    if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
-        return args.Holder();
+    if (ConstructorMode::current() == ConstructorMode::WrapExistingObject) {
+        args.GetReturnValue().Set(args.Holder());
+        return;
+    }
 
 END
     return $content;
 }
 
 sub GenerateBatchedAttributeData
 {
     my $interface = shift;
     my $attributes = shift;
     my $code = "";
@@ skipping 2603 matching lines @@
         if ($currentInterface->extendedAttributes->{$extendedAttribute}) {
             $found = 1;
         }
         return 1 if $found;
     }, 0);
 
     return $found;
 }
 
 1;