Support for latest WebIDL for indexed property getters.

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 413 matching lines @@
         AddToHeaderIncludes("core/svg/properties/SVGPathSegListPropertyTearOff.h");
     }
 
     if ($svgPropertyType) {
         $svgPropertyType = "SVGPoint" if $svgPropertyType eq "FloatPoint";
     }
 
     return ($svgPropertyType, $svgListPropertyType, $svgNativeType);
 }
 
+sub MakeDummyFunction
+{
+    my $returnType = shift;
+    my $methodName = shift;
+    my $function = domFunction->new();
+    $function->signature(domSignature->new());
+    $function->signature->type($returnType);
+    $function->signature->name($methodName);
+    $function->signature->extendedAttributes({});
+    return $function;
+}
+
+sub GetIndexedGetterFunction
+{
+    my $interface = shift;
+
+    # 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;
+    }
+
+    # FIXME: add getter method to WebKitCSSKeyframesRule.idl or remove special case of WebKitCSSKeyframesRule.idl
+    # Currently return type and method name is hard coded because it can not be obtained from IDL.
+    if ($interface->name eq "WebKitCSSKeyframesRule") {
+        return MakeDummyFunction("WebKitCSSKeyframeRule", "item")
+    }
+
+    return GetSpecialGetterFunctionForType($interface, "unsigned long");
+}
+
 sub GetNamedGetterFunction
 {
     my $interface = shift;
 
-    foreach my $function (@{$interface->functions}) {
-        my $specials = $function->signature->specials;
-        my $getterExists = grep { $_ eq "getter" } @$specials;
-        my $parameters = $function->parameters;
-        if ($getterExists and scalar(@$parameters) == 1 and $parameters->[0]->type eq "DOMString" ) {
-            return $function;
+    return GetSpecialGetterFunctionForType($interface, "DOMString");
+}
+
+sub GetSpecialGetterFunctionForType
+{
+    my $interface = shift;
+    my $type = shift;
+
+    my @interfaces = ($interface);
+    ForAllParents($interface, sub {
+        my $currentInterface = shift;
+        push(@interfaces, $currentInterface);
+    });
+
+    foreach my $currentInterface (@interfaces) {
+        foreach my $function (@{$currentInterface->functions}) {
+            my $specials = $function->signature->specials;
+            my $getterExists = grep { $_ eq "getter" } @$specials;
+            my $parameters = $function->parameters;
+            if ($getterExists and scalar(@$parameters) == 1 and $parameters->[0]->type eq $type ) {
+                return $function;
+            }
         }
     }
+
     return 0;
 }
 
 sub GenerateHeader
 {
     my $object = shift;
     my $interface = shift;
 
     my $interfaceName = $interface->name;
     my $v8InterfaceName = "V8$interfaceName";
@@ skipping 426 matching lines @@
     "Storage" => 1,
     "HTMLAppletElement" => 1,
     "HTMLEmbedElement" => 1,
     "HTMLObjectElement" => 1
 );
 
 sub GenerateHeaderNamedAndIndexedPropertyAccessors
 {
     my $interface = shift;
     my $interfaceName = $interface->name;
-    my $hasIndexedGetter = $interface->extendedAttributes->{"IndexedGetter"} || $interface->extendedAttributes->{"CustomIndexedGetter"};
+    my $hasIndexedGetter = GetIndexedGetterFunction($interface) || $interface->extendedAttributes->{"CustomIndexedGetter"};
     my $hasCustomIndexedSetter = $interface->extendedAttributes->{"CustomIndexedSetter"};
     my $hasCustomNamedGetter = GetNamedGetterFunction($interface) || $interface->extendedAttributes->{"CustomNamedGetter"} || $interface->extendedAttributes->{"CustomGetOwnPropertySlot"};
     my $hasCustomNamedSetter = $interface->extendedAttributes->{"CustomNamedSetter"};
     my $hasCustomDeleters = $interface->extendedAttributes->{"CustomDeleteProperty"};
     my $hasCustomEnumerator = $interface->extendedAttributes->{"CustomEnumerateProperty"};
     if ($interfaceName eq "HTMLOptionsCollection") {
         $interfaceName = "HTMLCollection";
         $hasIndexedGetter = 1;
         $hasCustomNamedGetter = 1;
     }
@@ skipping 2045 matching lines @@
     } else {
         $code .= "    ${conditional}$template->Set(v8::String::NewSymbol(\"$name\"), v8::FunctionTemplate::New(${interfaceName}V8Internal::${name}MethodCallback, v8Undefined(), ${signature}, $functionLength)$property_attributes);\n";
     }
     $code .= "#endif // ${conditionalString}\n" if $conditionalString;
     return $code;
 }
 
 sub GenerateImplementationIndexedProperty
 {
     my $interface = shift;
-    my $indexer = shift;
     my $interfaceName = $interface->name;
     my $v8InterfaceName = "V8$interfaceName";
 
+    my $indexedGetterfunction = GetIndexedGetterFunction($interface);
     my $hasCustomIndexedSetter = $interface->extendedAttributes->{"CustomIndexedSetter"};
-    my $hasIndexedGetter = $interface->extendedAttributes->{"IndexedGetter"} || $interface->extendedAttributes->{"CustomIndexedGetter"};
+    my $hasCustomIndexedGetter = $interface->extendedAttributes->{"CustomIndexedGetter"};
 
     # FIXME: Investigate and remove this nastinesss. In V8, named property handling and indexer handling are apparently decoupled,
     # which means that object[X] where X is a number doesn't reach named property indexer. So we need to provide
     # simplistic, mirrored indexer handling in addition to named property handling.
     my $isSpecialCase = exists $indexerSpecialCases{$interfaceName};
     if ($isSpecialCase) {
-        $hasIndexedGetter = 1;
         if ($interface->extendedAttributes->{"CustomNamedSetter"}) {
             $hasCustomIndexedSetter = 1;
         }
     }
 
     # FIXME: Remove the special cases. Interfaces that have indexedPropertyGetter should have indexedPropertyEnumerator.
     my $hasEnumerator = !$isSpecialCase && InheritsInterface($interface, "Node");
 
     # FIXME: Find a way to not have to special-case HTMLOptionsCollection.
     if ($interfaceName eq "HTMLOptionsCollection") {
         $hasEnumerator = 1;
-        $hasIndexedGetter = 1;
     }
 
-    if (!$hasIndexedGetter) {
+    if (!$indexedGetterfunction && !$hasCustomIndexedGetter) {
         return "";
     }
 
     AddToImplIncludes("bindings/v8/V8Collection.h");
 
-    if (!$indexer) {
-        $indexer = FindSuperMethod($interface, "item");
+    if ($indexedGetterfunction && !$hasCustomIndexedSetter) {
+        $hasEnumerator = 1;
     }
-
-    my $indexerType = $indexer ? $indexer->type : 0;
-
-    if ($indexerType && !$hasCustomIndexedSetter) {
-        $hasEnumerator = 1;
+    if ($interfaceName eq "WebKitCSSKeyframesRule") {
+        $hasEnumerator = 0;
     }

[kojih, 2013/05/01 08:50:22]

Although I think every object that have IndexedPropertyGetter should also have
IndexedPropertyEnumerator,
This is necessary so that generated codes are exactly same as before.
(Current WebKitCSSKeyframesRule does not have IndexedPropertyEnumerator)

"enumerator 	The callback to invoke to enumerate all the indexed properties of
an object.":
http://bespin.cz/~ondras/html/classv8_1_1ObjectTemplate.html#af436aeb8132068d...

 
     my $hasDeleter = $interface->extendedAttributes->{"CustomDeleteProperty"};
     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";
     }
     # FIXME: Implement V8DataTransferItemList::indexedPropertyDeleter
     if ($interfaceName eq "DataTransferItemList") {
         $hasDeleter = 0;
     }
 
     my $code = "";
     $code .= "    desc->${setOn}Template()->SetIndexedPropertyHandler(${v8InterfaceName}::indexedPropertyGetter";
     $code .= $hasCustomIndexedSetter ? ", ${v8InterfaceName}::indexedPropertySetter" : ", 0";
     $code .= ", 0"; # IndexedPropertyQuery -- not being used at the moment.
     $code .= $hasDeleter ? ", ${v8InterfaceName}::indexedPropertyDeleter" : ", 0";
     $code .= ", nodeCollectionIndexedPropertyEnumerator<${interfaceName}>" if $hasEnumerator;
     $code .= ");\n";
 
-    if($interface->extendedAttributes->{"IndexedGetter"}) {
-        # FIXME: add item() method to WebKitCSSKeyframesRule.idl or remove [IndexedGetter] from WebKitCSSKeyframesRule.idl
-        # Currently indexer type is hard coded because it can not be obtained from IDL.
-        if ($interfaceName eq "WebKitCSSKeyframesRule") {
-            $indexerType = "WebKitCSSKeyframeRule";
-        }
+    if ($indexedGetterfunction && !$hasCustomIndexedGetter) {
+        my $returnType = $indexedGetterfunction->signature->type;
+        my $methodName = $indexedGetterfunction->signature->name;
+        AddToImplIncludes("bindings/v8/V8Collection.h");
         my $jsValue = "";
-        my $nativeType = GetNativeType($indexerType);
+        my $nativeType = GetNativeType($returnType);
         my $isNull = "";
 
-        if (IsRefPtrType($indexerType)) {
+        if (IsRefPtrType($returnType)) {
+            AddToImplIncludes("V8$returnType.h");
             $isNull = "!element";
-            if ($interfaceName eq "WebKitCSSKeyframesRule") {
-                $jsValue = "toV8(element.release(), info.Holder(), info.GetIsolate())";
-            } else {
-                $jsValue = NativeToJSValue($indexer, "element.release()", "info.Holder()", "info.GetIsolate()");
-            }
+            $jsValue = NativeToJSValue($indexedGetterfunction->signature, "element.release()", "info.Holder()", "info.GetIsolate()", "info", "collection", "", "");
         } else {
             $isNull = "element.isNull()";
-            $jsValue = NativeToJSValue($indexer, "element", "info.Holder()", "info.GetIsolate()");
+            $jsValue = NativeToJSValue($indexedGetterfunction->signature, "element", "info.Holder()", "info.GetIsolate()");
         }
 
         AddToImplContent(<<END);
 v8::Handle<v8::Value> ${v8InterfaceName}::indexedPropertyGetter(uint32_t index, const v8::AccessorInfo& info)
 {
     ASSERT(V8DOMWrapper::maybeDOMWrapper(info.Holder()));
     ${interfaceName}* collection = toNative(info.Holder());
-    $nativeType element = collection->item(index);
+    $nativeType element = collection->$methodName(index);
     if ($isNull)
         return v8Undefined();
     return $jsValue;
 }
 END
     }
     return $code;
 }
 
 sub GenerateImplementationNamedPropertyGetter
 {
     my $interface = shift;
 
     my $subCode = "";
     my $interfaceName = $interface->name;
     my $v8InterfaceName = "V8$interfaceName";
 
-    my $function = GetNamedGetterFunction($interface);
-    if ($function) {
-        my $returnType = $function->signature->type;
-        my $methodName = $function->signature->name;
+    my $namedGetterFunction = GetNamedGetterFunction($interface);
+    my $hasCustomNamedGetter = $interface->extendedAttributes->{"CustomNamedGetter"};
+    # FIXME: make consistent between IDL and implementation. Then remove these special cases.
+    $hasCustomNamedGetter = 1 if $interfaceName eq "HTMLAppletElement";
+    $hasCustomNamedGetter = 1 if $interfaceName eq "HTMLEmbedElement";
+    $hasCustomNamedGetter = 1 if $interfaceName eq "HTMLObjectElement";
+    $hasCustomNamedGetter = 1 if $interfaceName eq "DOMWindow";
+    $hasCustomNamedGetter = 0 if $interfaceName eq "HTMLDocument";
+
+    if ($namedGetterFunction && !$hasCustomNamedGetter) {
+        my $returnType = $namedGetterFunction->signature->type;
+        my $methodName = $namedGetterFunction->signature->name;
         AddToImplIncludes("bindings/v8/V8Collection.h");
         AddToImplIncludes("V8$returnType.h");
         $subCode .= <<END;
     desc->InstanceTemplate()->SetNamedPropertyHandler(${v8InterfaceName}::namedPropertyGetter, 0, 0, 0, 0);
 END
 
         my $code .= <<END;
 v8::Handle<v8::Value> ${v8InterfaceName}::namedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
     if (!info.Holder()->GetRealNamedPropertyInPrototypeChain(name).IsEmpty())
@@ skipping 12 matching lines @@
     if (!element)
         return v8Undefined();
 
     return toV8Fast(element.release(), info, collection);
 }
 
 END
         AddToImplContent($code);
     }
 
-    my $hasCustomNamedGetter = $interface->extendedAttributes->{"CustomNamedGetter"};
-    # FIXME: make consistent between IDL and implementation. Then remove these special cases.
-    $hasCustomNamedGetter = 1 if $interfaceName eq "HTMLAppletElement";
-    $hasCustomNamedGetter = 1 if $interfaceName eq "HTMLEmbedElement";
-    $hasCustomNamedGetter = 1 if $interfaceName eq "HTMLObjectElement";
-    $hasCustomNamedGetter = 1 if $interfaceName eq "DOMWindow";
-    $hasCustomNamedGetter = 0 if $interfaceName eq "HTMLDocument";
-
     if ($hasCustomNamedGetter) {
         my $hasCustomNamedSetter = $interface->extendedAttributes->{"CustomNamedSetter"};
         my $hasDeleter = $interface->extendedAttributes->{"CustomDeleteProperty"};
         my $hasEnumerator = $interface->extendedAttributes->{"CustomEnumerateProperty"};
         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.
@@ skipping 520 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, $indexer);
+    $code .= GenerateImplementationIndexedProperty($interface);
     $code .= GenerateImplementationNamedPropertyGetter($interface);
     $code .= GenerateImplementationCustomCall($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;
 
@@ skipping 1893 matching lines @@
         if ($currentInterface->extendedAttributes->{$extendedAttribute}) {
             $found = 1;
         }
         return 1 if $found;
     }, 0);
 
     return $found;
 }
 
 1;