[binding] Replace [CustomIndexedGetter] attributes with [Custom] getter

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 534 matching lines @@
 
     # FIXME: Expose indexed getter of WebKitCSSMixFunctionValue by removing this special case
     # because CSSValueList(which is parent of WebKitCSSMixFunctionValue) has indexed property getter.
     if ($interface->name eq "WebKitCSSMixFunctionValue") {
         return 0;
     }
 
     return GetSpecialAccessorFunctionForType($interface, "getter", "unsigned long", 1);
 }
 
+sub GetIndexedSetterFunction
+{
+    my $interface = shift;
+
+    return GetSpecialAccessorFunctionForType($interface, "setter", "unsigned long", 2);
+}
+
+sub GetIndexedDeleterFunction
+{
+    my $interface = shift;
+
+    return GetSpecialAccessorFunctionForType($interface, "deleter", "unsigned long", 1);
+}
+
 sub GetNamedGetterFunction
 {
     my $interface = shift;
     return GetSpecialAccessorFunctionForType($interface, "getter", "DOMString", 1);
 }
 
 sub GetNamedSetterFunction
 {
     my $interface = shift;
     return GetSpecialAccessorFunctionForType($interface, "setter", "DOMString", 2);
 }
 
+sub GetNamedDeleterFunction
+{
+    my $interface = shift;
+    return GetSpecialAccessorFunctionForType($interface, "deleter", "DOMString", 1);
+}
+
 sub GetSpecialAccessorFunctionForType
 {
     my $interface = shift;
     my $special = shift;
     my $firstParameterType = shift;
     my $numberOfParameters = shift;
 
     foreach my $function (@{$interface->functions}) {
         my $specials = $function->signature->specials;
         my $specialExists = grep { $_ eq $special } @$specials;
@@ skipping 98 matching lines @@
 
     if ($interfaceName eq "DOMWindow") {
         $header{classPublic}->add(<<END);
     static v8::Persistent<v8::ObjectTemplate> GetShadowObjectTemplate(v8::Isolate*, WrapperWorldType);
 END
     }
 
     my @enabledPerContextFunctions;
     foreach my $function (@{$interface->functions}) {
         my $name = $function->signature->name;
+        next if $name eq "";
         my $attrExt = $function->signature->extendedAttributes;
 
         if (HasCustomMethod($attrExt) && !$attrExt->{"ImplementedBy"} && $function->{overloadIndex} == 1) {
             my $conditionalString = GenerateConditionalString($function->signature);
             $header{classPublic}->add("#if ${conditionalString}\n") if $conditionalString;
             $header{classPublic}->add(<<END);
     static v8::Handle<v8::Value> ${name}MethodCustom(const v8::Arguments&);
 END
             $header{classPublic}->add("#endif // ${conditionalString}\n") if $conditionalString;
         }
@@ skipping 261 matching lines @@
     $header{classPublic}->add(<<END);
     static const int internalFieldCount = v8DefaultWrapperInternalFieldCount + ${customFieldCounter};
 END
 }
 
 sub GenerateHeaderNamedAndIndexedPropertyAccessors
 {
     my $interface = shift;
 
     my $indexedGetterFunction = GetIndexedGetterFunction($interface);
-    my $hasCustomIndexedGetter = $interface->extendedAttributes->{"CustomIndexedGetter"};
-    my $hasIndexedGetter = $indexedGetterFunction || $hasCustomIndexedGetter;
+    my $hasCustomIndexedGetter = $indexedGetterFunction ? $indexedGetterFunction->signature->extendedAttributes->{"Custom"} : 0;
 
-    my $hasCustomIndexedSetter = $interface->extendedAttributes->{"CustomIndexedSetter"};
+    my $indexedSetterFunction = GetIndexedSetterFunction($interface);
+    my $hasCustomIndexedSetter = $indexedSetterFunction ? $indexedSetterFunction->signature->extendedAttributes->{"Custom"} : 0;
+
+    my $indexedDeleterFunction = GetIndexedDeleterFunction($interface);
+    my $hasCustomIndexedDeleters = $indexedDeleterFunction ? $indexedDeleterFunction->signature->extendedAttributes->{"Custom"} : 0;
 
     my $namedGetterFunction = GetNamedGetterFunction($interface);
-    my $hasCustomNamedGetter = $interface->extendedAttributes->{"CustomNamedGetter"};
-    my $hasNamedGetter = $namedGetterFunction || $hasCustomNamedGetter;
+    my $hasCustomNamedGetter = $namedGetterFunction ? $namedGetterFunction->signature->extendedAttributes->{"Custom"} : 0;
 
     my $namedSetterFunction = GetNamedSetterFunction($interface);
-    my $hasCustomNamedSetter = $interface->extendedAttributes->{"CustomNamedSetter"};
-    my $hasNamedSetter = $namedSetterFunction || $hasCustomNamedSetter;
+    my $hasCustomNamedSetter = $namedSetterFunction ? $namedSetterFunction->signature->extendedAttributes->{"Custom"} : 0;
 
-    my $hasCustomDeleters = $interface->extendedAttributes->{"CustomDeleteProperty"};
+    my $namedDeleterFunction = GetNamedDeleterFunction($interface);
+    my $hasCustomNamedDeleters = $namedDeleterFunction ? $namedSetterFunction->signature->extendedAttributes->{"Custom"} : 0;
 
     my $hasCustomEnumerator = $interface->extendedAttributes->{"CustomEnumerateProperty"};
 
-    if ($hasIndexedGetter) {
+    if ($indexedGetterFunction) {
         $header{classPublic}->add(<<END);
     static v8::Handle<v8::Value> indexedPropertyGetter(uint32_t, const v8::AccessorInfo&);
 END
     }
 
-    if ($hasCustomIndexedSetter) {
+    if ($indexedSetterFunction) {
         $header{classPublic}->add(<<END);
     static v8::Handle<v8::Value> indexedPropertySetter(uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo&);
 END
     }
-    if ($hasCustomDeleters) {
+    if ($indexedDeleterFunction) {
         $header{classPublic}->add(<<END);
     static v8::Handle<v8::Boolean> indexedPropertyDeleter(uint32_t, const v8::AccessorInfo&);
 END
     }
-    if ($hasNamedGetter) {
+    if ($namedGetterFunction) {
         $header{classPublic}->add(<<END);
     static v8::Handle<v8::Value> namedPropertyGetter(v8::Local<v8::String>, const v8::AccessorInfo&);
 END
     }
-    if ($hasNamedSetter) {
+    if ($namedSetterFunction) {
         $header{classPublic}->add(<<END);
     static v8::Handle<v8::Value> namedPropertySetter(v8::Local<v8::String>, v8::Local<v8::Value>, const v8::AccessorInfo&);
 END
     }
-    if ($hasCustomDeleters) {
+    if ($namedDeleterFunction) {
         $header{classPublic}->add(<<END);
     static v8::Handle<v8::Boolean> namedPropertyDeleter(v8::Local<v8::String>, const v8::AccessorInfo&);
 END
     }
     if ($hasCustomEnumerator) {
         $header{classPublic}->add(<<END);
     static v8::Handle<v8::Array> namedPropertyEnumerator(const v8::AccessorInfo&);
     static v8::Handle<v8::Integer> namedPropertyQuery(v8::Local<v8::String>, const v8::AccessorInfo&);
 END
     }
@@ skipping 2019 matching lines @@
     }
     if (IsRefPtrType($type)) {
         return "!${variableName}";
     } elsif ($type eq "DOMString") {
         return "${variableName}.isNull()";
     } else {
         return "";
     }
 }
 
-sub GenerateImplementationIndexedProperty
+sub GenerateImplementationIndexedPropertyAccessors
 {
     my $interface = shift;
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
 
     my $indexedGetterFunction = GetIndexedGetterFunction($interface);
-    my $hasCustomIndexedSetter = $interface->extendedAttributes->{"CustomIndexedSetter"};
-    my $hasCustomIndexedGetter = $interface->extendedAttributes->{"CustomIndexedGetter"};
-
-    if (!$indexedGetterFunction && !$hasCustomIndexedGetter) {
-        return "";
+    my $hasCustomIndexedGetter = $indexedGetterFunction ? $indexedGetterFunction->signature->extendedAttributes->{"Custom"} : 0;
+    if ($indexedGetterFunction && !$hasCustomIndexedGetter) {
+        GenerateImplementationIndexedPropertyGetter($interface, $indexedGetterFunction);
     }
 
-    my $hasEnumerator = 1;
+    # FIXME: Support generated indexed setter bindings.
+    my $indexedSetterFunction = GetIndexedSetterFunction($interface);
+    my $hasCustomIndexedSetter = $indexedSetterFunction ? $indexedSetterFunction->signature->extendedAttributes->{"Custom"} : 0;
+
+    # FIXME: Support generated named deleter bindings.
+    my $indexedDeleterFunction = GetIndexedDeleterFunction($interface);
+    my $hasCustomIndexedDeleter = $indexedDeleterFunction ? $indexedDeleterFunction->signature->extendedAttributes->{"Custom"} : 0;
+
+    # FIXME: Support generated named enumerator bindings.
+    my $hasEnumerator = $indexedGetterFunction;
     # FIXME: Remove the special cases. Interfaces that have indexedPropertyGetter should have indexedPropertyEnumerator.
     $hasEnumerator = 0 if $interfaceName eq "WebKitCSSKeyframesRule";
     $hasEnumerator = 0 if $interfaceName eq "HTMLAppletElement";
     $hasEnumerator = 0 if $interfaceName eq "HTMLEmbedElement";
     $hasEnumerator = 0 if $interfaceName eq "HTMLObjectElement";
     $hasEnumerator = 0 if $interfaceName eq "DOMWindow";
     $hasEnumerator = 0 if $interfaceName eq "Storage";
 
-    AddToImplIncludes("bindings/v8/V8Collection.h");
 
-    my $hasDeleter = $interface->extendedAttributes->{"CustomDeleteProperty"};
+    # FIXME: Support generated named query bindings.
+    my $indexedQueryFunction = 0;
+    # If there is an enumerator, there MUST be a query method to properly communicate property attributes.
+    my $hasQuery = $indexedQueryFunction || $hasEnumerator;
+
     my $setOn = "Instance";
 
     # V8 has access-check callback API (see ObjectTemplate::SetAccessCheckCallbacks) and it's used on DOMWindow
     # instead of deleters or enumerators. In addition, the getter should be set on prototype template, to
     # get implementation straight out of the DOMWindow prototype regardless of what prototype is actually set
     # on the object.
     if ($interfaceName eq "DOMWindow") {
         $setOn = "Prototype";
     }
 
     my $code = "";
-    $code .= "    desc->${setOn}Template()->SetIndexedPropertyHandler(${v8ClassName}::indexedPropertyGetter";
-    $code .= $hasCustomIndexedSetter ? ", ${v8ClassName}::indexedPropertySetter" : ", 0";
-    $code .= ", 0"; # IndexedPropertyQuery -- not being used at the moment.
-    $code .= $hasDeleter ? ", ${v8ClassName}::indexedPropertyDeleter" : ", 0";
-    $code .= ", nodeCollectionIndexedPropertyEnumerator<${implClassName}>" if $hasEnumerator;
-    $code .= ");\n";
+    if ($indexedGetterFunction || $indexedSetterFunction || $indexedDeleterFunction || $hasEnumerator || $hasQuery) {
+        $code .= "    desc->${setOn}Template()->SetIndexedPropertyHandler(${v8ClassName}::indexedPropertyGetter";
+        $code .= $indexedSetterFunction ? ", ${v8ClassName}::indexedPropertySetter" : ", 0";
+        $code .= ", 0"; # IndexedPropertyQuery -- not being used at the moment.
+        $code .= $indexedDeleterFunction ? ", ${v8ClassName}::indexedPropertyDeleter" : ", 0";
+        $code .= ", nodeCollectionIndexedPropertyEnumerator<${implClassName}>" if $hasEnumerator;
+        $code .= ");\n";
+    }
 
-    if ($indexedGetterFunction && !$hasCustomIndexedGetter) {
-        my $returnType = $indexedGetterFunction->signature->type;
-        my $nativeType = GetNativeType($returnType);
-        my $methodName = GetImplName($indexedGetterFunction->signature);
-        AddToImplIncludes("bindings/v8/V8Collection.h");
-        my $nativeValue = "element";
-        $nativeValue .= ".release()" if (IsRefPtrType($returnType));
-        my $isNull = GenerateIsNullExpression($returnType, "element");
-        my $returnJSValueCode = NativeToJSValue($indexedGetterFunction->signature->type, $indexedGetterFunction->signature->extendedAttributes, $nativeValue, "    ", "return", "info.Holder()", "info.GetIsolate()", "info", "collection");
-        my $raisesExceptions = $indexedGetterFunction->signature->extendedAttributes->{"RaisesException"};
-        my $methodCallCode = GenerateMethodCall($returnType, "element", "collection->${methodName}", "index", $raisesExceptions);
-        my $getterCode = "v8::Handle<v8::Value> ${v8ClassName}::indexedPropertyGetter(uint32_t index, const v8::AccessorInfo& info)\n";
-        $getterCode .= "{\n";
-        $getterCode .= "    ASSERT(V8DOMWrapper::maybeDOMWrapper(info.Holder()));\n";
-        $getterCode .= "    ${implClassName}* collection = toNative(info.Holder());\n";
-        if ($raisesExceptions) {
-            $getterCode .= "    ExceptionCode ec = 0;\n";
-        }
-        $getterCode .= $methodCallCode . "\n";
-        if ($raisesExceptions) {
-            $getterCode .= "    if (ec)\n";
-            $getterCode .= "        return setDOMException(ec, info.GetIsolate());\n";
-        }
-        if (IsUnionType($returnType)) {
-            $getterCode .= "${returnJSValueCode}\n";
-            $getterCode .= "    return v8Undefined();\n";
-        } else {
-            $getterCode .= "    if (${isNull})\n";
-            $getterCode .= "        return v8Undefined();\n";
-            $getterCode .= $returnJSValueCode . "\n";
-        }
-        $getterCode .= "}\n\n";
-        $implementation{nameSpaceWebCore}->add($getterCode);
+    return $code;
+}
+
+sub GenerateImplementationIndexedPropertyGetter
+{
+    my $interface = shift;
+    my $indexedGetterFunction = shift;
+    my $implClassName = GetImplName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
+    my $methodName = GetImplName($indexedGetterFunction->signature);
+
+    AddToImplIncludes("bindings/v8/V8Collection.h");
+    my $returnType = $indexedGetterFunction->signature->type;
+    my $nativeType = GetNativeType($returnType);
+    my $nativeValue = "element";
+    $nativeValue .= ".release()" if (IsRefPtrType($returnType));
+    my $isNull = GenerateIsNullExpression($returnType, "element");
+    my $returnJSValueCode = NativeToJSValue($indexedGetterFunction->signature->type, $indexedGetterFunction->signature->extendedAttributes, $nativeValue, "    ", "return", "info.Holder()", "info.GetIsolate()", "info", "collection");
+    my $raisesExceptions = $indexedGetterFunction->signature->extendedAttributes->{"RaisesException"};
+    my $methodCallCode = GenerateMethodCall($returnType, "element", "collection->${methodName}", "index", $raisesExceptions);
+    my $getterCode = "v8::Handle<v8::Value> ${v8ClassName}::indexedPropertyGetter(uint32_t index, const v8::AccessorInfo& info)\n";
+    $getterCode .= "{\n";
+    $getterCode .= "    ASSERT(V8DOMWrapper::maybeDOMWrapper(info.Holder()));\n";
+    $getterCode .= "    ${implClassName}* collection = toNative(info.Holder());\n";
+    if ($raisesExceptions) {
+        $getterCode .= "    ExceptionCode ec = 0;\n";
     }
-    return $code;
+    $getterCode .= $methodCallCode . "\n";
+    if ($raisesExceptions) {
+        $getterCode .= "    if (ec)\n";
+        $getterCode .= "        return setDOMException(ec, info.GetIsolate());\n";
+    }
+    if (IsUnionType($returnType)) {
+        $getterCode .= "${returnJSValueCode}\n";
+        $getterCode .= "    return v8Undefined();\n";
+    } else {
+        $getterCode .= "    if (${isNull})\n";
+        $getterCode .= "        return v8Undefined();\n";
+        $getterCode .= $returnJSValueCode . "\n";
+    }
+    $getterCode .= "}\n\n";
+    $implementation{nameSpaceWebCore}->add($getterCode);
 }
 
 sub GenerateImplementationNamedPropertyAccessors
 {
     my $interface = shift;
 
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
 
     my $namedGetterFunction = GetNamedGetterFunction($interface);
-    my $hasCustomNamedGetter = $interface->extendedAttributes->{"CustomNamedGetter"};
-    my $hasGetter = $namedGetterFunction || $hasCustomNamedGetter;
+    my $hasCustomNamedGetter = $namedGetterFunction ? $namedGetterFunction->signature->extendedAttributes->{"Custom"} : 0;
+    my $hasGetter = $namedGetterFunction;
     if ($namedGetterFunction && !$hasCustomNamedGetter) {
         GenerateImplementationNamedPropertyGetter($interface, $namedGetterFunction);
     }
 
     my $namedSetterFunction = GetNamedSetterFunction($interface);
-    my $hasCustomNamedSetter = $interface->extendedAttributes->{"CustomNamedSetter"};
-    my $hasSetter = $namedSetterFunction || $hasCustomNamedSetter;
+    my $hasCustomNamedSetter = $namedSetterFunction ? $namedSetterFunction->signature->extendedAttributes->{"Custom"} : 0;
+    my $hasSetter = $namedSetterFunction;
     if ($namedSetterFunction && !$hasCustomNamedSetter) {
         GenerateImplementationNamedPropertySetter($interface, $namedSetterFunction);
     }
 
     # FIXME: Support generated named deleter bindings.
-    my $namedDeleterFunction = 0;
-    my $hasCustomNamedDeleter = $interface->extendedAttributes->{"CustomDeleteProperty"};
-    my $hasDeleter = $namedDeleterFunction || $hasCustomNamedDeleter;
+    my $namedDeleterFunction = GetNamedDeleterFunction($interface);
+    my $hasCustomNamedDeleters = $namedDeleterFunction ? $namedSetterFunction->signature->extendedAttributes->{"Custom"} : 0;
+    my $hasDeleter = $namedDeleterFunction;
 
     # FIXME: Support generated named enumerator bindings.
     my $namedEnumeratorFunction = 0;
     my $hasCustomNamedEnumerator = $interface->extendedAttributes->{"CustomEnumerateProperty"};
     my $hasEnumerator = $namedEnumeratorFunction || $hasCustomNamedEnumerator;
 
     # FIXME: Support generated named query bindings.
     my $namedQueryFunction = 0;
     # If there is an enumerator, there MUST be a query method to properly communicate property attributes.
     my $hasQuery = $namedQueryFunction || $hasEnumerator;
@@ skipping 619 matching lines @@
         $code .= "\n#if ${conditionalString}\n" if $conditionalString;
         $code .= "    if (${enable_function}()) {\n";
         $code .= <<END;
         static const V8DOMConfiguration::BatchedConstant constData = {"${name}", static_cast<signed int>(${value})};
         V8DOMConfiguration::batchConfigureConstants(desc, proto, &constData, 1, isolate);
 END
         $code .= "    }\n";
         $code .= "\n#endif // ${conditionalString}\n" if $conditionalString;
     }
 
-    $code .= GenerateImplementationIndexedProperty($interface);
+    $code .= GenerateImplementationIndexedPropertyAccessors($interface);
     $code .= GenerateImplementationNamedPropertyAccessors($interface);
     $code .= GenerateImplementationLegacyCall($interface);
     $code .= GenerateImplementationMasqueradesAsUndefined($interface);
 
     # Define our functions with Set() or SetAccessor()
     my $total_functions = 0;
     foreach my $function (@normalFunctions) {
         # Only one accessor is needed for overloaded methods:
         next if $function->{overloadIndex} > 1;
         next if $function->signature->name eq "";
@@ skipping 1641 matching lines @@
         if ($currentInterface->extendedAttributes->{$extendedAttribute}) {
             $found = 1;
         }
         return 1 if $found;
     }, 0);
 
     return $found;
 }
 
 1;