Gen index getter by unified way instead of using several helper function in some special cases.

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 680 matching lines @@
     "Storage" => 1,
     "HTMLAppletElement" => 1,
     "HTMLEmbedElement" => 1,
     "HTMLObjectElement" => 1
 );
 
 sub GenerateHeaderNamedAndIndexedPropertyAccessors
 {
     my $interface = shift;
     my $interfaceName = $interface->name;
-    my $hasCustomIndexedGetter = $interface->extendedAttributes->{"IndexedGetter"} || $interface->extendedAttributes->{"CustomGetOwnPropertySlot"};
+    my $hasCustomIndexedGetter = $interface->extendedAttributes->{"IndexedGetter"} || $interface->extendedAttributes->{"CustomIndexedGetter"};
     my $hasCustomIndexedSetter = $interface->extendedAttributes->{"CustomIndexedSetter"} && !$interface->extendedAttributes->{"NumericIndexedGetter"};
     my $hasCustomNamedGetter = $interface->extendedAttributes->{"NamedGetter"} || $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";
         $hasCustomIndexedGetter = 1;
         $hasCustomNamedGetter = 1;
     }
@@ skipping 1891 matching lines @@
         push(@implContent, "        ${conditional}$template->Set(v8::String::NewSymbol(\"$name\"), v8::FunctionTemplate::New(${interfaceName}V8Internal::${name}MethodCallbackForMainWorld, v8Undefined(), ${signature})$property_attributes);\n");
         push(@implContent, "    } else {\n");
         push(@implContent, "        ${conditional}$template->Set(v8::String::NewSymbol(\"$name\"), v8::FunctionTemplate::New(${interfaceName}V8Internal::${name}MethodCallback, v8Undefined(), ${signature})$property_attributes);\n");
         push(@implContent, "    }\n");
     } else {
         push(@implContent, "    ${conditional}$template->Set(v8::String::NewSymbol(\"$name\"), v8::FunctionTemplate::New(${interfaceName}V8Internal::${name}MethodCallback, v8Undefined(), ${signature})$property_attributes);\n");
     }
     push(@implContent, "#endif // ${conditionalString}\n") if $conditionalString;
 }
 
-sub GenerateImplementationIndexer
+sub GenerateImplementationIndexedProperty
 {
     my $interface = shift;
     my $indexer = shift;
     my $interfaceName = $interface->name;
     my $v8InterfaceName = "V8$interfaceName";
 
     # FIXME: Figure out what NumericIndexedGetter is really supposed to do. Right now, it's only set on WebGL-related files.
-    my $hasCustomSetter = $interface->extendedAttributes->{"CustomIndexedSetter"} && !$interface->extendedAttributes->{"NumericIndexedGetter"};
-    my $hasGetter = $interface->extendedAttributes->{"IndexedGetter"} || $interface->extendedAttributes->{"CustomGetOwnPropertySlot"};
+    my $hasCustomIndexedSetter = $interface->extendedAttributes->{"CustomIndexedSetter"} && !$interface->extendedAttributes->{"NumericIndexedGetter"};
+    my $hasIndexedGetter = $interface->extendedAttributes->{"IndexedGetter"} || $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) {
-        $hasGetter = 1;
+        $hasIndexedGetter = 1;
         if ($interface->extendedAttributes->{"CustomNamedSetter"}) {
-            $hasCustomSetter = 1;
+            $hasCustomIndexedSetter = 1;
         }
     }
 
+    # FIXME: Remove the special cases. Interfaces that have indexedPropertyGetter should have indexedPropertyEnumerator.
     my $hasEnumerator = !$isSpecialCase && $codeGenerator->InheritsInterface($interface, "Node");
 
     # FIXME: Find a way to not have to special-case HTMLOptionsCollection.
     if ($interfaceName eq "HTMLOptionsCollection") {
         $hasEnumerator = 1;
-        $hasGetter = 1;
+        $hasIndexedGetter = 1;
     }
 
-    if (!$hasGetter) {
-        return;
+    if (!$hasIndexedGetter) {
+        return "";
     }
 
     AddToImplIncludes("V8Collection.h");
 
     if (!$indexer) {
         $indexer = $codeGenerator->FindSuperMethod($interface, "item");
     }
 
     my $indexerType = $indexer ? $indexer->type : 0;
 
-    # FIXME: Remove this once toV8 helper methods are implemented (see https://bugs.webkit.org/show_bug.cgi?id=32563).
-    if ($interfaceName eq "WebKitCSSKeyframesRule") {
-        $indexerType = "WebKitCSSKeyframeRule";
-    }
-
-    if ($indexerType && !$hasCustomSetter) {
-        if ($indexerType eq "DOMString") {
-            my $conversion = $indexer->extendedAttributes->{"TreatReturnedNullStringAs"};
-            if ($conversion && $conversion eq "Null") {
-                push(@implContent, <<END);
-    setCollectionStringOrUndefinedIndexedGetter<${interfaceName}>(desc);
-END
-            } else {
-                push(@implContent, <<END);
-    setCollectionStringIndexedGetter<${interfaceName}>(desc);
-END
-            }
-        } else {
-            push(@implContent, <<END);
-    setCollectionIndexedGetter<${interfaceName}, ${indexerType}>(desc);
-END
-            # Include the header for this indexer type, because setCollectionIndexedGetter() requires toV8() for this type.
-            AddToImplIncludes("V8${indexerType}.h");
-        }
-
-        return;
+    if ($indexerType && !$hasCustomIndexedSetter) {
+        $hasEnumerator = 1;
     }
 
     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";
         $hasDeleter = 0;
     }
+    # FIXME: Implement V8DataTransferItemList::indexedPropertyDeleter
+    if ($interfaceName eq "DataTransferItemList") {
+        $hasDeleter = 0;
+    }
 
     push(@implContent, "    desc->${setOn}Template()->SetIndexedPropertyHandler(${v8InterfaceName}::indexedPropertyGetter");
-    push(@implContent, $hasCustomSetter ? ", ${v8InterfaceName}::indexedPropertySetter" : ", 0");
+    push(@implContent, $hasCustomIndexedSetter ? ", ${v8InterfaceName}::indexedPropertySetter" : ", 0");
     push(@implContent, ", 0"); # IndexedPropertyQuery -- not being used at the moment.
     push(@implContent, $hasDeleter ? ", ${v8InterfaceName}::indexedPropertyDeleter" : ", 0");
     push(@implContent, ", nodeCollectionIndexedPropertyEnumerator<${interfaceName}>") if $hasEnumerator;
     push(@implContent, ");\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";
+        }
+        my $jsValue = "";
+        my $elementType = GetNativeType($indexerType);

[haraken, 2013/04/17 10:29:52]

$elementType => $nativeType

+        my $isNull = "";
+
+        if ($indexerType eq "DOMString") {

[haraken, 2013/04/17 10:29:52]

Shall we use $codeGenerator->IsRefPtrType($indexerType) instead of hard-coding
"DOMString" ?

+            $isNull = "element.isNull()";
+            $jsValue = NativeToJSValue($indexer, "element", "info.Holder()", "info.GetIsolate()");
+        } else {
+            $isNull = "!element";
+            if ($interfaceName eq "WebKitCSSKeyframesRule") {
+                $jsValue = "toV8(element.release(), info.Holder(), info.GetIsolate())";
+            } else {
+                $jsValue = NativeToJSValue($indexer, "element.release()", "info.Holder()", "info.GetIsolate()");
+            }
+        }
+
+        return <<END;
+v8::Handle<v8::Value> ${v8InterfaceName}::indexedPropertyGetter(uint32_t index, const v8::AccessorInfo& info)
+{
+    ASSERT(V8DOMWrapper::maybeDOMWrapper(info.Holder()));
+    ${interfaceName}* collection = toNative(info.Holder());
+    $elementType element = collection->item(index);
+    if ($isNull)
+        return v8Undefined();
+    return $jsValue;
+}
+END
+    }
+    return "";
 }
 
 sub GenerateImplementationNamedPropertyGetter
 {
     my $interface = shift;
     my $namedPropertyGetter = shift;
     my $interfaceName = $interface->name;
     my $v8InterfaceName = "V8$interfaceName";
 
     if ($interface->extendedAttributes->{"NamedGetter"}) {
@@ skipping 507 matching lines @@
         push(@implContent, "\n#if ${conditionalString}\n") if $conditionalString;
         push(@implContent, "    if (${enable_function}()) {\n");
         push(@implContent, <<END);
         static const V8DOMConfiguration::BatchedConstant constData = {"${name}", static_cast<signed int>(${value})};
         V8DOMConfiguration::batchConfigureConstants(desc, proto, &constData, 1, isolate);
 END
         push(@implContent, "    }\n");
         push(@implContent, "\n#endif // ${conditionalString}\n") if $conditionalString;
     }
 
-    GenerateImplementationIndexer($interface, $indexer);
+    my $indexPropertyGetterCode = GenerateImplementationIndexedProperty($interface, $indexer);
     GenerateImplementationNamedPropertyGetter($interface, $namedPropertyGetter);
     GenerateImplementationCustomCall($interface);
     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 68 matching lines @@
 
 bool ${v8InterfaceName}::HasInstanceInAnyWorld(v8::Handle<v8::Value> value, v8::Isolate* isolate)
 {
     return V8PerIsolateData::from(isolate)->hasInstance(&info, value, MainWorld)
         || V8PerIsolateData::from(isolate)->hasInstance(&info, value, IsolatedWorld)
         || V8PerIsolateData::from(isolate)->hasInstance(&info, value, WorkerWorld);
 }
 
 END
 
+    push(@implContent, $indexPropertyGetterCode);
+
     if (@enabledPerContextAttributes) {
         push(@implContent, <<END);
 void ${v8InterfaceName}::installPerContextProperties(v8::Handle<v8::Object> instance, ${nativeType}* impl, v8::Isolate* isolate)
 {
     v8::Local<v8::Object> proto = v8::Local<v8::Object>::Cast(instance->GetPrototype());
     // When building QtWebkit with V8 this variable is unused when none of the features are enabled.
     UNUSED_PARAM(proto);
 END
 
         # Setup the enable-by-settings attrs if we have them
@@ skipping 1269 matching lines @@
 
 sub GetPassRefPtrType
 {
     my $v8InterfaceName = shift;
 
     my $angleBracketSpace = $v8InterfaceName =~ />$/ ? " " : "";
     return "PassRefPtr<${v8InterfaceName}${angleBracketSpace}>";
 }
 
 1;