IDL compiler: anonymous indexed property getters

Source/bindings/templates/interface.cpp

 {% extends 'interface_base.cpp' %}
 
 
 {##############################################################################}
 {% macro attribute_configuration(attribute) %}
 {% set getter_callback =
        '%sV8Internal::%sAttributeGetterCallback' %
             (cpp_class, attribute.name)
        if not attribute.constructor_type else
        '{0}V8Internal::{0}ConstructorGetter'.format(interface_name) %}
@@ skipping 80 matching lines @@
 {
     {{cpp_class}}* imp =  {{v8_class}}::toNative(host);
     return BindingSecurity::shouldAllowAccessToFrame(imp->frame(), DoNotReportSecurityError);
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
+{% block anonymous_indexed_property_getter_and_callback %}
+{% if anonymous_indexed_property_getter %}
+{% set getter = anonymous_indexed_property_getter %}
+static void indexedPropertyGetter(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info)
+{
+    ASSERT(V8DOMWrapper::maybeDOMWrapper(info.Holder()));

[haraken, 2014/01/27 06:35:32]

You can remove this. It's guaranteed that info.Holder() is a DOM wrapper.

[Nils Barth (inactive), 2014/01/27 06:59:35]

Got it, posted CL:
Remove unnecessary maybeDOMWrapper from indexed/named property getters
https://codereview.chromium.org/138003013/

+    {{cpp_class}}* collection = {{v8_class}}::toNative(info.Holder());
+    {{getter.cpp_type}} element = collection->{{getter.name}}(index);
+    if ({{getter.is_null_expression}})
+        return;
+    {{getter.v8_set_return_value}};
+}
+
+static void indexedPropertyGetterCallback(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info)
+{
+    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMIndexedProperty");
+    {{cpp_class}}V8Internal::indexedPropertyGetter(index, info);
+    TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
+}
+
+{% endif %}
+{% endblock %}
+
+
+{##############################################################################}
 {% block origin_safe_method_setter %}
 {% if has_origin_safe_method_setter %}
 static void {{cpp_class}}OriginSafeMethodSetter(v8::Local<v8::String> name, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)
 {
     {# FIXME: don't call GetIsolate 3 times #}
     v8::Handle<v8::Object> holder = info.This()->FindInstanceInPrototypeChain({{v8_class}}::domTemplate(info.GetIsolate(), worldType(info.GetIsolate())));
     if (holder.IsEmpty())
         return;
     {{cpp_class}}* imp = {{v8_class}}::toNative(holder);
     v8::String::Utf8Value attributeName(name);
@@ skipping 346 matching lines @@
     if ({{attribute.runtime_enabled_function}}()) {
         static const V8DOMConfiguration::AttributeConfiguration attributeConfiguration =\
         {{attribute_configuration(attribute)}};
         V8DOMConfiguration::installAttribute(instanceTemplate, prototypeTemplate, attributeConfiguration, isolate, currentWorldType);
     }
     {% endfilter %}
     {% endfor %}
     {% if constants %}
     {{install_constants() | indent}}
     {% endif %}
+    {% if anonymous_indexed_property_getter %}
+    functionTemplate->InstanceTemplate()->SetIndexedPropertyHandler({{cpp_class}}V8Internal::indexedPropertyGetterCallback, 0, 0, 0, indexedPropertyEnumerator<{{cpp_class}}>);
+    {% endif %}
     {% if has_custom_legacy_call_as_function %}
     functionTemplate->InstanceTemplate()->SetCallAsFunctionHandler({{v8_class}}::legacyCallCustom);
     {% endif %}
     {% if interface_name == 'HTMLAllCollection' %}
     {# Needed for legacy support of document.all #}
     functionTemplate->InstanceTemplate()->MarkAsUndetectable();
     {% endif %}
     {% for method in methods if not method.do_not_check_signature %}
     {# install_custom_signature #}
     {% if not method.overload_index or method.overload_index == 1 %}
@@ skipping 281 matching lines @@
     fromInternalPointer(object)->deref();
 }
 
 template<>
 v8::Handle<v8::Value> toV8NoInline({{cpp_class}}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     return toV8(impl, creationContext, isolate);
 }
 
 {% endblock %}