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 699 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 $hasIndexedGetter = $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;
+        $hasIndexedGetter = 1;
         $hasCustomNamedGetter = 1;
     }
     if ($interfaceName eq "DOMWindow") {
         $hasCustomDeleters = 0;
         $hasCustomEnumerator = 0;
     }
     if ($interfaceName eq "HTMLAppletElement" || $interfaceName eq "HTMLEmbedElement" || $interfaceName eq "HTMLObjectElement") {
         $hasCustomNamedGetter = 1;
     }
     if ($interfaceName eq "HTMLDocument") {
         $hasCustomNamedGetter = 0;
-        $hasCustomIndexedGetter = 0;
+        $hasIndexedGetter = 0;
     }
     my $isIndexerSpecialCase = exists $indexerSpecialCases{$interfaceName};
+    if ($isIndexerSpecialCase) {
+        $hasIndexedGetter = 1;
+        $hasCustomIndexedSetter = 1;
+    }
 
-    if ($hasCustomIndexedGetter || $isIndexerSpecialCase) {
+    if ($hasIndexedGetter) {
         AddToHeader(<<END);
     static v8::Handle<v8::Value> indexedPropertyGetter(uint32_t, const v8::AccessorInfo&);
 END
     }
 
-    if ($isIndexerSpecialCase || $hasCustomIndexedSetter) {
+    if ($hasCustomIndexedSetter) {
         AddToHeader(<<END);
     static v8::Handle<v8::Value> indexedPropertySetter(uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo&);
 END
     }
     if ($hasCustomDeleters) {
         AddToHeader(<<END);
     static v8::Handle<v8::Boolean> indexedPropertyDeleter(uint32_t, const v8::AccessorInfo&);
 END
     }
     if ($hasCustomNamedGetter) {
@@ skipping 1913 matching lines @@
         $code .= "    } else {\n";
         $code .= "        ${conditional}$template->Set(v8::String::NewSymbol(\"$name\"), v8::FunctionTemplate::New(${interfaceName}V8Internal::${name}MethodCallback, v8Undefined(), ${signature})$property_attributes);\n";
         $code .= "    }\n";
     } else {
         $code .= "    ${conditional}$template->Set(v8::String::NewSymbol(\"$name\"), v8::FunctionTemplate::New(${interfaceName}V8Internal::${name}MethodCallback, v8Undefined(), ${signature})$property_attributes);\n";
     }
     $code .= "#endif // ${conditionalString}\n" if $conditionalString;
     return $code;
 }
 
-sub GenerateImplementationIndexer
+sub GenerateImplementationIndexedProperty
 {
     my $interface = shift;
     my $indexer = shift;
-    my $code = "";
-
     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"};
+    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) {
+    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") {
-                $code .= <<END;
-    setCollectionStringOrUndefinedIndexedGetter<${interfaceName}>(desc);
-END
-            } else {
-                $code .= <<END;
-    setCollectionStringIndexedGetter<${interfaceName}>(desc);
-END
-            }
-        } else {
-            $code .= <<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 $code;
+    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;
+    }
 
+    my $code = "";
     $code .= "    desc->${setOn}Template()->SetIndexedPropertyHandler(${v8InterfaceName}::indexedPropertyGetter";
-    $code .= $hasCustomSetter ? ", ${v8InterfaceName}::indexedPropertySetter" : ", 0";
+    $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";
+        }
+        my $jsValue = "";
+        my $nativeType = GetNativeType($indexerType);
+        my $isNull = "";
+
+        if ($codeGenerator->IsRefPtrType($indexerType)) {
+            $isNull = "!element";
+            if ($interfaceName eq "WebKitCSSKeyframesRule") {
+                $jsValue = "toV8(element.release(), info.Holder(), info.GetIsolate())";
+            } else {
+                $jsValue = NativeToJSValue($indexer, "element.release()", "info.Holder()", "info.GetIsolate()");
+            }
+        } else {
+            $isNull = "element.isNull()";
+            $jsValue = NativeToJSValue($indexer, "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);
+    if ($isNull)
+        return v8Undefined();
+    return $jsValue;
+}
+END
+    }
     return $code;
 }
 
 sub GenerateImplementationNamedPropertyGetter
 {
     my $interface = shift;
     my $namedPropertyGetter = shift;
     my $subCode = "";
 
     my $interfaceName = $interface->name;
@@ skipping 557 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 .= GenerateImplementationIndexer($interface, $indexer);
-
-    my $tmplConfig = GenerateImplementationNamedPropertyGetter($interface, $namedPropertyGetter);
-    $code .= $tmplConfig;
+    $code .= GenerateImplementationIndexedProperty($interface, $indexer);
+    $code .= GenerateImplementationNamedPropertyGetter($interface, $namedPropertyGetter);
     $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;
 
         $total_functions++;
@@ skipping 1349 matching lines @@
 
 sub GetPassRefPtrType
 {
     my $v8InterfaceName = shift;
 
     my $angleBracketSpace = $v8InterfaceName =~ />$/ ? " " : "";
     return "PassRefPtr<${v8InterfaceName}${angleBracketSpace}>";
 }
 
 1;