Hack to add accessors for WebIDL attributes.

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 1276 matching lines @@
         $code .= <<END;
     V8PerContextData* contextData = V8PerContextData::from(args.GetIsolate()->GetCurrentContext());
     if (contextData && contextData->activityLogger()) {
         Vector<v8::Handle<v8::Value> > loggerArgs = toVectorOfArguments(args);
         contextData->activityLogger()->log("${interfaceName}.${propertyName}", args.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
     } elsif ($accessType eq "Getter") {
         $code .= <<END;
     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
     if (contextData && contextData->activityLogger())
         contextData->activityLogger()->log("${interfaceName}.${propertyName}", 0, 0, "${accessType}");
 END
     } else {
         die "Unrecognized activity logging access type";
     }
 
     return $code;
 }
 
 sub GenerateNormalAttributeGetterCallback
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
+    my $isAccessor = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $attrExt = $attribute->extendedAttributes;
     my $attrName = $attribute->name;
 
     my $conditionalString = GenerateConditionalString($attribute);
     my $code = "";
     $code .= "#if ${conditionalString}\n" if $conditionalString;
 
-    $code .= "static void ${attrName}AttributeGetterCallback${forMainWorldSuffix}(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)\n";
+    if ($isAccessor) {
+        $code .= "static void ${attrName}AttributeGetterCallback${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& info)\n";
+    } else {
+        $code .= "static void ${attrName}AttributeGetterCallback${forMainWorldSuffix}(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)\n";
+    }
     $code .= "{\n";
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"Blink\", \"DOMGetter\");\n";
     $code .= GenerateFeatureObservation($attrExt->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($attrExt->{"DeprecateAs"});
     if (HasActivityLogging($forMainWorldSuffix, $attrExt, "Getter")) {
         $code .= GenerateActivityLogging("Getter", $interface, "${attrName}");
     }
     if (HasCustomGetter($attrExt)) {
-        $code .= "    ${v8ClassName}::${attrName}AttributeGetterCustom(name, info);\n";
+        if ($isAccessor) {
+            $code .= "    ${v8ClassName}::${attrName}AttributeGetterCustom(info);\n";
+        } else {
+            $code .= "    ${v8ClassName}::${attrName}AttributeGetterCustom(name, info);\n";
+        }
     } else {
-        $code .= "    ${implClassName}V8Internal::${attrName}AttributeGetter${forMainWorldSuffix}(name, info);\n";
+        if ($isAccessor) {
+            $code .= "    ${implClassName}V8Internal::${attrName}AttributeGetter${forMainWorldSuffix}(info);\n";
+        } else {
+            $code .= "    ${implClassName}V8Internal::${attrName}AttributeGetter${forMainWorldSuffix}(name, info);\n";
+        }
     }
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"V8\", \"Execution\");\n";
     $code .= "}\n";
     $code .= "#endif // ${conditionalString}\n" if $conditionalString;
     $code .= "\n";
 
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GetCachedAttribute
 {
     my $attribute = shift;
     my $attrExt = $attribute->extendedAttributes;
     if (($attribute->type eq "any" || $attribute->type eq "SerializedScriptValue") && $attrExt->{"CachedAttribute"}) {
         return $attrExt->{"CachedAttribute"};
     }
     return "";
 }
 
 sub GenerateNormalAttributeGetter
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
+    my $isAccessor = shift;
 
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $attrExt = $attribute->extendedAttributes;
     my $attrName = $attribute->name;
     my $attrType = $attribute->type;
     my $attrCached = GetCachedAttribute($attribute);
 
     if (HasCustomGetter($attrExt)) {
         return;
     }
 
     AssertNotSequenceType($attrType);
     my $nativeType = GetNativeType($attribute->type, $attribute->extendedAttributes, "");
     my $svgNativeType = GetSVGTypeNeedingTearOff($interfaceName);
 
     my $conditionalString = GenerateConditionalString($attribute);
     my $code = "";
     $code .= "#if ${conditionalString}\n" if $conditionalString;
-    $code .= <<END;
-static void ${attrName}AttributeGetter${forMainWorldSuffix}(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
-{
-END
+    if ($isAccessor) {
+        $code .= "static void ${attrName}AttributeGetter${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& info)\n";
+        $code .= "{\n";
+    } else {
+        $code .= "static void ${attrName}AttributeGetter${forMainWorldSuffix}(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)\n";
+        $code .= "{\n";
+    }
     if ($svgNativeType) {
         my $svgWrappedNativeType = GetSVGWrappedTypeNeedingTearOff($interfaceName);
         if ($svgWrappedNativeType =~ /List/) {
             $code .= <<END;
     $svgNativeType* imp = ${v8ClassName}::toNative(info.Holder());
 END
         } else {
             $code .= <<END;
     $svgNativeType* wrapper = ${v8ClassName}::toNative(info.Holder());
     $svgWrappedNativeType& impInstance = wrapper->propertyReference();
@@ skipping 347 matching lines @@
 END
     }
     return $code;
 }
 
 sub GenerateNormalAttributeSetterCallback
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
+    my $isAccessor = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $attrExt = $attribute->extendedAttributes;
     my $attrName = $attribute->name;
 
     my $conditionalString = GenerateConditionalString($attribute);
     my $code = "";
     $code .= "#if ${conditionalString}\n" if $conditionalString;
 
-    $code .= "static void ${attrName}AttributeSetterCallback${forMainWorldSuffix}(v8::Local<v8::String> name, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)\n";
+    if ($isAccessor) {
+        $code .= "static void ${attrName}AttributeSetterCallback${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& info)\n";
+    } else {
+        $code .= "static void ${attrName}AttributeSetterCallback${forMainWorldSuffix}(v8::Local<v8::String> name, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)\n";
+    }
     $code .= "{\n";
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"Blink\", \"DOMSetter\");\n";
     $code .= GenerateFeatureObservation($attrExt->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($attrExt->{"DeprecateAs"});
     if (HasActivityLogging($forMainWorldSuffix, $attrExt, "Setter")) {
         $code .= GenerateActivityLogging("Setter", $interface, "${attrName}");
     }
     $code .= GenerateCustomElementInvocationScopeIfNeeded($attrExt);
     if (HasCustomSetter($attribute)) {
-        $code .= "    ${v8ClassName}::${attrName}AttributeSetterCustom(name, jsValue, info);\n";
+        if ($isAccessor) {
+            $code .= "    ${v8ClassName}::${attrName}AttributeSetterCustom(info);\n";
+        } else {
+            $code .= "    ${v8ClassName}::${attrName}AttributeSetterCustom(name, jsValue, info);\n";
+        }
     } else {
-        $code .= "    ${implClassName}V8Internal::${attrName}AttributeSetter${forMainWorldSuffix}(name, jsValue, info);\n";
+        if ($isAccessor) {
+            $code .= "    ${implClassName}V8Internal::${attrName}AttributeSetter${forMainWorldSuffix}(info);\n";
+        } else {
+            $code .= "    ${implClassName}V8Internal::${attrName}AttributeSetter${forMainWorldSuffix}(name, jsValue, info);\n";
+        }
     }
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"V8\", \"Execution\");\n";
     $code .= "}\n";
     $code .= "#endif // ${conditionalString}\n" if $conditionalString;
     $code .= "\n";
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub FindAttributeWithName
 {
     my $interface = shift;
     my $attrName = shift;
 
     foreach my $attribute (@{$interface->attributes}) {
         if ($attribute->name eq $attrName) {
             return $attribute;
         }
     }
 }
 
 sub GenerateNormalAttributeSetter
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
+    my $isAccessor = shift;
 
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $attrName = $attribute->name;
     my $attrExt = $attribute->extendedAttributes;
     my $attrType = $attribute->type;
     my $attrCached = GetCachedAttribute($attribute);
 
     if (HasCustomSetter($attribute)) {
         return;
     }
 
     my $conditionalString = GenerateConditionalString($attribute);
     my $code = "";
     $code .= "#if ${conditionalString}\n" if $conditionalString;
-    $code .= "static void ${attrName}AttributeSetter${forMainWorldSuffix}(v8::Local<v8::String> name, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)\n";
-    $code .= "{\n";
+    if ($isAccessor) {
+        $code .= "static void ${attrName}AttributeSetter${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& info)\n";
+        $code .= "{\n";
+        $code .= "    v8::Local<v8::Value> jsValue = info[0];\n";
+    } else {
+        $code .= "static void ${attrName}AttributeSetter${forMainWorldSuffix}(v8::Local<v8::String> name, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)\n";
+        $code .= "{\n";
+    }
 
     # If the "StrictTypeChecking" extended attribute is present, and the attribute'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 attribute is of these types.
     if ($attribute->extendedAttributes->{"StrictTypeChecking"}) {
         my $argType = $attribute->type;
         if (IsWrapperType($argType)) {
             $code .= "    if (!isUndefinedOrNull(jsValue) && !V8${argType}::HasInstance(jsValue, info.GetIsolate(), worldType(info.GetIsolate()))) {\n";
@@ skipping 1175 matching lines @@
     }
 
 END
     return $content;
 }
 
 sub GenerateAttributeConfigurationArray
 {
     my $interface = shift;
     my $attributes = shift;
+    my $isAccessor = shift;
     my $code = "";
 
     foreach my $attribute (@$attributes) {
         my $conditionalString = GenerateConditionalString($attribute);
         my $subCode = "";
         $subCode .= "#if ${conditionalString}\n" if $conditionalString;
-        $subCode .= GenerateAttributeConfiguration($interface, $attribute, ",", "");
+        $subCode .= GenerateAttributeConfiguration($interface, $attribute, ",", "", $isAccessor);
         $subCode .= "#endif // ${conditionalString}\n" if $conditionalString;
         $code .= $subCode;
     }
     return $code;
 }
 
 sub GenerateAttributeConfigurationParameters
 {
     my $interface = shift;
     my $attribute = shift;
+    my $isAccessor = shift;
     my $attrName = $attribute->name;
     my $attrExt = $attribute->extendedAttributes;
     my $implClassName = GetImplName($interface);
 
     my @accessControlList;
     if ($attrExt->{"DoNotCheckSecurityOnGetter"}) {
         push(@accessControlList, "v8::ALL_CAN_READ");
     } elsif ($attrExt->{"DoNotCheckSecurityOnSetter"}) {
         push(@accessControlList, "v8::ALL_CAN_WRITE");
     } elsif ($attrExt->{"DoNotCheckSecurity"}) {
@@ skipping 27 matching lines @@
     my @propAttributeList;
     if ($attrExt->{"NotEnumerable"} || $isConstructor) {
         push(@propAttributeList, "v8::DontEnum");
     }
     if ($attrExt->{"Unforgeable"} && !$isConstructor) {
         push(@propAttributeList, "v8::DontDelete");
     }
     @propAttributeList = ("v8::None") unless @propAttributeList;
     my $propAttribute = join(" | ", @propAttributeList);
 
-    my $on_proto = "0 /* on instance */";
+    my $onPrototype = "0 /* on instance */";
     my $data = "0";  # no data
 
     # Constructor
     if ($isConstructor) {
         my $constructorType = $attribute->type;
         $constructorType =~ s/Constructor$//;
         # $constructorType ~= /Constructor$/ indicates that it is NamedConstructor.
         # We do not generate the header file for NamedConstructor of class XXXX,
         # since we generate the NamedConstructor declaration into the header file of class XXXX.
         if ($constructorType !~ /Constructor$/ || $attribute->extendedAttributes->{"CustomConstructor"}) {
@@ skipping 18 matching lines @@
     }
 
     # Read only attributes
     if (IsReadonly($attribute)) {
         $setter = "0";
         $setterForMainWorld = "0";
     }
 
     # An accessor can be installed on the proto
     if ($attrExt->{"OnProto"}) {
-        $on_proto = "1 /* on proto */";
+        $onPrototype = "1 /* on proto */";
     }
 
     if (!$attrExt->{"PerWorldBindings"}) {
       $getterForMainWorld = "0";
       $setterForMainWorld = "0";
     }
 
-    return ($attrName, $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, "static_cast<v8::PropertyAttribute>($propAttribute)", $on_proto);
+    return ($attrName, $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, "static_cast<v8::PropertyAttribute>($propAttribute)", $onPrototype);
 }
 
 sub GenerateAttributeConfiguration
 {
     my $interface = shift;
     my $attribute = shift;
     my $delimiter = shift;
     my $indent = shift;
+    my $isAccessor = shift;
     my $code = "";
 
-    my ($attrName, $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, $propAttribute, $on_proto) = GenerateAttributeConfigurationParameters($interface, $attribute);
+    my ($attrName, $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, $propAttribute, $onPrototype) = GenerateAttributeConfigurationParameters($interface, $attribute, $isAccessor);
 
-    $code .= $indent . "    {\"$attrName\", $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, $propAttribute, $on_proto}" . $delimiter . "\n";
+    if ($isAccessor) {
+        $code .= $indent . "    {\"$attrName\", $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, $propAttribute}" . $delimiter . "\n";
+    } else {
+        $code .= $indent . "    {\"$attrName\", $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, $propAttribute, $onPrototype}" . $delimiter . "\n";
+    }
     return $code;
 }
 
 sub GenerateStaticAttribute
 {
     my $interface = shift;
     my $attribute = shift;
     my $attrExt = $attribute->extendedAttributes;
     my $code = "";
 
-    my ($attrName, $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, $propAttribute, $on_proto) = GenerateAttributeConfigurationParameters($interface, $attribute);
+    my ($attrName, $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, $propAttribute, $onPrototype) = GenerateAttributeConfigurationParameters($interface, $attribute);
 
     die "Static attributes do not support optimized getters or setters for the main world" if $getterForMainWorld || $setterForMainWorld;
 
     my $conditionalString = GenerateConditionalString($attribute);
 
     $code .= "#if ${conditionalString}\n" if $conditionalString;
     $code .= "    desc->SetNativeDataProperty(v8::String::NewSymbol(\"$attrName\"), $getter, $setter, v8::External::New($data), $propAttribute, v8::Handle<v8::AccessorSignature>(), $accessControl);\n";
     $code .= "#endif // ${conditionalString}\n" if $conditionalString;
 
     return $code;
@@ skipping 911 matching lines @@
         if ($attrType eq "SerializedScriptValue") {
             AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
         }
 
         my $isReplaceable = 0;
         if (!HasCustomSetter($attribute) && !$attrExt->{"PutForwards"} && $attrExt->{"Replaceable"}) {
             $isReplaceable = 1;
             $hasReplaceable = 1;
         }
 
+        my $isAccessor = $attrExt->{"ExposeV8GetterAndSetter"};
         my @worldSuffixes = ("");
         if ($attrExt->{"PerWorldBindings"}) {
             push(@worldSuffixes, "ForMainWorld");
         }
         foreach my $worldSuffix (@worldSuffixes) {
-            GenerateNormalAttributeGetter($attribute, $interface, $worldSuffix);
-            GenerateNormalAttributeGetterCallback($attribute, $interface, $worldSuffix);
+            GenerateNormalAttributeGetter($attribute, $interface, $worldSuffix, $isAccessor);
+            GenerateNormalAttributeGetterCallback($attribute, $interface, $worldSuffix, $isAccessor);
             if (!$isReplaceable && !IsReadonly($attribute)) {
-                GenerateNormalAttributeSetter($attribute, $interface, $worldSuffix);
-                GenerateNormalAttributeSetterCallback($attribute, $interface, $worldSuffix);
+                GenerateNormalAttributeSetter($attribute, $interface, $worldSuffix, $isAccessor);
+                GenerateNormalAttributeSetterCallback($attribute, $interface, $worldSuffix, $isAccessor);
             }
         }
     }
 
     if ($hasConstructors) {
         GenerateConstructorGetter($interface);
     }
 
     if ($hasConstructors || $hasReplaceable) {
         GenerateReplaceableAttributeSetter($interface);
@@ skipping 73 matching lines @@
     # Attributes
     my $attributes = $interface->attributes;
 
     # For the Window interface we partition the attributes into the
     # ones that disallows shadowing and the rest.
     my @disallowsShadowing;
     # Also separate out attributes that are enabled at runtime so we can process them specially.
     my @runtimeEnabledAttributes;
     my @perContextEnabledAttributes;
     my @normalAttributes;
+    my @normalAccessors;
     my @staticAttributes;
     foreach my $attribute (@$attributes) {
-
         if ($attribute->isStatic) {
             push(@staticAttributes, $attribute);
         } elsif ($interfaceName eq "Window" && $attribute->extendedAttributes->{"Unforgeable"}) {
             push(@disallowsShadowing, $attribute);
-        } elsif ($attribute->extendedAttributes->{"PerContextEnabled"}) {
-            push(@perContextEnabledAttributes, $attribute);
-        } elsif ($attribute->extendedAttributes->{"RuntimeEnabled"}) {
-            push(@runtimeEnabledAttributes, $attribute);
+        } elsif ($attribute->extendedAttributes->{"RuntimeEnabled"} || $attribute->extendedAttributes->{"PerContextEnabled"}) {
+            if ($attribute->extendedAttributes->{"PerContextEnabled"}) {
+                push(@perContextEnabledAttributes, $attribute);
+            }
+            if ($attribute->extendedAttributes->{"RuntimeEnabled"}) {
+                push(@runtimeEnabledAttributes, $attribute);
+            }
+        } elsif ($attribute->extendedAttributes->{"ExposeV8GetterAndSetter"}) {
+            push(@normalAccessors, $attribute);
         } else {
             push(@normalAttributes, $attribute);
         }
     }
     AddToImplIncludes("bindings/v8/V8DOMConfiguration.h");
     # Put the attributes that disallow shadowing on the shadow object.
     if (@disallowsShadowing) {
         my $code = "";
         $code .= "static const V8DOMConfiguration::AttributeConfiguration shadowAttributes[] = {\n";
         $code .= GenerateAttributeConfigurationArray($interface, \@disallowsShadowing);
         $code .= "};\n\n";
         $implementation{nameSpaceWebCore}->add($code);
     }
 
-    my $has_attributes = 0;
+    my $hasAttributes = 0;
     if (@normalAttributes) {
-        $has_attributes = 1;
+        $hasAttributes = 1;
         my $code = "";
         $code .= "static const V8DOMConfiguration::AttributeConfiguration ${v8ClassName}Attributes[] = {\n";
         $code .= GenerateAttributeConfigurationArray($interface, \@normalAttributes);
         $code .= "};\n\n";
         $implementation{nameSpaceWebCore}->add($code);
     }
 
+    my $hasAccessors = 0;
+    if (@normalAccessors) {
+        $hasAccessors = 1;
+        my $code = "";
+        $code .= "static const V8DOMConfiguration::AccessorConfiguration ${v8ClassName}Accessors[] = {\n";
+        $code .= GenerateAttributeConfigurationArray($interface, \@normalAccessors, "accessor");
+        $code .= "};\n\n";
+        $implementation{nameSpaceWebCore}->add($code);
+    }
+
     # Setup table of standard callback functions
-    my $num_callbacks = 0;
-    my $has_callbacks = 0;
+    my $hasMethods = 0;
     $code = "";
     foreach my $function (@normalFunctions) {
         # Only one table entry is needed for overloaded methods:
         next if $function->{overloadIndex} > 1;
         # Don't put any nonstandard functions into this table:
         next if !IsStandardFunction($interface, $function);
         next if $function->name eq "";
-        if (!$has_callbacks) {
-            $has_callbacks = 1;
+        if (!$hasMethods) {
+            $hasMethods = 1;
             $code .= "static const V8DOMConfiguration::MethodConfiguration ${v8ClassName}Methods[] = {\n";
         }
         my $name = $function->name;
         my $methodForMainWorld = "0";
         if ($function->extendedAttributes->{"PerWorldBindings"}) {
             $methodForMainWorld = "${implClassName}V8Internal::${name}MethodCallbackForMainWorld";
         }
         my $functionLength = GetFunctionLength($function);
         my $conditionalString = GenerateConditionalString($function);
         $code .= "#if ${conditionalString}\n" if $conditionalString;
         $code .= <<END;
     {"$name", ${implClassName}V8Internal::${name}MethodCallback, ${methodForMainWorld}, ${functionLength}},
 END
         $code .= "#endif // ${conditionalString}\n" if $conditionalString;
-        $num_callbacks++;
     }
-    $code .= "};\n\n"  if $has_callbacks;
+    $code .= "};\n\n"  if $hasMethods;
     $implementation{nameSpaceWebCore}->add($code);
 
-    my $has_constants = 0;
+    my $hasConstants = 0;
     if (@{$interface->constants}) {
-        $has_constants = 1;
+        $hasConstants = 1;
     }
 
     if (!HasCustomConstructor($interface)) {
         if ($interface->extendedAttributes->{"NamedConstructor"}) {
             GenerateNamedConstructor(@{$interface->constructors}[0], $interface);
         } elsif ($interface->extendedAttributes->{"Constructor"}) {
             GenerateConstructor($interface);
         } elsif (IsConstructorTemplate($interface, "Event")) {
             GenerateEventConstructor($interface);
         }
     }
     if (IsConstructable($interface)) {
         GenerateConstructorCallback($interface);
     }
 
-    my $access_check = "";
+    my $accessCheck = "";
     if ($interface->extendedAttributes->{"CheckSecurity"} && $interfaceName ne "Window") {
-        $access_check = "instance->SetAccessCheckCallbacks(${implClassName}V8Internal::namedSecurityCheck, ${implClassName}V8Internal::indexedSecurityCheck, v8::External::New(const_cast<WrapperTypeInfo*>(&${v8ClassName}::wrapperTypeInfo)));";
+        $accessCheck = "instance->SetAccessCheckCallbacks(${implClassName}V8Internal::namedSecurityCheck, ${implClassName}V8Internal::indexedSecurityCheck, v8::External::New(const_cast<WrapperTypeInfo*>(&${v8ClassName}::wrapperTypeInfo)));";
     }
 
     # For the Window interface, generate the shadow object template
     # configuration method.
     if ($interfaceName eq "Window") {
         $implementation{nameSpaceWebCore}->add(<<END);
 static void ConfigureShadowObjectTemplate(v8::Handle<v8::ObjectTemplate> templ, v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     V8DOMConfiguration::installAttributes(templ, v8::Handle<v8::ObjectTemplate>(), shadowAttributes, WTF_ARRAY_LENGTH(shadowAttributes), isolate, currentWorldType);
 
     // Install a security handler with V8.
     templ->SetAccessCheckCallbacks(V8Window::namedSecurityCheckCustom, V8Window::indexedSecurityCheckCustom, v8::External::New(const_cast<WrapperTypeInfo*>(&V8Window::wrapperTypeInfo)));
     templ->SetInternalFieldCount(V8Window::internalFieldCount);
 }
 END
     }
 
     if (!$parentClassTemplate) {
         $parentClassTemplate = "v8::Local<v8::FunctionTemplate>()";
     }
 
     # Generate the template configuration method
     $code =  <<END;
 static v8::Handle<v8::FunctionTemplate> Configure${v8ClassName}Template(v8::Handle<v8::FunctionTemplate> desc, v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     desc->ReadOnlyPrototype();
 
     v8::Local<v8::Signature> defaultSignature;
 END
+
+    # Define constants, attributes, accessors and methods.
     if ($interface->extendedAttributes->{"RuntimeEnabled"}) {
         my $runtimeEnabledFunction = GetRuntimeEnabledFunctionName($interface);
         $code .= <<END;
     if (!${runtimeEnabledFunction}())
-        defaultSignature = V8DOMConfiguration::installDOMClassTemplate(desc, \"\", $parentClassTemplate, ${v8ClassName}::internalFieldCount, 0, 0, 0, 0, isolate, currentWorldType);
+        defaultSignature = V8DOMConfiguration::installDOMClassTemplate(desc, \"\", $parentClassTemplate, ${v8ClassName}::internalFieldCount, 0, 0, 0, 0, 0, 0, isolate, currentWorldType);
     else
 END
     }
-    $code .=  <<END;
-    defaultSignature = V8DOMConfiguration::installDOMClassTemplate(desc, \"${interfaceName}\", $parentClassTemplate, ${v8ClassName}::internalFieldCount,
-END
-    # Set up our attributes if we have them
-    if ($has_attributes) {
-        $code .= <<END;
-        ${v8ClassName}Attributes, WTF_ARRAY_LENGTH(${v8ClassName}Attributes),
-END
-    } else {
-        $code .= <<END;
-        0, 0,
-END
-    }
+    $code .=  "    defaultSignature = V8DOMConfiguration::installDOMClassTemplate(desc, \"${interfaceName}\", $parentClassTemplate, ${v8ClassName}::internalFieldCount, ";
 
-    if ($has_callbacks) {
-        $code .= <<END;
-        ${v8ClassName}Methods, WTF_ARRAY_LENGTH(${v8ClassName}Methods), isolate, currentWorldType);
-END
-    } else {
-        $code .= <<END;
-        0, 0, isolate, currentWorldType);
-END
-    }
+    $code .= $hasAttributes ? "${v8ClassName}Attributes, WTF_ARRAY_LENGTH(${v8ClassName}Attributes), " : "0, 0, ";
+    $code .= $hasAccessors ? "${v8ClassName}Accessors, WTF_ARRAY_LENGTH(${v8ClassName}Accessors), " : "0, 0, ";
+    $code .= $hasMethods ? "${v8ClassName}Methods, WTF_ARRAY_LENGTH(${v8ClassName}Methods), " : "0, 0, ";
+    $code .= "isolate, currentWorldType);\n";
 
     AddToImplIncludes("wtf/UnusedParam.h");
     $code .= <<END;
     UNUSED_PARAM(defaultSignature);
 END
 
     if (IsConstructable($interface)) {
         $code .= "    desc->SetCallHandler(${v8ClassName}::constructorCallback);\n";
         my $interfaceLength = GetInterfaceLength($interface);
         $code .= "    desc->SetLength(${interfaceLength});\n";
     }
 
-    if ($access_check or @runtimeEnabledAttributes or @normalFunctions or $has_constants) {
+    if ($accessCheck or @runtimeEnabledAttributes or @normalFunctions or $hasConstants) {
         $code .=  <<END;
     v8::Local<v8::ObjectTemplate> instance = desc->InstanceTemplate();
     v8::Local<v8::ObjectTemplate> proto = desc->PrototypeTemplate();
     UNUSED_PARAM(instance);
     UNUSED_PARAM(proto);
 END
     }
 
-    if ($access_check) {
-        $code .=  "    $access_check\n";
+    if ($accessCheck) {
+        $code .=  "    $accessCheck\n";
     }
 
-    # Setup the enable-at-runtime attributes if we have them
-    foreach my $runtime_attr (@runtimeEnabledAttributes) {
-        my $runtimeEnabledFunction = GetRuntimeEnabledFunctionName($runtime_attr);
-        my $conditionalString = GenerateConditionalString($runtime_attr);
-        $code .= "#if ${conditionalString}\n" if $conditionalString;
+    # Define enable-at-runtime attributes.
+    foreach my $runtimeAttribute (@runtimeEnabledAttributes) {
+        my $runtimeEnabledFunction = GetRuntimeEnabledFunctionName($runtimeAttribute);
+        my $conditionalString = GenerateConditionalString($runtimeAttribute);
+        $code .= "\n#if ${conditionalString}\n" if $conditionalString;
         $code .= "    if (${runtimeEnabledFunction}()) {\n";
         $code .= "        static const V8DOMConfiguration::AttributeConfiguration attributeConfiguration =\\\n";
-        $code .= GenerateAttributeConfiguration($interface, $runtime_attr, ";", "    ");
+        $code .= GenerateAttributeConfiguration($interface, $runtimeAttribute, ";", "    ");
         $code .= <<END;
         V8DOMConfiguration::installAttribute(instance, proto, attributeConfiguration, isolate, currentWorldType);
     }
 END
         $code .= "#endif // ${conditionalString}\n" if $conditionalString;
     }
 
     my @constantsEnabledAtRuntime;
-    if ($has_constants) {
+    if ($hasConstants) {
+        # Define constants.
         $code .= "    static const V8DOMConfiguration::ConstantConfiguration ${v8ClassName}Constants[] = {\n";
         foreach my $constant (@{$interface->constants}) {
             my $name = $constant->name;
             my $value = $constant->value;
             my $attrExt = $constant->extendedAttributes;
             my $implementedBy = $attrExt->{"ImplementedBy"};
             if ($implementedBy) {
                 my $implementedByImplName = GetImplNameFromImplementedBy($implementedBy);
                 AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedByImplName));
             }
             if ($attrExt->{"RuntimeEnabled"}) {
                 push(@constantsEnabledAtRuntime, $constant);
             } else {
                 $code .= <<END;
         {"${name}", $value},
 END
             }
         }
         $code .= "    };\n";
         $code .= <<END;
     V8DOMConfiguration::installConstants(desc, proto, ${v8ClassName}Constants, WTF_ARRAY_LENGTH(${v8ClassName}Constants), isolate);
 END
-        # Setup the enable-at-runtime constants if we have them
-        foreach my $runtime_const (@constantsEnabledAtRuntime) {
-            my $runtimeEnabledFunction = GetRuntimeEnabledFunctionName($runtime_const);
-            my $name = $runtime_const->name;
-            my $value = $runtime_const->value;
+        # Define enable-at-runtime constants.
+        foreach my $runtimeConstant (@constantsEnabledAtRuntime) {
+            my $runtimeEnabledFunction = GetRuntimeEnabledFunctionName($runtimeConstant);
+            my $name = $runtimeConstant->name;
+            my $value = $runtimeConstant->value;
             $code .= "    if (${runtimeEnabledFunction}()) {\n";
             $code .= <<END;
         static const V8DOMConfiguration::ConstantConfiguration constantConfiguration = {"${name}", static_cast<signed int>(${value})};
         V8DOMConfiguration::installConstants(desc, proto, &constantConfiguration, 1, isolate);
 END
             $code .= "    }\n";
         }
         $code .= join "", GenerateCompileTimeCheckForEnumsIfNeeded($interface);
     }
 
     $code .= GenerateImplementationIndexedPropertyAccessors($interface);
     $code .= GenerateImplementationNamedPropertyAccessors($interface);
     $code .= GenerateImplementationLegacyCall($interface);
     $code .= GenerateImplementationMasqueradesAsUndefined($interface);
 
-    # Define our functions with Set() or SetAccessor()
-    my $total_functions = 0;
+    # Define methods.
     foreach my $function (@normalFunctions) {
         # Only one accessor is needed for overloaded methods:
         next if $function->{overloadIndex} > 1;
         next if $function->name eq "";
 
-        $total_functions++;
         next if IsStandardFunction($interface, $function);
         $code .= GenerateNonStandardFunction($interface, $function);
-        $num_callbacks++;
     }
 
-    die "Wrong number of callbacks generated for $interfaceName ($num_callbacks, should be $total_functions)" if $num_callbacks != $total_functions;
-
     # Define static attributes.
     foreach my $attribute (@staticAttributes) {
         $code .= GenerateStaticAttribute($interface, $attribute);
     }
 
     # Special cases
     if ($interfaceName eq "Window") {
         $code .= <<END;
 
     proto->SetInternalFieldCount(V8Window::internalFieldCount);
@@ skipping 56 matching lines @@
 END
 
     if (@perContextEnabledAttributes) {
         my $code = "";
         $code .= <<END;
 void ${v8ClassName}::installPerContextEnabledProperties(v8::Handle<v8::Object> instance, ${nativeType}* impl, v8::Isolate* isolate)
 {
     v8::Local<v8::Object> proto = v8::Local<v8::Object>::Cast(instance->GetPrototype());
 END
 
-        # Setup the enable-by-settings attributes if we have them
+        # Define the enable-per-context attributes.
         foreach my $perContextEnabledAttribute (@perContextEnabledAttributes) {
             my $contextEnabledFunction = GetContextEnabledFunctionName($perContextEnabledAttribute);
             $code .= "    if (${contextEnabledFunction}(impl->document())) {\n";
 
             $code .= "        static const V8DOMConfiguration::AttributeConfiguration attributeConfiguration =\\\n";
             $code .= GenerateAttributeConfiguration($interface, $perContextEnabledAttribute, ";", "    ");
             $code .= <<END;
         V8DOMConfiguration::installAttribute(instance, proto, attributeConfiguration, isolate);
 END
             $code .= "    }\n";
         }
         $code .= <<END;
 }
 
 END
         $implementation{nameSpaceWebCore}->add($code);
     }
 
     if (@perContextEnabledFunctions) {
         my $code = "";
         $code .= <<END;
 void ${v8ClassName}::installPerContextEnabledPrototypeProperties(v8::Handle<v8::Object> proto, v8::Isolate* isolate)
 {
     UNUSED_PARAM(proto);
 END
-        # Setup the enable-by-settings functions if we have them
+        # Define enable-per-context methods.
         $code .=  <<END;
     v8::Local<v8::Signature> defaultSignature = v8::Signature::New(GetTemplate(isolate, worldType(isolate)));
     UNUSED_PARAM(defaultSignature);
 
     ExecutionContext* context = toExecutionContext(proto->CreationContext());
 END
 
         foreach my $runtimeFunc (@perContextEnabledFunctions) {
             my $contextEnabledFunction = GetContextEnabledFunctionName($runtimeFunc);
             my $functionLength = GetFunctionLength($runtimeFunc);
@@ skipping 1650 matching lines @@
     my $interface = shift;
 
     return 1 if $interface->extendedAttributes->{"CustomToV8"};
     return 1 if $interface->extendedAttributes->{"SpecialWrapFor"};
     return 1 if InheritsInterface($interface, "Document");
 
     return 0;
 }
 
 1;