[Binding] Remove signature from domAttribute

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 708 matching lines @@
     if (IsConstructable($interface)) {
         $header{classPublic}->add("    static void constructorCallback(const v8::FunctionCallbackInfo<v8::Value>&);\n");
 END
     }
     if (HasCustomConstructor($interface)) {
         $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);
+        my $name = $attribute->name;
+        my $attrExt = $attribute->extendedAttributes;
+        my $conditionalString = GenerateConditionalString($attribute);
         if (HasCustomGetter($attrExt) && !$attrExt->{"ImplementedBy"}) {
             $header{classPublic}->add("#if ${conditionalString}\n") if $conditionalString;
             $header{classPublic}->add(<<END);
     static void ${name}AttrGetterCustom(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>&);
 END
             $header{classPublic}->add("#endif // ${conditionalString}\n") if $conditionalString;
         }
         if (HasCustomSetter($attrExt) && !$attrExt->{"ImplementedBy"}) {
             $header{classPublic}->add("#if ${conditionalString}\n") if $conditionalString;
             $header{classPublic}->add(<<END);
@@ skipping 354 matching lines @@
 
 sub HasCustomMethod
 {
     my $attrExt = shift;
     return $attrExt->{"Custom"};
 }
 
 sub IsReadonly
 {
     my $attribute = shift;
-    my $attrExt = $attribute->signature->extendedAttributes;
+    my $attrExt = $attribute->extendedAttributes;
     return $attribute->isReadOnly && !$attrExt->{"Replaceable"};
 }
 
 sub GetV8ClassName
 {
     my $interface = shift;
     return "V8" . $interface->name;
 }
 
 sub GetImplName
@@ skipping 180 matching lines @@
 }
 
 sub GenerateNormalAttrGetterCallback
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
-    my $attrExt = $attribute->signature->extendedAttributes;
-    my $attrName = $attribute->signature->name;
+    my $attrExt = $attribute->extendedAttributes;
+    my $attrName = $attribute->name;
 
-    my $conditionalString = GenerateConditionalString($attribute->signature);
+    my $conditionalString = GenerateConditionalString($attribute);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
 
     $code .= "static void ${attrName}AttrGetterCallback${forMainWorldSuffix}(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)\n";
     $code .= "{\n";
     $code .= GenerateFeatureObservation($attrExt->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($attrExt->{"DeprecateAs"});
     if (HasActivityLogging($forMainWorldSuffix, $attrExt, "Getter")) {
         $code .= GenerateActivityLogging("Getter", $interface, "${attrName}");
     }
@@ skipping 10 matching lines @@
 
 sub GenerateNormalAttrGetter
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
-    my $attrExt = $attribute->signature->extendedAttributes;
-    my $attrName = $attribute->signature->name;
-    my $attrType = $attribute->signature->type;
+    my $attrExt = $attribute->extendedAttributes;
+    my $attrName = $attribute->name;
+    my $attrType = $attribute->type;
 
     if (HasCustomGetter($attrExt)) {
         return;
     }
 
     AssertNotSequenceType($attrType);
     my $getterStringUsesImp = $interfaceName ne "SVGNumber";
-    my $nativeType = GetNativeTypeFromSignature($attribute->signature, -1);
+    my $nativeType = GetNativeTypeFromSignature($attribute, -1);
     my $svgNativeType = GetSVGTypeNeedingTearOff($interfaceName);
 
-    my $conditionalString = GenerateConditionalString($attribute->signature);
+    my $conditionalString = GenerateConditionalString($attribute);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
     $code .= <<END;
 static void ${attrName}AttrGetter${forMainWorldSuffix}(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
 {
 END
     if ($svgNativeType) {
         my $svgWrappedNativeType = GetSVGWrappedTypeNeedingTearOff($interfaceName);
         if ($svgWrappedNativeType =~ /List/) {
             $code .= <<END;
@@ skipping 20 matching lines @@
             $code .= <<END;
     v8::Handle<v8::Object> holder = info.This()->FindInstanceInPrototypeChain(${v8ClassName}::GetTemplate(info.GetIsolate(), worldType(info.GetIsolate())));
     if (holder.IsEmpty())
         return;
 END
         }
         $code .= <<END;
     ${implClassName}* imp = ${v8ClassName}::toNative(holder);
 END
     } else {
-        my $reflect = $attribute->signature->extendedAttributes->{"Reflect"};
-        my $url = $attribute->signature->extendedAttributes->{"URL"};
+        my $reflect = $attribute->extendedAttributes->{"Reflect"};
+        my $url = $attribute->extendedAttributes->{"URL"};
         if ($getterStringUsesImp && $reflect && !$url && InheritsInterface($interface, "Node") && $attrType eq "DOMString") {
             # Generate super-compact call for regular attribute getter:
             my ($functionName, @arguments) = GetterExpression($interfaceName, $attribute);
             $code .= "    Element* imp = V8Element::toNative(info.Holder());\n";
             $code .= "    v8SetReturnValue(info, v8String(imp->${functionName}(" . join(", ", @arguments) . "), info.GetIsolate(), ReturnUnsafeHandle));\n";
             $code .= "    return;\n";
             $code .= "}\n\n";
             $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
             $implementation{nameSpaceInternal}->add($code);
             return;
             # Skip the rest of the function!
         }
-        if ($attribute->signature->type eq "SerializedScriptValue" && $attrExt->{"CachedAttribute"}) {
+        if ($attribute->type eq "SerializedScriptValue" && $attrExt->{"CachedAttribute"}) {
             $code .= <<END;
     v8::Handle<v8::String> propertyName = v8::String::NewSymbol("${attrName}");
     v8::Handle<v8::Value> value = info.Holder()->GetHiddenValue(propertyName);
     if (!value.IsEmpty()) {
         v8SetReturnValue(info, value);
         return;
     }
 END
         }
         if (!$attribute->isStatic) {
             $code .= <<END;
     ${implClassName}* imp = ${v8ClassName}::toNative(info.Holder());
 END
         }
     }
 
     # Generate security checks if necessary
-    if ($attribute->signature->extendedAttributes->{"CheckSecurityForNode"}) {
+    if ($attribute->extendedAttributes->{"CheckSecurityForNode"}) {
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
-        $code .= "    if (!BindingSecurity::shouldAllowAccessToNode(imp->" . GetImplName($attribute->signature) . "())) {\n";
+        $code .= "    if (!BindingSecurity::shouldAllowAccessToNode(imp->" . GetImplName($attribute) . "())) {\n";
         $code .= "        v8SetReturnValueNull(info);\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
 
-    my $useExceptions = 1 if $attribute->signature->extendedAttributes->{"GetterRaisesException"} ||  $attribute->signature->extendedAttributes->{"RaisesException"};
-    my $isNullable = $attribute->signature->isNullable;
+    my $useExceptions = 1 if $attribute->extendedAttributes->{"GetterRaisesException"} ||  $attribute->extendedAttributes->{"RaisesException"};
+    my $isNullable = $attribute->isNullable;
     if ($useExceptions) {
         AddToImplIncludes("core/dom/ExceptionCode.h");
         $code .= "    ExceptionCode ec = 0;\n";
     }
 
     if ($isNullable) {
         $code .= "    bool isNull = false;\n";
     }
 
-    my $returnType = $attribute->signature->type;
+    my $returnType = $attribute->type;
     my $getterString;
 
     if ($getterStringUsesImp) {
         my ($functionName, @arguments) = GetterExpression($interfaceName, $attribute);
         push(@arguments, "isNull") if $isNullable;
         push(@arguments, "ec") if $useExceptions;
-        if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
-            my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
+        if ($attribute->extendedAttributes->{"ImplementedBy"}) {
+            my $implementedBy = $attribute->extendedAttributes->{"ImplementedBy"};
             my $implementedByImplName = GetImplNameFromImplementedBy($implementedBy);
             AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedByImplName));
             unshift(@arguments, "imp") if !$attribute->isStatic;
             $functionName = "${implementedByImplName}::${functionName}";
         } elsif ($attribute->isStatic) {
             $functionName = "${implClassName}::${functionName}";
         } else {
             $functionName = "imp->${functionName}";
         }
-        my ($arg, $subCode) = GenerateCallWith($attribute->signature->extendedAttributes->{"CallWith"}, "    ", 0);
+        my ($arg, $subCode) = GenerateCallWith($attribute->extendedAttributes->{"CallWith"}, "    ", 0);
         $code .= $subCode;
         unshift(@arguments, @$arg);
         $getterString = "${functionName}(" . join(", ", @arguments) . ")";
     } else {
         $getterString = "impInstance";
     }
 
     my $expression;
-    if ($attribute->signature->type eq "EventListener" && $interface->name eq "Window") {
+    if ($attribute->type eq "EventListener" && $interface->name eq "Window") {
         $code .= "    if (!imp->document())\n";
         $code .= "        return;\n";
     }
 
     if ($useExceptions || $isNullable) {
         if ($nativeType =~ /^V8StringResource/) {
-            $code .= "    " . ConvertToV8StringResource($attribute->signature, $nativeType, "v", $getterString) . ";\n";
+            $code .= "    " . ConvertToV8StringResource($attribute, $nativeType, "v", $getterString) . ";\n";
         } else {
             $code .= "    $nativeType v = $getterString;\n";
         }
 
         if ($isNullable) {
             $code .= "    if (isNull) {\n";
             $code .= "        v8SetReturnValueNull(info);\n";
             $code .= "        return;\n";
             $code .= "    }\n";
         }
 
         if ($useExceptions) {
             $code .= "    if (UNLIKELY(ec)) {\n";
             $code .= "        setDOMException(ec, info.GetIsolate());\n";
             $code .= "        return;\n";
             $code .= "    };\n";
 
-            if (ExtendedAttributeContains($attribute->signature->extendedAttributes->{"CallWith"}, "ScriptState")) {
+            if (ExtendedAttributeContains($attribute->extendedAttributes->{"CallWith"}, "ScriptState")) {
                 $code .= "    if (state.hadException()) {\n";
                 $code .= "        throwError(state.exception(), info.GetIsolate());\n";
                 $code .= "        return;\n";
                 $code .= "    }\n";
             }
         }
 
         $expression = "v";
         $expression .= ".release()" if (IsRefPtrType($returnType));
     } else {
@@ skipping 42 matching lines @@
         AddToImplIncludes("V8$attrType.h");
         my $svgNativeType = GetSVGTypeNeedingTearOff($attrType);
         # Convert from abstract SVGProperty to real type, so the right toJS() method can be invoked.
         $code .= "    v8SetReturnValue(info, toV8Fast$forMainWorldSuffix(static_cast<$svgNativeType*>($expression), info, imp));\n";
         $code .= "    return;\n";
     } elsif (IsSVGTypeNeedingTearOff($attrType) and not $interfaceName =~ /List$/) {
         AddToImplIncludes("V8$attrType.h");
         AddToImplIncludes("core/svg/properties/SVGPropertyTearOff.h");
         my $tearOffType = GetSVGTypeNeedingTearOff($attrType);
         my $wrappedValue;
-        if (IsSVGTypeWithWritablePropertiesNeedingTearOff($attrType) and not defined $attribute->signature->extendedAttributes->{"Immutable"}) {
+        if (IsSVGTypeWithWritablePropertiesNeedingTearOff($attrType) and not defined $attribute->extendedAttributes->{"Immutable"}) {
             my $getter = $expression;
             $getter =~ s/imp->//;
             $getter =~ s/\(\)//;
 
             my $updateMethod = "&${implClassName}::update" . FirstLetterToUpperCase($getter);
 
             my $selfIsTearOffType = IsSVGTypeNeedingTearOff($interfaceName);
             if ($selfIsTearOffType) {
                 AddToImplIncludes("core/svg/properties/SVGStaticPropertyWithParentTearOff.h");
                 $tearOffType =~ s/SVGPropertyTearOff</SVGStaticPropertyWithParentTearOff<$implClassName, /;
@@ skipping 13 matching lines @@
             }
         } elsif ($tearOffType =~ /SVGStaticListPropertyTearOff/) {
                 $wrappedValue = "WTF::getPtr(${tearOffType}::create(imp, $expression))";
         } elsif ($tearOffType =~ /SVG(Point|PathSeg)List/) {
                 $wrappedValue = "WTF::getPtr($expression)";
         } else {
                 $wrappedValue = "WTF::getPtr(${tearOffType}::create($expression))";
         }
         $code .= "    v8SetReturnValue(info, toV8Fast$forMainWorldSuffix($wrappedValue, info, imp));\n";
         $code .= "    return;\n";
-    } elsif ($attribute->signature->type eq "SerializedScriptValue" && $attrExt->{"CachedAttribute"}) {
-        my $getterFunc = ToMethodName($attribute->signature->name);
+    } elsif ($attribute->type eq "SerializedScriptValue" && $attrExt->{"CachedAttribute"}) {
+        my $getterFunc = ToMethodName($attribute->name);
         $code .= <<END;
     RefPtr<SerializedScriptValue> serialized = imp->${getterFunc}();
     value = serialized ? serialized->deserialize() : v8::Handle<v8::Value>(v8Null(info.GetIsolate()));
     info.Holder()->SetHiddenValue(propertyName, value);
     v8SetReturnValue(info, value);
     return;
 END
-    } elsif ($attribute->signature->type eq "EventListener") {
+    } elsif ($attribute->type eq "EventListener") {
         AddToImplIncludes("bindings/v8/V8AbstractEventListener.h");
-        my $getterFunc = ToMethodName($attribute->signature->name);
+        my $getterFunc = ToMethodName($attribute->name);
         # FIXME: Pass the main world ID for main-world-only getters.
         $code .= "    EventListener* listener = imp->${getterFunc}(isolatedWorldForIsolate(info.GetIsolate()));\n";
         $code .= "    v8SetReturnValue(info, listener ? v8::Handle<v8::Value>(V8AbstractEventListener::cast(listener)->getListenerObject(imp->scriptExecutionContext())) : v8::Handle<v8::Value>(v8Null(info.GetIsolate())));\n";
         $code .= "    return;\n";
     } else {
-        my $nativeValue = NativeToJSValue($attribute->signature->type, $attribute->signature->extendedAttributes, $expression, "    ", "", "info.Holder()", "info.GetIsolate()", "info", "imp", "ReturnUnsafeHandle", $forMainWorldSuffix, "return");
+        my $nativeValue = NativeToJSValue($attribute->type, $attribute->extendedAttributes, $expression, "    ", "", "info.Holder()", "info.GetIsolate()", "info", "imp", "ReturnUnsafeHandle", $forMainWorldSuffix, "return");
         $code .= "${nativeValue}\n";
         $code .= "    return;\n";
     }
 
     $code .= "}\n\n";  # end of getter
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub ShouldKeepAttributeAlive
 {
     my ($interface, $attribute, $returnType) = @_;
-    my $attrName = $attribute->signature->name;
+    my $attrName = $attribute->name;
 
-    return 1 if $attribute->signature->extendedAttributes->{"KeepAttributeAliveForGC"};
+    return 1 if $attribute->extendedAttributes->{"KeepAttributeAliveForGC"};
 
     # Basically, for readonly or replaceable attributes, we have to guarantee
     # that JS wrappers don't get garbage-collected prematually when their
     # lifetime is strongly tied to their owner.
     return 0 if !IsWrapperType($returnType);
-    return 0 if !IsReadonly($attribute) && !$attribute->signature->extendedAttributes->{"Replaceable"};
+    return 0 if !IsReadonly($attribute) && !$attribute->extendedAttributes->{"Replaceable"};
 
     # However, there are a couple of exceptions.
 
     # Node lifetime is managed by object grouping.
     return 0 if InheritsInterface($interface, "Node");
     return 0 if IsDOMNodeType($returnType);
 
     # To avoid adding a reference to itself.
     # FIXME: Introduce [DoNotKeepAttributeAliveForGC] and remove this hack
     # depending on the attribute name.
@@ skipping 76 matching lines @@
 }
 
 sub GenerateNormalAttrSetterCallback
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
-    my $attrExt = $attribute->signature->extendedAttributes;
-    my $attrName = $attribute->signature->name;
+    my $attrExt = $attribute->extendedAttributes;
+    my $attrName = $attribute->name;
 
-    my $conditionalString = GenerateConditionalString($attribute->signature);
+    my $conditionalString = GenerateConditionalString($attribute);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
 
     $code .= "static void ${attrName}AttrSetterCallback${forMainWorldSuffix}(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)\n";
     $code .= "{\n";
     $code .= GenerateFeatureObservation($attrExt->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($attrExt->{"DeprecateAs"});
     if (HasActivityLogging($forMainWorldSuffix, $attrExt, "Setter")) {
         $code .= GenerateActivityLogging("Setter", $interface, "${attrName}");
     }
     if (HasCustomSetter($attrExt)) {
         $code .= "    ${v8ClassName}::${attrName}AttrSetterCustom(name, value, info);\n";
     } else {
         $code .= "    ${implClassName}V8Internal::${attrName}AttrSetter${forMainWorldSuffix}(name, value, info);\n";
     }
     $code .= "}\n\n";
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateNormalAttrSetter
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
-    my $attrName = $attribute->signature->name;
-    my $attrExt = $attribute->signature->extendedAttributes;
-    my $attrType = $attribute->signature->type;
+    my $attrName = $attribute->name;
+    my $attrExt = $attribute->extendedAttributes;
+    my $attrType = $attribute->type;
 
     if (HasCustomSetter($attrExt)) {
         return;
     }
 
-    my $conditionalString = GenerateConditionalString($attribute->signature);
+    my $conditionalString = GenerateConditionalString($attribute);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
     $code .= "static void ${attrName}AttrSetter${forMainWorldSuffix}(v8::Local<v8::String> name, v8::Local<v8::Value> value, 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->signature->extendedAttributes->{"StrictTypeChecking"}) {
-        my $argType = $attribute->signature->type;
+    if ($attribute->extendedAttributes->{"StrictTypeChecking"}) {
+        my $argType = $attribute->type;
         if (IsWrapperType($argType)) {
             $code .= "    if (!isUndefinedOrNull(value) && !V8${argType}::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate()))) {\n";
             $code .= "        throwTypeError(0, info.GetIsolate());\n";
             $code .= "        return;\n";
             $code .= "    }\n";
         }
     }
 
     my $svgNativeType = GetSVGTypeNeedingTearOff($interfaceName);
     if ($svgNativeType) {
@@ skipping 10 matching lines @@
             $code .= "        return;\n";
             $code .= "    }\n";
             $code .= "    $svgWrappedNativeType& impInstance = wrapper->propertyReference();\n";
             $code .= "    $svgWrappedNativeType* imp = &impInstance;\n";
         }
     } elsif ($attrExt->{"OnProto"}) {
         $code .= <<END;
     ${implClassName}* imp = ${v8ClassName}::toNative(info.Holder());
 END
     } else {
-        my $reflect = $attribute->signature->extendedAttributes->{"Reflect"};
+        my $reflect = $attribute->extendedAttributes->{"Reflect"};
         if ($reflect && InheritsInterface($interface, "Node") && $attrType eq "DOMString") {
             # Generate super-compact call for regular attribute setter:
             my $contentAttributeName = $reflect eq "VALUE_IS_MISSING" ? lc $attrName : $reflect;
             my $namespace = NamespaceForAttributeName($interfaceName, $contentAttributeName);
             AddToImplIncludes("${namespace}.h");
             $code .= "    Element* imp = V8Element::toNative(info.Holder());\n";
             $code .= "    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, stringResource, value);\n";
             $code .= "    imp->setAttribute(${namespace}::${contentAttributeName}Attr, stringResource);\n";
             $code .= "}\n\n";
             $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
             $implementation{nameSpaceInternal}->add($code);
             return;
             # Skip the rest of the function!
         }
 
         if (!$attribute->isStatic) {
             $code .= <<END;
     ${implClassName}* imp = ${v8ClassName}::toNative(info.Holder());
 END
         }
     }
 
-    my $nativeType = GetNativeTypeFromSignature($attribute->signature, 0);
-    if ($attribute->signature->type eq "EventListener") {
+    my $nativeType = GetNativeTypeFromSignature($attribute, 0);
+    if ($attribute->type eq "EventListener") {
         if ($interface->name eq "Window") {
             $code .= "    if (!imp->document())\n";
             $code .= "        return;\n";
         }
     } else {
-        my $value = JSValueToNative($attribute->signature->type, $attribute->signature->extendedAttributes, "value", "info.GetIsolate()");
+        my $value = JSValueToNative($attribute->type, $attribute->extendedAttributes, "value", "info.GetIsolate()");
         my $arrayType = GetArrayType($nativeType);
 
         if ($nativeType =~ /^V8StringResource/) {
-            $code .= "    " . ConvertToV8StringResource($attribute->signature, $nativeType, "v", $value) . "\n";
+            $code .= "    " . ConvertToV8StringResource($attribute, $nativeType, "v", $value) . "\n";
         } elsif ($arrayType) {
             $code .= "    Vector<$arrayType> v = $value;\n";
-        } elsif ($attribute->signature->extendedAttributes->{"EnforceRange"}) {
+        } elsif ($attribute->extendedAttributes->{"EnforceRange"}) {
             $code .= "    V8TRYCATCH_WITH_TYPECHECK_VOID($nativeType, v, $value, info.GetIsolate());\n";
         } else {
             $code .= "    V8TRYCATCH_VOID($nativeType, v, $value);\n";
         }
     }
 
     if (IsEnumType($attrType)) {
         # setter ignores invalid enumeration values
         my @enumValues = ValidEnumValues($attrType);
         my @validEqualities = ();
         foreach my $enumValue (@enumValues) {
             push(@validEqualities, "string == \"$enumValue\"");
         }
         my $enumValidationExpression = join(" || ", @validEqualities);
         $code .= <<END;
     String string = v;
     if (!($enumValidationExpression))
         return;
 END
     }
 
     my $expression = "v";
-    my $returnType = $attribute->signature->type;
+    my $returnType = $attribute->type;
     if (IsRefPtrType($returnType) && !GetArrayType($returnType)) {
         $expression = "WTF::getPtr(" . $expression . ")";
     }
 
-    $code .= GenerateCustomElementInvocationScopeIfNeeded($attribute->signature->extendedAttributes);
+    $code .= GenerateCustomElementInvocationScopeIfNeeded($attribute->extendedAttributes);
 
-    my $useExceptions = 1 if $attribute->signature->extendedAttributes->{"SetterRaisesException"} ||  $attribute->signature->extendedAttributes->{"RaisesException"};
+    my $useExceptions = 1 if $attribute->extendedAttributes->{"SetterRaisesException"} ||  $attribute->extendedAttributes->{"RaisesException"};
 
     if ($useExceptions) {
         AddToImplIncludes("core/dom/ExceptionCode.h");
         $code .= "    ExceptionCode ec = 0;\n";
     }
 
     if ($interfaceName eq "SVGNumber") {
         $code .= "    *imp = $expression;\n";
     } else {
-        if ($attribute->signature->type eq "EventListener") {
+        if ($attribute->type eq "EventListener") {
             my $implSetterFunctionName = FirstLetterToUpperCase($attrName);
             AddToImplIncludes("bindings/v8/V8AbstractEventListener.h");
             if (!InheritsInterface($interface, "Node")) {
-                my $attrImplName = GetImplName($attribute->signature);
+                my $attrImplName = GetImplName($attribute);
                 $code .= "    transferHiddenDependency(info.Holder(), imp->${attrImplName}(isolatedWorldForIsolate(info.GetIsolate())), value, ${v8ClassName}::eventListenerCacheIndex, info.GetIsolate());\n";
             }
             AddToImplIncludes("bindings/v8/V8EventListenerList.h");
-            if (($interfaceName eq "Window" or $interfaceName eq "WorkerContext") and $attribute->signature->name eq "onerror") {
+            if (($interfaceName eq "Window" or $interfaceName eq "WorkerContext") and $attribute->name eq "onerror") {
                 AddToImplIncludes("bindings/v8/V8ErrorHandler.h");
                 $code .= "    imp->set$implSetterFunctionName(V8EventListenerList::findOrCreateWrapper<V8ErrorHandler>(value, true), isolatedWorldForIsolate(info.GetIsolate()));\n";
             } else {
                 $code .= "    imp->set$implSetterFunctionName(V8EventListenerList::getEventListener(value, true, ListenerFindOrCreate), isolatedWorldForIsolate(info.GetIsolate()));\n";
             }
         } else {
             my ($functionName, @arguments) = SetterExpression($interfaceName, $attribute);
             push(@arguments, $expression);
             push(@arguments, "ec") if $useExceptions;
-            if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
-                my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
+            if ($attribute->extendedAttributes->{"ImplementedBy"}) {
+                my $implementedBy = $attribute->extendedAttributes->{"ImplementedBy"};
                 my $implementedByImplName = GetImplNameFromImplementedBy($implementedBy);
                 AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedByImplName));
                 unshift(@arguments, "imp") if !$attribute->isStatic;
                 $functionName = "${implementedByImplName}::${functionName}";
             } elsif ($attribute->isStatic) {
                 $functionName = "${implClassName}::${functionName}";
             } else {
                 $functionName = "imp->${functionName}";
             }
-            my ($arg, $subCode) = GenerateCallWith($attribute->signature->extendedAttributes->{"SetterCallWith"} || $attribute->signature->extendedAttributes->{"CallWith"}, "    ", 1);
+            my ($arg, $subCode) = GenerateCallWith($attribute->extendedAttributes->{"SetterCallWith"} || $attribute->extendedAttributes->{"CallWith"}, "    ", 1);
             $code .= $subCode;
             unshift(@arguments, @$arg);
             $code .= "    ${functionName}(" . join(", ", @arguments) . ");\n";
         }
     }
 
     if ($useExceptions) {
         $code .= "    if (UNLIKELY(ec))\n";
         $code .= "        setDOMException(ec, info.GetIsolate());\n";
     }
 
-    if (ExtendedAttributeContains($attribute->signature->extendedAttributes->{"CallWith"}, "ScriptState")) {
+    if (ExtendedAttributeContains($attribute->extendedAttributes->{"CallWith"}, "ScriptState")) {
         $code .= "    if (state.hadException())\n";
         $code .= "        throwError(state.exception(), info.GetIsolate());\n";
     }
 
     if ($svgNativeType) {
         if ($useExceptions) {
             $code .= "    if (!ec)\n";
             $code .= "        wrapper->commitChange();\n";
         } else {
             $code .= "    wrapper->commitChange();\n";
         }
     }
 
-    if ($attribute->signature->type eq "SerializedScriptValue" && $attribute->signature->extendedAttributes->{"CachedAttribute"}) {
+    if ($attribute->type eq "SerializedScriptValue" && $attribute->extendedAttributes->{"CachedAttribute"}) {
         $code .= <<END;
     info.Holder()->DeleteHiddenValue(v8::String::NewSymbol("${attrName}")); // Invalidate the cached value.
 END
     }
 
     $code .= "    return;\n";
     $code .= "}\n\n";  # end of setter
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
 }
@@ skipping 738 matching lines @@
     foreach my $interfaceBase (@{$interface->parents}) {
         $code .= <<END;
     if (!fill${interfaceBase}Init(eventInit, options))
         return false;
 
 END
     }
 
     for (my $index = 0; $index < @{$interface->attributes}; $index++) {
         my $attribute = @{$interface->attributes}[$index];
-        if ($attribute->signature->extendedAttributes->{"InitializedByEventConstructor"}) {
-            my $attributeName = $attribute->signature->name;
+        if ($attribute->extendedAttributes->{"InitializedByEventConstructor"}) {
+            my $attributeName = $attribute->name;
             $code .= "    options.get(\"$attributeName\", eventInit.$attributeName);\n";
         }
     }
 
     $code .= <<END;
     return true;
 }
 
 END
     $implementation{nameSpaceWebCore}->add($code);
@@ skipping 166 matching lines @@
     return $content;
 }
 
 sub GenerateBatchedAttributeData
 {
     my $interface = shift;
     my $attributes = shift;
     my $code = "";
 
     foreach my $attribute (@$attributes) {
-        my $conditionalString = GenerateConditionalString($attribute->signature);
+        my $conditionalString = GenerateConditionalString($attribute);
         my $subCode = "";
         $subCode .= "#if ${conditionalString}\n" if $conditionalString;
         $subCode .= GenerateSingleBatchedAttribute($interface, $attribute, ",", "");
         $subCode .= "#endif // ${conditionalString}\n" if $conditionalString;
         $code .= $subCode;
     }
     return $code;
 }
 
 sub GenerateSingleBatchedAttribute
 {
     my $interface = shift;
     my $attribute = shift;
     my $delimiter = shift;
     my $indent = shift;
     my $code = "";
-    my $attrName = $attribute->signature->name;
-    my $attrExt = $attribute->signature->extendedAttributes;
+    my $attrName = $attribute->name;
+    my $attrExt = $attribute->extendedAttributes;
     my $implClassName = GetImplName($interface);
 
     my $accessControl = "v8::DEFAULT";
     if ($attrExt->{"DoNotCheckSecurityOnGetter"}) {
         $accessControl = "v8::ALL_CAN_READ";
     } elsif ($attrExt->{"DoNotCheckSecurityOnSetter"}) {
         $accessControl = "v8::ALL_CAN_WRITE";
     } elsif ($attrExt->{"DoNotCheckSecurity"}) {
         $accessControl = "v8::ALL_CAN_READ";
         if (!IsReadonly($attribute)) {
@@ skipping 10 matching lines @@
         # use the naming convension, interface + (capitalize) attr name
         $customAccessor = $implClassName . "::" . $attrName;
     }
 
     my $getter;
     my $setter;
     my $getterForMainWorld;
     my $setterForMainWorld;
     my $propAttr = "v8::None";
 
-    my $isConstructor = ($attribute->signature->type =~ /Constructor$/);
+    my $isConstructor = ($attribute->type =~ /Constructor$/);
 
     # Check attributes.
     # As per Web IDL specification, constructor properties on the ECMAScript global object should be
     # configurable and should not be enumerable.
     if ($attrExt->{"NotEnumerable"} || $isConstructor) {
         $propAttr .= " | v8::DontEnum";
     }
     if ($attrExt->{"Unforgeable"} && !$isConstructor) {
         $propAttr .= " | v8::DontDelete";
     }
 
     my $on_proto = "0 /* on instance */";
     my $data = "0 /* no data */";
 
     # Constructor
     if ($isConstructor) {
-        my $constructorType = $attribute->signature->type;
+        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->signature->extendedAttributes->{"CustomConstructor"}) {
+        if ($constructorType !~ /Constructor$/ || $attribute->extendedAttributes->{"CustomConstructor"}) {
             AddToImplIncludes("V8${constructorType}.h");
         }
         $data = "&V8${constructorType}::info";
         $getter = "${implClassName}V8Internal::${implClassName}ConstructorGetter";
         $setter = "${implClassName}V8Internal::${implClassName}ReplaceableAttrSetterCallback";
         $getterForMainWorld = "0";
         $setterForMainWorld = "0";
     } else {
         # Default Getter and Setter
         $getter = "${implClassName}V8Internal::${attrName}AttrGetterCallback";
@@ skipping 16 matching lines @@
     # An accessor can be installed on the proto
     if ($attrExt->{"OnProto"}) {
         $on_proto = "1 /* on proto */";
     }
 
     if (!$attrExt->{"PerWorldBindings"}) {
       $getterForMainWorld = "0";
       $setterForMainWorld = "0";
     }
 
-    my $commentInfo = "Attribute '$attrName' (Type: '" . $attribute->type .
-                      "' ExtAttr: '" . join(' ', keys(%{$attrExt})) . "')";
+    my $commentInfo = "Attribute '$attrName'";
 
     $code .= $indent . "    \/\/ $commentInfo\n";
     $code .= $indent . "    {\"$attrName\", $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, static_cast<v8::PropertyAttribute>($propAttr), $on_proto}" . $delimiter . "\n";
     return $code;
 }
 
 sub IsStandardFunction
 {
     my $interface = shift;
     my $function = shift;
@@ skipping 730 matching lines @@
     $implementation{nameSpaceWebCore}->addHeader($code);
 
     $implementation{nameSpaceInternal}->add("template <typename T> void V8_USE(T) { }\n\n");
 
     my $hasConstructors = 0;
     my $hasReplaceable = 0;
 
     # Generate property accessors for attributes.
     for (my $index = 0; $index < @{$interface->attributes}; $index++) {
         my $attribute = @{$interface->attributes}[$index];
-        my $attrType = $attribute->signature->type;
-        my $attrExt = $attribute->signature->extendedAttributes;
+        my $attrType = $attribute->type;
+        my $attrExt = $attribute->extendedAttributes;
 
         # Generate special code for the constructor attributes.
         if ($attrType =~ /Constructor$/) {
             if (!HasCustomGetter($attrExt)) {
                 $hasConstructors = 1;
             }
             next;
         }
 
         if ($attrType eq "EventListener" && $interfaceName eq "Window") {
@@ skipping 106 matching lines @@
 
     # 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 @enabledAtRuntimeAttributes;
     my @enabledPerContextAttributes;
     my @normalAttributes;
     foreach my $attribute (@$attributes) {
 
-        if ($interfaceName eq "Window" && $attribute->signature->extendedAttributes->{"Unforgeable"}) {
+        if ($interfaceName eq "Window" && $attribute->extendedAttributes->{"Unforgeable"}) {
             push(@disallowsShadowing, $attribute);
-        } elsif ($attribute->signature->extendedAttributes->{"EnabledAtRuntime"} || $attribute->signature->extendedAttributes->{"EnabledPerContext"}) {
-            if ($attribute->signature->extendedAttributes->{"EnabledPerContext"}) {
+        } elsif ($attribute->extendedAttributes->{"EnabledAtRuntime"} || $attribute->extendedAttributes->{"EnabledPerContext"}) {
+            if ($attribute->extendedAttributes->{"EnabledPerContext"}) {
                 push(@enabledPerContextAttributes, $attribute);
             }
-            if ($attribute->signature->extendedAttributes->{"EnabledAtRuntime"}) {
+            if ($attribute->extendedAttributes->{"EnabledAtRuntime"}) {
                 push(@enabledAtRuntimeAttributes, $attribute);
             }
         } else {
             push(@normalAttributes, $attribute);
         }
     }
     AddToImplIncludes("bindings/v8/V8DOMConfiguration.h");
     $attributes = \@normalAttributes;
     # Put the attributes that disallow shadowing on the shadow object.
     if (@disallowsShadowing) {
@@ skipping 183 matching lines @@
 END
     }
 
     if ($access_check) {
         $code .=  "    $access_check\n";
     }
 
     # Setup the enable-at-runtime attrs if we have them
     foreach my $runtime_attr (@enabledAtRuntimeAttributes) {
         next if grep { $_ eq $runtime_attr } @enabledPerContextAttributes;
-        my $enable_function = GetRuntimeEnableFunctionName($runtime_attr->signature);
-        my $conditionalString = GenerateConditionalString($runtime_attr->signature);
+        my $enable_function = GetRuntimeEnableFunctionName($runtime_attr);
+        my $conditionalString = GenerateConditionalString($runtime_attr);
         $code .= "\n#if ${conditionalString}\n" if $conditionalString;
         $code .= "    if (${enable_function}()) {\n";
         $code .= "        static const V8DOMConfiguration::BatchedAttribute attrData =\\\n";
         $code .= GenerateSingleBatchedAttribute($interface, $runtime_attr, ";", "    ");
         $code .= <<END;
         V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate, currentWorldType);
     }
 END
         $code .= "\n#endif // ${conditionalString}\n" if $conditionalString;
     }
@@ skipping 105 matching lines @@
     if (@enabledPerContextAttributes) {
         my $code = "";
         $code .= <<END;
 void ${v8ClassName}::installPerContextProperties(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 attrs if we have them
         foreach my $runtimeAttr (@enabledPerContextAttributes) {
-            my $enableFunction = GetContextEnableFunction($runtimeAttr->signature);
-            my $conditionalString = GenerateConditionalString($runtimeAttr->signature);
+            my $enableFunction = GetContextEnableFunction($runtimeAttr);
+            my $conditionalString = GenerateConditionalString($runtimeAttr);
             $code .= "\n#if ${conditionalString}\n" if $conditionalString;
             if (grep { $_ eq $runtimeAttr } @enabledAtRuntimeAttributes) {
-                my $runtimeEnableFunction = GetRuntimeEnableFunctionName($runtimeAttr->signature);
+                my $runtimeEnableFunction = GetRuntimeEnableFunctionName($runtimeAttr);
                 $code .= "    if (${enableFunction}(impl->document()) && ${runtimeEnableFunction}()) {\n";
             } else {
                 $code .= "    if (${enableFunction}(impl->document())) {\n";
             }
 
             $code .= "        static const V8DOMConfiguration::BatchedAttribute attrData =\\\n";
             $code .= GenerateSingleBatchedAttribute($interface, $runtimeAttr, ";", "    ");
             $code .= <<END;
         V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate);
 END
@@ skipping 1425 matching lines @@
         push(@{$nameToFunctionsMap{$name}}, $function);
         $function->{overloads} = $nameToFunctionsMap{$name};
         $function->{overloadIndex} = @{$nameToFunctionsMap{$name}};
     }
 }
 
 sub AttributeNameForGetterAndSetter
 {
     my $attribute = shift;
 
-    my $attributeName = GetImplName($attribute->signature);
-    if ($attribute->signature->extendedAttributes->{"ImplementedAs"}) {
-        $attributeName = $attribute->signature->extendedAttributes->{"ImplementedAs"};
+    my $attributeName = GetImplName($attribute);
+    if ($attribute->extendedAttributes->{"ImplementedAs"}) {
+        $attributeName = $attribute->extendedAttributes->{"ImplementedAs"};
     }
-    my $attributeType = $attribute->signature->type;
+    my $attributeType = $attribute->type;
 
     # Avoid clash with C++ keyword.
     $attributeName = "_operator" if $attributeName eq "operator";
 
     # SVGAElement defines a non-virtual "String& target() const" method which clashes with "virtual String target() const" in Element.
     # To solve this issue the SVGAElement method was renamed to "svgTarget", take care of that when calling this method.
     $attributeName = "svgTarget" if $attributeName eq "target" and $attributeType eq "SVGAnimatedString";
 
     # SVG animated types need to use a special attribute name.
     # The rest of the special casing for SVG animated types is handled in the language-specific code generators.
     $attributeName .= "Animated" if IsSVGAnimatedType($attributeType);
 
     return $attributeName;
 }
 
 sub ContentAttributeName
 {
     my ($interfaceName, $attribute) = @_;
 
-    my $contentAttributeName = $attribute->signature->extendedAttributes->{"Reflect"};
+    my $contentAttributeName = $attribute->extendedAttributes->{"Reflect"};
     return undef if !$contentAttributeName;
 
     $contentAttributeName = lc AttributeNameForGetterAndSetter($attribute) if $contentAttributeName eq "VALUE_IS_MISSING";
 
     my $namespace = NamespaceForAttributeName($interfaceName, $contentAttributeName);
 
     AddToImplIncludes("${namespace}.h");
     return "WebCore::${namespace}::${contentAttributeName}Attr";
 }
 
 sub CanUseFastAttribute
 {
     my $attribute = shift;
-    return !IsSVGAnimatedType($attribute->signature->type);
+    return !IsSVGAnimatedType($attribute->type);
 }
 
 sub GetterExpression
 {
     my ($interfaceName, $attribute) = @_;
 
     my $contentAttributeName = ContentAttributeName($interfaceName, $attribute);
 
     if (!$contentAttributeName) {
         return (ToMethodName(AttributeNameForGetterAndSetter($attribute)));
     }
 
     my $functionName;
-    if ($attribute->signature->extendedAttributes->{"URL"}) {
+    if ($attribute->extendedAttributes->{"URL"}) {
         $functionName = "getURLAttribute";
-    } elsif ($attribute->signature->type eq "boolean") {
+    } elsif ($attribute->type eq "boolean") {
         if (CanUseFastAttribute($attribute)) {
             $functionName = "fastHasAttribute";
         } else {
             $functionName = "hasAttribute";
         }
-    } elsif ($attribute->signature->type eq "long") {
+    } elsif ($attribute->type eq "long") {
         $functionName = "getIntegralAttribute";
-    } elsif ($attribute->signature->type eq "unsigned long") {
+    } elsif ($attribute->type eq "unsigned long") {
         $functionName = "getUnsignedIntegralAttribute";
     } else {
         if ($contentAttributeName eq "WebCore::HTMLNames::idAttr") {
             $functionName = "getIdAttribute";
             $contentAttributeName = "";
         } elsif ($contentAttributeName eq "WebCore::HTMLNames::nameAttr") {
             $functionName = "getNameAttribute";
             $contentAttributeName = "";
         } elsif ($contentAttributeName eq "WebCore::HTMLNames::classAttr") {
             $functionName = "getClassAttribute";
@@ skipping 12 matching lines @@
 {
     my ($interfaceName, $attribute) = @_;
 
     my $contentAttributeName = ContentAttributeName($interfaceName, $attribute);
 
     if (!$contentAttributeName) {
         return ("set" . FirstLetterToUpperCase(AttributeNameForGetterAndSetter($attribute)));
     }
 
     my $functionName;
-    if ($attribute->signature->type eq "boolean") {
+    if ($attribute->type eq "boolean") {
         $functionName = "setBooleanAttribute";
-    } elsif ($attribute->signature->type eq "long") {
+    } elsif ($attribute->type eq "long") {
         $functionName = "setIntegralAttribute";
-    } elsif ($attribute->signature->type eq "unsigned long") {
+    } elsif ($attribute->type eq "unsigned long") {
         $functionName = "setUnsignedIntegralAttribute";
     } else {
         $functionName = "setAttribute";
     }
 
     return ($functionName, $contentAttributeName);
 }
 
 sub GenerateConditionalString
 {
@@ skipping 100 matching lines @@
         if ($currentInterface->extendedAttributes->{$extendedAttribute}) {
             $found = 1;
         }
         return 1 if $found;
     }, 0);
 
     return $found;
 }
 
 1;