Support per-overload [RuntimeEnabled] extended attribute

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
        ('%sV8Internal::%sConstructorGetterCallback' %
@@ skipping 968 matching lines @@
     functionTemplate->{{set_on_template}}()->SetNamedPropertyHandler({{named_property_getter_callback}}, {{named_property_setter_callback}}, {{named_property_query_callback}}, {{named_property_deleter_callback}}, {{named_property_enumerator_callback}});
     {% endif %}
     {# End special operations #}
     {% 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 %}
+    {% for method in methods %}
     {# install_custom_signature #}
-    {% if not method.overload_index or method.overload_index == 1 %}
+    {% if not(method.overloads.do_not_check_signature_all if method.overloads else
+              (method.overload_index or method.do_not_check_signature)) %}
     {# For overloaded methods, only generate one accessor #}
     {% filter conditional(method.conditional_string) %}
+    {% filter runtime_enabled(method.overloads.runtime_enabled_function_all if method.overloads else

[Jens Widell, 2014/06/04 11:20:28]

This is wrong if all overloads are runtime enabled, but by more than one feature
flag. You could end up with a method registered that supports zero overloads and
thus always fails when called. (And traces of experimental features could
potentially be shipped in the form of useless stub methods by mistake.)

Don't know how likely it is that this would ever happen. Should we add a FIXME
somewhere in v8_interface.py and raise an exception if such a set of overloads
is ever defined?

[Jens Widell, 2014/06/05 08:51:51]

It occurs to me that the "Function.length is dynamic" compile-time check that
issue 296403007 adds is such a check, somewhat unintentionally.

+                              method.runtime_enabled_function) %}
     {% if method.is_do_not_check_security %}
     {% if method.is_per_world_bindings %}
     if (DOMWrapperWorld::current(isolate).isMainWorld()) {
         {{install_do_not_check_security_signature(method, 'ForMainWorld')}}
     } else {
         {{install_do_not_check_security_signature(method)}}
     }
     {% else %}
     {{install_do_not_check_security_signature(method)}}
     {% endif %}
     {% else %}{# is_do_not_check_security #}
     {% if method.is_per_world_bindings %}
     if (DOMWrapperWorld::current(isolate).isMainWorld()) {
-        {% filter runtime_enabled(method.runtime_enabled_function) %}
         {{install_custom_signature(method, 'ForMainWorld')}}
-        {% endfilter %}
     } else {
-        {% filter runtime_enabled(method.runtime_enabled_function) %}
         {{install_custom_signature(method)}}
-        {% endfilter %}
     }
     {% else %}
-    {% filter runtime_enabled(method.runtime_enabled_function) %}
     {{install_custom_signature(method)}}
-    {% endfilter %}
     {% endif %}
     {% endif %}{# is_do_not_check_security #}
-    {% endfilter %}
+    {% endfilter %}{# runtime_enabled() #}
+    {% endfilter %}{# conditional() #}
     {% endif %}{# install_custom_signature #}
     {% endfor %}
     {% for attribute in attributes if attribute.is_static %}
     {% set getter_callback = '%sV8Internal::%sAttributeGetterCallback' %
            (cpp_class, attribute.name) %}
     {% filter conditional(attribute.conditional_string) %}
     functionTemplate->SetNativeDataProperty(v8AtomicString(isolate, "{{attribute.name}}"), {{getter_callback}}, {{attribute.setter_callback}}, v8::External::New(isolate, 0), static_cast<v8::PropertyAttribute>(v8::None), v8::Handle<v8::AccessorSignature>(), static_cast<v8::AccessControl>(v8::DEFAULT));
     {% endfilter %}
     {% endfor %}
     {# Special interfaces #}
@@ skipping 303 matching lines @@
 {% endif %}
 }
 
 template<>
 v8::Handle<v8::Value> toV8NoInline({{cpp_class}}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     return toV8(impl, creationContext, isolate);
 }
 
 {% endblock %}