Rename |args| to |info| in V8 bindings

Source/bindings/scripts/code_generator_v8.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 1292 matching lines @@
     my $interface = shift;
     my $propertyName = shift;
 
     my $interfaceName = $interface->name;
 
     AddToImplIncludes("bindings/v8/V8DOMActivityLogger.h");
 
     my $code = "";
     if ($accessType eq "Method") {
         $code .= <<END;
-    V8PerContextData* contextData = V8PerContextData::from(args.GetIsolate()->GetCurrentContext());
+    V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
     if (contextData && contextData->activityLogger()) {
-        Vector<v8::Handle<v8::Value> > loggerArgs = toVectorOfArguments(args);
-        contextData->activityLogger()->log("${interfaceName}.${propertyName}", args.Length(), loggerArgs.data(), "${accessType}");
+        Vector<v8::Handle<v8::Value> > loggerArgs = toVectorOfArguments(info);
+        contextData->activityLogger()->log("${interfaceName}.${propertyName}", info.Length(), loggerArgs.data(), "${accessType}");
     }
 END
     } elsif ($accessType eq "Setter") {
         $code .= <<END;
     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
     if (contextData && contextData->activityLogger()) {
         v8::Handle<v8::Value> loggerArg[] = { jsValue };
         contextData->activityLogger()->log("${interfaceName}.${propertyName}", 1, &loggerArg[0], "${accessType}");
     }
 END
@@ skipping 745 matching lines @@
     $code .= "\n";
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateParametersCheckExpression
 {
     my $numParameters = shift;
     my $function = shift;
 
     my @andExpression = ();
-    push(@andExpression, "args.Length() == $numParameters");
+    push(@andExpression, "info.Length() == $numParameters");
     my $parameterIndex = 0;
     foreach my $parameter (@{$function->parameters}) {
         last if $parameterIndex >= $numParameters;
-        my $value = "args[$parameterIndex]";
+        my $value = "info[$parameterIndex]";
         my $type = $parameter->type;
 
         # Only DOMString or wrapper types are checked.
         # For DOMString with StrictTypeChecking only Null, Undefined and Object
         # are accepted for compatibility. Otherwise, no restrictions are made to
         # match the non-overloaded behavior.
         # FIXME: Implement WebIDL overload resolution algorithm.
         if ($type eq "DOMString") {
             if ($parameter->extendedAttributes->{"StrictTypeChecking"}) {
                 push(@andExpression, "(${value}->IsNull() || ${value}->IsUndefined() || ${value}->IsString() || ${value}->IsObject())");
             }
         } elsif (IsCallbackInterface($parameter->type)) {
             # For Callbacks only checks if the value is null or object.
             push(@andExpression, "(${value}->IsNull() || ${value}->IsFunction())");
         } elsif (GetArrayOrSequenceType($type)) {
             if ($parameter->isNullable) {
                 push(@andExpression, "(${value}->IsNull() || ${value}->IsArray())");
             } else {
                 push(@andExpression, "(${value}->IsArray())");
             }
         } elsif (IsWrapperType($type)) {
             if ($parameter->isNullable) {
-                push(@andExpression, "(${value}->IsNull() || V8${type}::HasInstance($value, args.GetIsolate(), worldType(args.GetIsolate())))");
+                push(@andExpression, "(${value}->IsNull() || V8${type}::HasInstance($value, info.GetIsolate(), worldType(info.GetIsolate())))");
             } else {
-                push(@andExpression, "(V8${type}::HasInstance($value, args.GetIsolate(), worldType(args.GetIsolate())))");
+                push(@andExpression, "(V8${type}::HasInstance($value, info.GetIsolate(), worldType(info.GetIsolate())))");
             }
         }
 
         $parameterIndex++;
     }
     my $res = join(" && ", @andExpression);
     $res = "($res)" if @andExpression > 1;
     return $res;
 }
 
@@ skipping 52 matching lines @@
 
     my $name = $function->name;
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
 
     my $conditionalString = GenerateConditionalString($function);
     my $leastNumMandatoryParams = 255;
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
     $code .= <<END;
-static void ${name}Method${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& args)
+static void ${name}Method${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
 END
     $code .= GenerateFeatureObservation($function->extendedAttributes->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($function->extendedAttributes->{"DeprecateAs"});
 
     foreach my $overload (@{$function->{overloads}}) {
         my ($numMandatoryParams, $parametersCheck) = GenerateFunctionParametersCheck($overload);
         $leastNumMandatoryParams = $numMandatoryParams if ($numMandatoryParams < $leastNumMandatoryParams);
         $code .= "    if ($parametersCheck) {\n";
         my $overloadedIndexString = $overload->{overloadIndex};
-        $code .= "        ${name}${overloadedIndexString}Method${forMainWorldSuffix}(args);\n";
+        $code .= "        ${name}${overloadedIndexString}Method${forMainWorldSuffix}(info);\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
     if ($leastNumMandatoryParams >= 1) {
-        $code .= "    if (UNLIKELY(args.Length() < $leastNumMandatoryParams)) {\n";
-        $code .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$name\", \"$interfaceName\", ExceptionMessages::notEnoughArguments($leastNumMandatoryParams, args.Length())), args.GetIsolate());\n";
+        $code .= "    if (UNLIKELY(info.Length() < $leastNumMandatoryParams)) {\n";
+        $code .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$name\", \"$interfaceName\", ExceptionMessages::notEnoughArguments($leastNumMandatoryParams, info.Length())), info.GetIsolate());\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
     $code .= <<END;
-    throwUninformativeAndGenericTypeError(args.GetIsolate());
+    throwUninformativeAndGenericTypeError(info.GetIsolate());
 END
     $code .= "}\n\n";
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateFunctionCallback
 {
     my $function = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $name = $function->name;
 
     if ($name eq "") {
         return;
     }
 
     my $conditionalString = GenerateConditionalString($function);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
     $code .= <<END;
-static void ${name}MethodCallback${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& args)
+static void ${name}MethodCallback${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
 END
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"Blink\", \"DOMMethod\");\n";
     $code .= GenerateFeatureObservation($function->extendedAttributes->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($function->extendedAttributes->{"DeprecateAs"});
     if (HasActivityLogging($forMainWorldSuffix, $function->extendedAttributes, "Access")) {
         $code .= GenerateActivityLogging("Method", $interface, "${name}");
     }
     if (HasCustomMethod($function->extendedAttributes)) {
-        $code .= "    ${v8ClassName}::${name}MethodCustom(args);\n";
+        $code .= "    ${v8ClassName}::${name}MethodCustom(info);\n";
     } else {
-        $code .= "    ${implClassName}V8Internal::${name}Method${forMainWorldSuffix}(args);\n";
+        $code .= "    ${implClassName}V8Internal::${name}Method${forMainWorldSuffix}(info);\n";
     }
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"V8\", \"Execution\");\n";
     $code .= "}\n\n";
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateFunction
 {
     my $function = shift;
@@ skipping 12 matching lines @@
     }
 
     if (@{$function->{overloads}} > 1) {
         # Append a number to an overloaded method's name to make it unique:
         $name = $name . $function->{overloadIndex};
     }
 
     my $conditionalString = GenerateConditionalString($function);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
-    $code .= "static void ${name}Method${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& args)\n";
+    $code .= "static void ${name}Method${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& info)\n";
     $code .= "{\n";
 
     if ($name eq "addEventListener" || $name eq "removeEventListener") {
         my $lookupType = ($name eq "addEventListener") ? "OrCreate" : "Only";
         my $passRefPtrHandling = ($name eq "addEventListener") ? "" : ".get()";
         my $hiddenDependencyAction = ($name eq "addEventListener") ? "create" : "remove";
 
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         AddToImplIncludes("bindings/v8/ExceptionState.h");
         AddToImplIncludes("bindings/v8/V8EventListenerList.h");
         AddToImplIncludes("core/frame/DOMWindow.h");
         $code .= <<END;
-    EventTarget* impl = ${v8ClassName}::toNative(args.Holder());
+    EventTarget* impl = ${v8ClassName}::toNative(info.Holder());
     if (DOMWindow* window = impl->toDOMWindow()) {
-        ExceptionState es(args.GetIsolate());
+        ExceptionState es(info.GetIsolate());
         if (!BindingSecurity::shouldAllowAccessToFrame(window->frame(), es)) {
             es.throwIfNeeded();
             return;
         }
 
         if (!window->document())
             return;
     }
 
-    RefPtr<EventListener> listener = V8EventListenerList::getEventListener(args[1], false, ListenerFind${lookupType});
+    RefPtr<EventListener> listener = V8EventListenerList::getEventListener(info[1], false, ListenerFind${lookupType});
     if (listener) {
-        V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, stringResource, args[0]);
-        impl->${implName}(stringResource, listener${passRefPtrHandling}, args[2]->BooleanValue());
+        V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, stringResource, info[0]);
+        impl->${implName}(stringResource, listener${passRefPtrHandling}, info[2]->BooleanValue());
         if (!impl->toNode())
-            ${hiddenDependencyAction}HiddenDependency(args.Holder(), args[1], ${v8ClassName}::eventListenerCacheIndex, args.GetIsolate());
+            ${hiddenDependencyAction}HiddenDependency(info.Holder(), info[1], ${v8ClassName}::eventListenerCacheIndex, info.GetIsolate());
     }
 }
 
 END
         $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
         $implementation{nameSpaceInternal}->add($code);
         return;
     }
 
     $code .= GenerateArgumentsCountCheck($function, $interface);
 
     if ($name eq "set" and IsConstructorTemplate($interface, "TypedArray")) {
         AddToImplIncludes("bindings/v8/custom/V8ArrayBufferViewCustom.h");
         $code .= <<END;
-    setWebGLArrayHelper<$implClassName, ${v8ClassName}>(args);
+    setWebGLArrayHelper<$implClassName, ${v8ClassName}>(info);
 }
 
 END
         $implementation{nameSpaceInternal}->add($code);
         return;
     }
 
     my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($interfaceName);
 
     if ($svgNativeType) {
         my $nativeClassName = GetNativeType($interfaceName);
         if ($interfaceName =~ /List$/) {
-            $code .= "    $nativeClassName imp = ${v8ClassName}::toNative(args.Holder());\n";
+            $code .= "    $nativeClassName imp = ${v8ClassName}::toNative(info.Holder());\n";
         } else {
             AddToImplIncludes("bindings/v8/ExceptionMessages.h");
             AddToImplIncludes("bindings/v8/ExceptionState.h");
             AddToImplIncludes("core/dom/ExceptionCode.h");
-            $code .= "    $nativeClassName wrapper = ${v8ClassName}::toNative(args.Holder());\n";
+            $code .= "    $nativeClassName wrapper = ${v8ClassName}::toNative(info.Holder());\n";
             $code .= "    if (wrapper->isReadOnly()) {\n";
-            $code .= "        setDOMException(NoModificationAllowedError, ExceptionMessages::failedToExecute(\"${name}\", \"${interfaceName}\", \"The object is read-only.\"), args.GetIsolate());\n";
+            $code .= "        setDOMException(NoModificationAllowedError, ExceptionMessages::failedToExecute(\"${name}\", \"${interfaceName}\", \"The object is read-only.\"), info.GetIsolate());\n";
             $code .= "        return;\n";
             $code .= "    }\n";
             my $svgWrappedNativeType = GetSVGWrappedTypeNeedingTearOff($interfaceName);
             $code .= "    $svgWrappedNativeType& impInstance = wrapper->propertyReference();\n";
             $code .= "    $svgWrappedNativeType* imp = &impInstance;\n";
         }
     } elsif (!$function->isStatic) {
         $code .= <<END;
-    ${implClassName}* imp = ${v8ClassName}::toNative(args.Holder());
+    ${implClassName}* imp = ${v8ClassName}::toNative(info.Holder());
 END
     }
 
     $code .= GenerateCustomElementInvocationScopeIfNeeded($funcExt);
 
     my $raisesExceptions = $function->extendedAttributes->{"RaisesException"} || ($interface->extendedAttributes->{"CheckSecurity"} && !$function->extendedAttributes->{"DoNotCheckSecurity"});
     if ($raisesExceptions) {
         AddToImplIncludes("bindings/v8/ExceptionMessages.h");
         AddToImplIncludes("bindings/v8/ExceptionState.h");
-        $code .= "    ExceptionState es(args.GetIsolate());\n";
+        $code .= "    ExceptionState es(info.GetIsolate());\n";
     }
 
     # Check domain security if needed
     if ($interface->extendedAttributes->{"CheckSecurity"} && !$function->extendedAttributes->{"DoNotCheckSecurity"}) {
         # We have not find real use cases yet.
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         $code .= <<END;
     if (!BindingSecurity::shouldAllowAccessToFrame(imp->frame(), es)) {
         es.throwIfNeeded();
         return;
     }
 END
     }
 
     if ($function->extendedAttributes->{"CheckSecurityForNode"}) {
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         $code .= "    if (!BindingSecurity::shouldAllowAccessToNode(imp->" . GetImplName($function) . "(es), es)) {\n";
-        $code .= "        v8SetReturnValueNull(args);\n";
+        $code .= "        v8SetReturnValueNull(info);\n";
         $code .= "        es.throwIfNeeded();\n";
         $code .= "        return;\n";
         $code .= "    }\n";
 END
     }
 
     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface, $forMainWorldSuffix);
     $code .= $parameterCheckString;
 
     # Build the function call string.
@@ skipping 18 matching lines @@
         $code .= $indent . "if (!currentState)\n";
         $code .= $indent . "    return" . ($returnVoid ? "" : " v8Undefined()") . ";\n";
         $code .= $indent . "ScriptState& state = *currentState;\n";
         push(@callWithArgs, "&state");
     }
     if (ExtendedAttributeContains($callWith, "ExecutionContext")) {
         $code .= $indent . "ExecutionContext* scriptContext = getExecutionContext();\n";
         push(@callWithArgs, "scriptContext");
     }
     if ($function and ExtendedAttributeContains($callWith, "ScriptArguments")) {
-        $code .= $indent . "RefPtr<ScriptArguments> scriptArguments(createScriptArguments(args, " . @{$function->parameters} . "));\n";
+        $code .= $indent . "RefPtr<ScriptArguments> scriptArguments(createScriptArguments(info, " . @{$function->parameters} . "));\n";
         push(@callWithArgs, "scriptArguments.release()");
         AddToImplIncludes("bindings/v8/ScriptCallStackFactory.h");
         AddToImplIncludes("core/inspector/ScriptArguments.h");
     }
     if (ExtendedAttributeContains($callWith, "ActiveWindow")) {
         push(@callWithArgs, "activeDOMWindow()");
     }
     if (ExtendedAttributeContains($callWith, "FirstWindow")) {
         push(@callWithArgs, "firstDOMWindow()");
     }
@@ skipping 15 matching lines @@
         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 (UNLIKELY(args.Length() < $numMandatoryParams)) {\n";
-        $argumentsCountCheckString .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", ExceptionMessages::notEnoughArguments($numMandatoryParams, args.Length())), args.GetIsolate());\n";
+        $argumentsCountCheckString .= "    if (UNLIKELY(info.Length() < $numMandatoryParams)) {\n";
+        $argumentsCountCheckString .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", ExceptionMessages::notEnoughArguments($numMandatoryParams, info.Length())), info.GetIsolate());\n";
         $argumentsCountCheckString .= "        return;\n";
         $argumentsCountCheckString .= "    }\n";
     }
     return $argumentsCountCheckString;
 }
 
 sub GenerateParametersCheck
 {
     my $function = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
     my $style = shift || "new";
 
     my $functionName = $function->name;
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
 
     my $parameterCheckString = "";
     my $paramIndex = 0;
     my %replacements = ();
 
     foreach my $parameter (@{$function->parameters}) {
         my $humanFriendlyIndex = $paramIndex + 1;
         my $nativeType = GetNativeType($parameter->type, $parameter->extendedAttributes, "parameter");
 
         # Optional arguments without [Default=...] should generate an early call with fewer arguments.
         # Optional Dictionary arguments always considered to have default of empty dictionary.
         if ($parameter->isOptional && !$parameter->extendedAttributes->{"Default"} && $nativeType ne "Dictionary" && !IsCallbackInterface($parameter->type)) {
             $parameterCheckString .= <<END;
-    if (UNLIKELY(args.Length() <= $paramIndex)) {
+    if (UNLIKELY(info.Length() <= $paramIndex)) {
 END
             $parameterCheckString .= GenerateFunctionCallString($function, $paramIndex, "    " x 2, $interface, $forMainWorldSuffix, %replacements);
             $parameterCheckString .= <<END;
         return;
     }
 END
         }
 
         my $parameterName = $parameter->name;
         AddToImplIncludes("bindings/v8/ExceptionMessages.h");
         AddToImplIncludes("bindings/v8/ExceptionState.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 .= "            throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", \"The callback provided as parameter $humanFriendlyIndex is not a function.\"), args.GetIsolate());\n";
+                $parameterCheckString .= "    if (info.Length() > $paramIndex && !info[$paramIndex]->IsNull() && !info[$paramIndex]->IsUndefined()) {\n";
+                $parameterCheckString .= "        if (!info[$paramIndex]->IsFunction()) {\n";
+                $parameterCheckString .= "            throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", \"The callback provided as parameter $humanFriendlyIndex is not a function.\"), info.GetIsolate());\n";
                 $parameterCheckString .= "            return;\n";
                 $parameterCheckString .= "        }\n";
-                $parameterCheckString .= "        $parameterName = ${v8ClassName}::create(args[$paramIndex], getExecutionContext());\n";
+                $parameterCheckString .= "        $parameterName = ${v8ClassName}::create(info[$paramIndex], getExecutionContext());\n";
                 $parameterCheckString .= "    }\n";
             } else {
-                $parameterCheckString .= "    if (args.Length() <= $paramIndex || ";
+                $parameterCheckString .= "    if (info.Length() <= $paramIndex || ";
                 if ($parameter->isNullable) {
-                    $parameterCheckString .= "!(args[$paramIndex]->IsFunction() || args[$paramIndex]->IsNull())";
+                    $parameterCheckString .= "!(info[$paramIndex]->IsFunction() || info[$paramIndex]->IsNull())";
                 } else {
-                    $parameterCheckString .= "!args[$paramIndex]->IsFunction()";
+                    $parameterCheckString .= "!info[$paramIndex]->IsFunction()";
                 }
                 $parameterCheckString .= ") {\n";
-                $parameterCheckString .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", \"The callback provided as parameter $humanFriendlyIndex is not a function.\"), args.GetIsolate());\n";
+                $parameterCheckString .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", \"The callback provided as parameter $humanFriendlyIndex is not a function.\"), info.GetIsolate());\n";
                 $parameterCheckString .= "        return;\n";
                 $parameterCheckString .= "    }\n";
                 $parameterCheckString .= "    RefPtr<" . $parameter->type . "> $parameterName = ";
-                $parameterCheckString .= "args[$paramIndex]->IsNull() ? 0 : " if $parameter->isNullable;
-                $parameterCheckString .= "${v8ClassName}::create(args[$paramIndex], getExecutionContext());\n";
+                $parameterCheckString .= "info[$paramIndex]->IsNull() ? 0 : " if $parameter->isNullable;
+                $parameterCheckString .= "${v8ClassName}::create(info[$paramIndex], getExecutionContext());\n";
             }
         } elsif ($parameter->extendedAttributes->{"Clamp"}) {
                 my $nativeValue = "${parameterName}NativeValue";
                 my $idlType = $parameter->type;
                 $parameterCheckString .= "    $nativeType $parameterName = 0;\n";
-                $parameterCheckString .= "    V8TRYCATCH_VOID(double, $nativeValue, args[$paramIndex]->NumberValue());\n";
+                $parameterCheckString .= "    V8TRYCATCH_VOID(double, $nativeValue, info[$paramIndex]->NumberValue());\n";
                 $parameterCheckString .= "    if (!std::isnan($nativeValue))\n";
                 $parameterCheckString .= "        $parameterName = clampTo<$idlType>($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 .= "    $nativeType $parameterName = SerializedScriptValue::create(info[$paramIndex], 0, 0, ${parameterName}DidThrow, info.GetIsolate());\n";
             $parameterCheckString .= "    if (${parameterName}DidThrow)\n";
             $parameterCheckString .= "        return;\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 .= "            throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", \"parameter $humanFriendlyIndex is not of type \'$argType\'.\"), args.GetIsolate());\n";
+                $parameterCheckString .= "    for (int i = $paramIndex; i < info.Length(); ++i) {\n";
+                $parameterCheckString .= "        if (!V8${argType}::HasInstance(info[i], info.GetIsolate(), worldType(info.GetIsolate()))) {\n";
+                $parameterCheckString .= "            throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", \"parameter $humanFriendlyIndex is not of type \'$argType\'.\"), info.GetIsolate());\n";
                 $parameterCheckString .= "            return;\n";
                 $parameterCheckString .= "        }\n";
-                $parameterCheckString .= "        $parameterName.append(V8${argType}::toNative(v8::Handle<v8::Object>::Cast(args[i])));\n";
+                $parameterCheckString .= "        $parameterName.append(V8${argType}::toNative(v8::Handle<v8::Object>::Cast(info[i])));\n";
                 $parameterCheckString .= "    }\n";
             } else {
-                $parameterCheckString .= "    V8TRYCATCH_VOID(Vector<$nativeElementType>, $parameterName, toNativeArguments<$nativeElementType>(args, $paramIndex));\n";
+                $parameterCheckString .= "    V8TRYCATCH_VOID(Vector<$nativeElementType>, $parameterName, toNativeArguments<$nativeElementType>(info, $paramIndex));\n";
             }
         } elsif ($nativeType =~ /^V8StringResource/) {
             my $default = defined $parameter->extendedAttributes->{"Default"} ? $parameter->extendedAttributes->{"Default"} : "";
-            my $jsValue = $parameter->isOptional && $default eq "NullString" ? "argumentOrNull(args, $paramIndex)" : "args[$paramIndex]";
+            my $jsValue = $parameter->isOptional && $default eq "NullString" ? "argumentOrNull(info, $paramIndex)" : "info[$paramIndex]";
             my $stringResourceParameterName = $parameterName;
             my $isNullable = $parameter->isNullable && !IsRefPtrType($parameter->type);
             if ($isNullable) {
                 $parameterCheckString .= "    bool ${parameterName}IsNull = $jsValue->IsNull();\n";
                 $stringResourceParameterName .= "StringResource";
             }
-            $parameterCheckString .= JSValueToNativeStatement($parameter->type, $parameter->extendedAttributes, $humanFriendlyIndex, $jsValue, $stringResourceParameterName, "    ", "args.GetIsolate()");
+            $parameterCheckString .= JSValueToNativeStatement($parameter->type, $parameter->extendedAttributes, $humanFriendlyIndex, $jsValue, $stringResourceParameterName, "    ", "info.GetIsolate()");
             $parameterCheckString .= "    String $parameterName = $stringResourceParameterName;\n" if $isNullable;
             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 .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", \"parameter $humanFriendlyIndex (\'\" + string + \"\') is not a valid enum value.\"), args.GetIsolate());\n";
+                $parameterCheckString .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", \"parameter $humanFriendlyIndex (\'\" + string + \"\') is not a valid enum value.\"), info.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->extendedAttributes->{"StrictTypeChecking"}) {
-                my $argValue = "args[$paramIndex]";
+                my $argValue = "info[$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 .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", \"parameter $humanFriendlyIndex is not of type \'$argType\'.\"), args.GetIsolate());\n";
+                    $parameterCheckString .= "    if (info.Length() > $paramIndex && !isUndefinedOrNull($argValue) && !V8${argType}::HasInstance($argValue, info.GetIsolate(), worldType(info.GetIsolate()))) {\n";
+                    $parameterCheckString .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", \"parameter $humanFriendlyIndex is not of type \'$argType\'.\"), info.GetIsolate());\n";
                     $parameterCheckString .= "        return;\n";
                     $parameterCheckString .= "    }\n";
                 }
             }
             my $default = defined $parameter->extendedAttributes->{"Default"} ? $parameter->extendedAttributes->{"Default"} : "";
-            my $jsValue = $parameter->isOptional && $default eq "NullString" ? "argumentOrNull(args, $paramIndex)" : "args[$paramIndex]";
+            my $jsValue = $parameter->isOptional && $default eq "NullString" ? "argumentOrNull(info, $paramIndex)" : "info[$paramIndex]";
             my $isNullable = $parameter->isNullable && !IsRefPtrType($parameter->type);
             $parameterCheckString .= "    bool ${parameterName}IsNull = $jsValue->IsNull();\n" if $isNullable;
-            $parameterCheckString .= JSValueToNativeStatement($parameter->type, $parameter->extendedAttributes, $humanFriendlyIndex, $jsValue, $parameterName, "    ", "args.GetIsolate()");
+            $parameterCheckString .= JSValueToNativeStatement($parameter->type, $parameter->extendedAttributes, $humanFriendlyIndex, $jsValue, $parameterName, "    ", "info.GetIsolate()");
             if ($nativeType eq 'Dictionary' or $nativeType eq 'ScriptPromise') {
                 $parameterCheckString .= "    if (!$parameterName.isUndefinedOrNull() && !$parameterName.isObject()) {\n";
                 if ($functionName eq "Constructor") {
-                    $parameterCheckString .= "        throwTypeError(ExceptionMessages::failedToConstruct(\"$interfaceName\", \"parameter ${humanFriendlyIndex} ('${parameterName}') is not an object.\"), args.GetIsolate());\n";
+                    $parameterCheckString .= "        throwTypeError(ExceptionMessages::failedToConstruct(\"$interfaceName\", \"parameter ${humanFriendlyIndex} ('${parameterName}') is not an object.\"), info.GetIsolate());\n";
                 } else {
-                    $parameterCheckString .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", \"parameter ${humanFriendlyIndex} ('${parameterName}') is not an object.\"), args.GetIsolate());\n";
+                    $parameterCheckString .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", \"parameter ${humanFriendlyIndex} ('${parameterName}') is not an object.\"), info.GetIsolate());\n";
                 }
                 $parameterCheckString .= "        return;\n";
                 $parameterCheckString .= "    }\n";
             }
         }
 
         $paramIndex++;
     }
     return ($parameterCheckString, $paramIndex, %replacements);
 }
 
 sub GenerateOverloadedConstructorCallback
 {
     my $interface = shift;
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
 
     my $code = "";
     $code .= <<END;
-static void constructor(const v8::FunctionCallbackInfo<v8::Value>& args)
+static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
 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 .= "        ${implClassName}V8Internal::${name}(args);\n";
+        $code .= "        ${implClassName}V8Internal::${name}(info);\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
     if ($leastNumMandatoryParams >= 1) {
         AddToImplIncludes("bindings/v8/ExceptionMessages.h");
-        $code .= "    if (UNLIKELY(args.Length() < $leastNumMandatoryParams)) {\n";
+        $code .= "    if (UNLIKELY(info.Length() < $leastNumMandatoryParams)) {\n";
 
-        $code .= "        throwTypeError(ExceptionMessages::failedToConstruct(\"$interfaceName\", ExceptionMessages::notEnoughArguments($leastNumMandatoryParams, args.Length())), args.GetIsolate());\n";
+        $code .= "        throwTypeError(ExceptionMessages::failedToConstruct(\"$interfaceName\", ExceptionMessages::notEnoughArguments($leastNumMandatoryParams, info.Length())), info.GetIsolate());\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
     $code .= <<END;
-    throwUninformativeAndGenericTypeError(args.GetIsolate());
+    throwUninformativeAndGenericTypeError(info.GetIsolate());
     return;
 END
     $code .= "}\n\n";
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateSingleConstructorCallback
 {
     my $interface = shift;
     my $function = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $overloadedIndexString = "";
     if ($function->overloadedIndex > 0) {
         $overloadedIndexString .= $function->overloadedIndex;
     }
 
     my $raisesExceptions = $function->extendedAttributes->{"RaisesException"};
     if ($interface->extendedAttributes->{"ConstructorRaisesException"}) {
         $raisesExceptions = 1;
     }
 
     my @beforeArgumentList;
     my @afterArgumentList;
     my $code = "";
     $code .= <<END;
-static void constructor${overloadedIndexString}(const v8::FunctionCallbackInfo<v8::Value>& args)
+static void constructor${overloadedIndexString}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
 END
 
     if ($function->overloadedIndex == 0) {
         $code .= GenerateArgumentsCountCheck($function, $interface);
     }
 
     if ($raisesExceptions) {
         AddToImplIncludes("bindings/v8/ExceptionMessages.h");
         AddToImplIncludes("bindings/v8/ExceptionState.h");
-        $code .= "    ExceptionState es(args.GetIsolate());\n";
+        $code .= "    ExceptionState es(info.GetIsolate());\n";
     }
 
     # FIXME: Currently [Constructor(...)] does not yet support optional arguments without [Default=...]
     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface, "");
     $code .= $parameterCheckString;
 
     if ($interface->extendedAttributes->{"ConstructorCallWith"}) {
         if ($interface->extendedAttributes->{"ConstructorCallWith"} eq "ExecutionContext") {
             push(@beforeArgumentList, "context");
             $code .= "\n";
@@ skipping 17 matching lines @@
             push(@argumentList, $replacements{$parameter->name});
         } else {
             push(@argumentList, $parameter->name);
         }
         $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";
+    $code .= "    v8::Handle<v8::Object> wrapper = info.Holder();\n";
 
     if ($interface->extendedAttributes->{"ConstructorRaisesException"}) {
         $code .= "    if (es.throwIfNeeded())\n";
         $code .= "        return;\n";
     }
 
     $code .= <<END;
 
-    V8DOMWrapper::associateObjectWithWrapper<${v8ClassName}>(impl.release(), &${v8ClassName}::wrapperTypeInfo, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
-    args.GetReturnValue().Set(wrapper);
+    V8DOMWrapper::associateObjectWithWrapper<${v8ClassName}>(impl.release(), &${v8ClassName}::wrapperTypeInfo, wrapper, info.GetIsolate(), WrapperConfiguration::Dependent);
+    info.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 .= "void ${v8ClassName}::constructorCallback(const v8::FunctionCallbackInfo<v8::Value>& args)\n";
+    $code .= "void ${v8ClassName}::constructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info)\n";
     $code .= "{\n";
     $code .= "    TRACE_EVENT_SCOPED_SAMPLING_STATE(\"Blink\", \"DOMConstructor\");\n";
     $code .= GenerateFeatureObservation($interface->extendedAttributes->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($interface->extendedAttributes->{"DeprecateAs"});
     $code .= GenerateConstructorHeader($interface->name);
     if (HasCustomConstructor($interface)) {
-        $code .= "    ${v8ClassName}::constructorCustom(args);\n";
+        $code .= "    ${v8ClassName}::constructorCustom(info);\n";
     } else {
-        $code .= "    ${implClassName}V8Internal::constructor(args);\n";
+        $code .= "    ${implClassName}V8Internal::constructor(info);\n";
     }
     $code .= "}\n\n";
     $implementation{nameSpaceWebCore}->add($code);
 }
 
 sub GenerateConstructor
 {
     my $interface = shift;
 
     if (@{$interface->constructors} == 1) {
@@ skipping 20 matching lines @@
             push(@anyAttributeNames, $attribute->name);
             if (!$attribute->extendedAttributes->{"Unserializable"}) {
                 push(@serializableAnyAttributeNames, $attribute->name);
             }
         }
     }
 
     AddToImplIncludes("bindings/v8/Dictionary.h");
     AddToImplIncludes("bindings/v8/ExceptionMessages.h");
     $implementation{nameSpaceInternal}->add(<<END);
-static void constructor(const v8::FunctionCallbackInfo<v8::Value>& args)
+static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    if (args.Length() < 1) {
-        throwTypeError(ExceptionMessages::failedToConstruct("$interfaceName", "An event name must be provided."), args.GetIsolate());
+    if (info.Length() < 1) {
+        throwTypeError(ExceptionMessages::failedToConstruct("$interfaceName", "An event name must be provided."), info.GetIsolate());
         return;
     }
 
-    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, type, args[0]);
+    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, type, info[0]);
 END
 
     foreach my $attrName (@anyAttributeNames) {
         $implementation{nameSpaceInternal}->add("    v8::Local<v8::Value> ${attrName};\n");
     }
 
     $implementation{nameSpaceInternal}->add(<<END);
     ${implClassName}Init eventInit;
-    if (args.Length() >= 2) {
-        V8TRYCATCH_VOID(Dictionary, options, Dictionary(args[1], args.GetIsolate()));
+    if (info.Length() >= 2) {
+        V8TRYCATCH_VOID(Dictionary, options, Dictionary(info[1], info.GetIsolate()));
         if (!fill${implClassName}Init(eventInit, options))
             return;
 END
 
     # Store 'any'-typed properties on the wrapper to avoid leaking them between isolated worlds.
     foreach my $attrName (@anyAttributeNames) {
         $implementation{nameSpaceInternal}->add(<<END);
         options.get("${attrName}", ${attrName});
         if (!${attrName}.IsEmpty())
-            args.Holder()->SetHiddenValue(V8HiddenPropertyName::${attrName}(args.GetIsolate()), ${attrName});
+            info.Holder()->SetHiddenValue(V8HiddenPropertyName::${attrName}(info.GetIsolate()), ${attrName});
 END
     }
 
     $implementation{nameSpaceInternal}->add(<<END);
     }
 
     RefPtr<${implClassName}> event = ${implClassName}::create(type, eventInit);
 END
 
     if (@serializableAnyAttributeNames) {
         # If we're in an isolated world, create a SerializedScriptValue and store it in the event for
         # later cloning if the property is accessed from another world.
         # The main world case is handled lazily (in Custom code).
-        $implementation{nameSpaceInternal}->add("    if (isolatedWorldForIsolate(args.GetIsolate())) {\n");
+        $implementation{nameSpaceInternal}->add("    if (isolatedWorldForIsolate(info.GetIsolate())) {\n");
         foreach my $attrName (@serializableAnyAttributeNames) {
             my $setter = "setSerialized" . FirstLetterToUpperCase($attrName);
             $implementation{nameSpaceInternal}->add(<<END);
         if (!${attrName}.IsEmpty())
-            event->${setter}(SerializedScriptValue::createAndSwallowExceptions(${attrName}, args.GetIsolate()));
+            event->${setter}(SerializedScriptValue::createAndSwallowExceptions(${attrName}, info.GetIsolate()));
 END
         }
         $implementation{nameSpaceInternal}->add("    }\n\n");
     }
 
     $implementation{nameSpaceInternal}->add(<<END);
-    v8::Handle<v8::Object> wrapper = args.Holder();
-    V8DOMWrapper::associateObjectWithWrapper<${v8ClassName}>(event.release(), &${v8ClassName}::wrapperTypeInfo, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
-    v8SetReturnValue(args, wrapper);
+    v8::Handle<v8::Object> wrapper = info.Holder();
+    V8DOMWrapper::associateObjectWithWrapper<${v8ClassName}>(event.release(), &${v8ClassName}::wrapperTypeInfo, wrapper, info.GetIsolate(), WrapperConfiguration::Dependent);
+    v8SetReturnValue(info, wrapper);
 }
 END
 
     my $code = "";
     $code .= <<END;
 bool fill${implClassName}Init(${implClassName}Init& eventInit, const Dictionary& options)
 {
 END
 
     if ($interface->parent) {
@@ skipping 58 matching lines @@
         $toEventTarget = "${v8ClassName}::toEventTarget";
     }
 
     $implementation{nameSpaceWebCore}->add(<<END);
 const WrapperTypeInfo ${v8ClassName}Constructor::wrapperTypeInfo = { ${v8ClassName}Constructor::GetTemplate, ${v8ClassName}::derefObject, $toActiveDOMObject, $toEventTarget, 0, ${v8ClassName}::installPerContextEnabledPrototypeProperties, 0, WrapperTypeObjectPrototype };
 
 END
 
     my $code = "";
     $code .= <<END;
-static void ${v8ClassName}ConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
+static void ${v8ClassName}ConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
 END
     $code .= $maybeObserveFeature if $maybeObserveFeature;
     $code .= $maybeDeprecateFeature if $maybeDeprecateFeature;
     $code .= GenerateConstructorHeader($function->extendedAttributes->{"NamedConstructor"});
     AddToImplIncludes("V8Document.h");
     $code .= <<END;
     Document* document = currentDocument();
     ASSERT(document);
 
     // Make sure the document is added to the DOM Node map. Otherwise, the ${implClassName} instance
     // may end up being the only node in the map and get garbage-collected prematurely.
-    toV8(document, args.Holder(), args.GetIsolate());
+    toV8(document, info.Holder(), info.GetIsolate());
 
 END
 
     $code .= GenerateArgumentsCountCheck($function, $interface);
 
     if ($raisesExceptions) {
         AddToImplIncludes("bindings/v8/ExceptionMessages.h");
         AddToImplIncludes("bindings/v8/ExceptionState.h");
-        $code .= "    ExceptionState es(args.GetIsolate());\n";
+        $code .= "    ExceptionState es(info.GetIsolate());\n";
     }
 
     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface);
     $code .= $parameterCheckString;
 
     push(@beforeArgumentList, "*document");
 
     if ($interface->extendedAttributes->{"ConstructorRaisesException"}) {
         push(@afterArgumentList, "es");
     }
 
     my @argumentList;
     my $index = 0;
     foreach my $parameter (@{$function->parameters}) {
         last if $index eq $paramIndex;
         if ($replacements{$parameter->name}) {
             push(@argumentList, $replacements{$parameter->name});
         } else {
             push(@argumentList, $parameter->name);
         }
         $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";
+    $code .= "    v8::Handle<v8::Object> wrapper = info.Holder();\n";
 
     if ($interface->extendedAttributes->{"ConstructorRaisesException"}) {
         $code .= "    if (es.throwIfNeeded())\n";
         $code .= "        return;\n";
     }
 
     $code .= <<END;
 
-    V8DOMWrapper::associateObjectWithWrapper<${v8ClassName}>(impl.release(), &${v8ClassName}Constructor::wrapperTypeInfo, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
-    args.GetReturnValue().Set(wrapper);
+    V8DOMWrapper::associateObjectWithWrapper<${v8ClassName}>(impl.release(), &${v8ClassName}Constructor::wrapperTypeInfo, wrapper, info.GetIsolate(), WrapperConfiguration::Dependent);
+    info.GetReturnValue().Set(wrapper);
 }
 
 END
     $implementation{nameSpaceWebCore}->add($code);
 
     $code = <<END;
 v8::Handle<v8::FunctionTemplate> ${v8ClassName}Constructor::GetTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     // This is only for getting a unique pointer which we can pass to privateTemplate.
     static int privateTemplateUniqueKey;
@@ skipping 19 matching lines @@
     $implementation{nameSpaceWebCore}->add($code);
 }
 
 sub GenerateConstructorHeader
 {
     my $constructorName = shift;
 
     AddToImplIncludes("bindings/v8/ExceptionMessages.h");
     AddToImplIncludes("bindings/v8/V8ObjectConstructor.h");
     my $content = <<END;
-    if (!args.IsConstructCall()) {
-        throwTypeError(ExceptionMessages::failedToConstruct("$constructorName", "Please use the 'new' operator, this DOM object constructor cannot be called as a function."), args.GetIsolate());
+    if (!info.IsConstructCall()) {
+        throwTypeError(ExceptionMessages::failedToConstruct("$constructorName", "Please use the 'new' operator, this DOM object constructor cannot be called as a function."), info.GetIsolate());
         return;
     }
 
     if (ConstructorMode::current() == ConstructorMode::WrapExistingObject) {
-        args.GetReturnValue().Set(args.Holder());
+        info.GetReturnValue().Set(info.Holder());
         return;
     }
 
 END
     return $content;
 }
 
 sub GenerateAttributeConfigurationArray
 {
     my $interface = shift;
@@ skipping 2062 matching lines @@
 
         if ($replacements{$paramName}) {
             push @arguments, $replacements{$paramName};
         } elsif ($parameter->type eq "NodeFilter" || $parameter->type eq "XPathNSResolver") {
             push @arguments, "$paramName.get()";
         } elsif (IsSVGTypeNeedingTearOff($parameter->type) and not $interfaceName =~ /List$/) {
             AddToImplIncludes("core/dom/ExceptionCode.h");
             push @arguments, "$paramName->propertyReference()";
             $code .= <<END;
     if (!$paramName) {
-        throwUninformativeAndGenericTypeError(args.GetIsolate());
+        throwUninformativeAndGenericTypeError(info.GetIsolate());
         return;
     }
 END
         } elsif ($parameter->type eq "SVGMatrix" and $interfaceName eq "SVGTransformList") {
             push @arguments, "$paramName.get()";
         } elsif ($parameter->isNullable && !IsRefPtrType($parameter->type)) {
             push @arguments, "${paramName}IsNull ? 0 : &$paramName";
         } else {
             push @arguments, $paramName;
         }
@@ skipping 25 matching lines @@
 
     if ($function->extendedAttributes->{"RaisesException"}) {
         $code .= $indent . "if (es.throwIfNeeded())\n";
         $code .= $indent . "    return;\n";
     }
 
     if (ExtendedAttributeContains($callWith, "ScriptState")) {
         $code .= $indent . "if (state.hadException()) {\n";
         $code .= $indent . "    v8::Local<v8::Value> exception = state.exception();\n";
         $code .= $indent . "    state.clearException();\n";
-        $code .= $indent . "    throwError(exception, args.GetIsolate());\n";
+        $code .= $indent . "    throwError(exception, info.GetIsolate());\n";
         $code .= $indent . "    return;\n";
         $code .= $indent . "}\n";
     }
 
     if ($isSVGTearOffType) {
         AddToImplIncludes("V8$returnType.h");
         AddToImplIncludes("core/svg/properties/SVGPropertyTearOff.h");
         my $svgNativeType = GetSVGTypeNeedingTearOff($returnType);
         # FIXME: Update for all ScriptWrappables.
         if (IsDOMNodeType($interfaceName)) {
             if ($forMainWorldSuffix eq "ForMainWorld") {
-                $code .= $indent . "v8SetReturnValueForMainWorld(args, WTF::getPtr(${svgNativeType}::create($return)));\n";
+                $code .= $indent . "v8SetReturnValueForMainWorld(info, WTF::getPtr(${svgNativeType}::create($return)));\n";
             } else {
-                $code .= $indent . "v8SetReturnValueFast(args, WTF::getPtr(${svgNativeType}::create($return)), imp);\n";
+                $code .= $indent . "v8SetReturnValueFast(info, WTF::getPtr(${svgNativeType}::create($return)), imp);\n";
             }
         } else {
-            $code .= $indent . "v8SetReturnValue${forMainWorldSuffix}(args, WTF::getPtr(${svgNativeType}::create($return)));\n";
+            $code .= $indent . "v8SetReturnValue${forMainWorldSuffix}(info, WTF::getPtr(${svgNativeType}::create($return)));\n";
         }
         return $code;
     }
 
     # If the implementing class is a POD type, commit changes
     if (IsSVGTypeNeedingTearOff($interfaceName) and not $interfaceName =~ /List$/) {
         $code .= $indent . "wrapper->commitChange();\n";
     }
 
     $return .= ".release()" if ($returnIsRef);
 
     my $nativeValue;
     # FIXME: Update for all ScriptWrappables.
     if (IsDOMNodeType($interfaceName)) {
-        $nativeValue = NativeToJSValue($function->type, $function->extendedAttributes, $return, $indent, "", "args.GetIsolate()", "args", "imp", $forMainWorldSuffix, "return");
+        $nativeValue = NativeToJSValue($function->type, $function->extendedAttributes, $return, $indent, "", "info.GetIsolate()", "info", "imp", $forMainWorldSuffix, "return");
     } else {
-        $nativeValue = NativeToJSValue($function->type, $function->extendedAttributes, $return, $indent, "", "args.GetIsolate()", "args", 0, $forMainWorldSuffix, "return");
+        $nativeValue = NativeToJSValue($function->type, $function->extendedAttributes, $return, $indent, "", "info.GetIsolate()", "info", 0, $forMainWorldSuffix, "return");
     }
 
     $code .= $nativeValue . "\n" if $nativeValue;  # Skip blank line for void return type
 
     return $code;
 }
 
 sub GetNativeType
 {
     my $type = shift;
@@ skipping 1037 matching lines @@
 
     return 1 if $interface->extendedAttributes->{"CustomToV8"};
     return 1 if $interface->extendedAttributes->{"SpecialWrapFor"};
     return 1 if InheritsInterface($interface, "Document");
     return 1 if SVGTypeNeedsToHoldContextElement($interface->name);
 
     return 0;
 }
 
 1;