[bindings] Implement an ExperimentEnabled IDL extended attribute.

third_party/WebKit/Source/bindings/templates/interface_base.cpp

 {% include 'copyright_block.txt' %}
 #include "config.h"
 {% filter conditional(conditional_string) %}
 #include "{{v8_class_or_partial}}.h"
 
 {% for filename in cpp_includes if filename != '%s.h' % cpp_class_or_partial %}
 #include "{{filename}}"
 {% endfor %}
 
 namespace blink {
@@ skipping 280 matching lines @@
     functionTemplate->ReadOnlyPrototype();
     {% endif %}
 
     v8::Local<v8::Signature> defaultSignature;
     {% set parent_template =
            '%s::domTemplateForNamedPropertiesObject(isolate)' % v8_class
            if has_named_properties_object else
            'V8%s::domTemplate(isolate)' % parent_interface
            if parent_interface else 'v8::Local<v8::FunctionTemplate>()' %}
     {% if runtime_enabled_function %}
-    if (!{{runtime_enabled_function}}())
+    if (!({{runtime_enabled_function}}))
         defaultSignature = V8DOMConfiguration::installDOMClassTemplate(isolate, functionTemplate, "{{interface_name}}", {{parent_template}}, {{v8_class}}::internalFieldCount, 0, 0, 0, 0, 0, 0);
     else
     {% endif %}
     {% set runtime_enabled_indent = 4 if runtime_enabled_function else 0 %}
     {% filter indent(runtime_enabled_indent, true) %}
     defaultSignature = V8DOMConfiguration::installDOMClassTemplate(isolate, functionTemplate, "{{interface_name}}", {{parent_template}}, {{v8_class}}::internalFieldCount,
         {# Test needed as size 0 arrays definitions are not allowed per standard
            (so objects have distinct addresses), which is enforced by MSVC.
            8.5.1 Aggregates [dcl.init.aggr]
            An array of unknown size initialized with a brace-enclosed
            initializer-list containing n initializer-clauses, where n shall be
            greater than zero, is defined as having n elements (8.3.4). #}
         {% set attributes_name, attributes_length =
                ('%sAttributes' % v8_class,
                 'WTF_ARRAY_LENGTH(%sAttributes)' % v8_class)
            if has_attribute_configuration else (0, 0) %}
         {% set accessors_name, accessors_length =
                ('%sAccessors' % v8_class,
                 'WTF_ARRAY_LENGTH(%sAccessors)' % v8_class)
            if has_accessor_configuration else (0, 0) %}
         {% set methods_name, methods_length =
                ('%sMethods' % v8_class,
                 'WTF_ARRAY_LENGTH(%sMethods)' % v8_class)
            if method_configuration_methods else (0, 0) %}
         {{attributes_name}}, {{attributes_length}},
         {{accessors_name}}, {{accessors_length}},
         {{methods_name}}, {{methods_length}});
-    {% endfilter %}
+    {% endfilter %}{# runtime_enabled_indent #}
 
     {% if constructors or has_custom_constructor or has_event_constructor %}
     functionTemplate->SetCallHandler({{v8_class}}::constructorCallback);
     functionTemplate->SetLength({{interface_length}});
     {% endif %}
     v8::Local<v8::ObjectTemplate> instanceTemplate = functionTemplate->InstanceTemplate();
     ALLOW_UNUSED_LOCAL(instanceTemplate);
     v8::Local<v8::ObjectTemplate> prototypeTemplate = functionTemplate->PrototypeTemplate();
     ALLOW_UNUSED_LOCAL(prototypeTemplate);
     {% if custom_registration_methods %}
     ExecutionContext* context = currentExecutionContext(isolate);
     ALLOW_UNUSED_LOCAL(context);
     {% endif %}
     {% if has_access_check_callbacks %}
     instanceTemplate->SetAccessCheckCallback({{cpp_class}}V8Internal::securityCheck, v8::External::New(isolate, const_cast<WrapperTypeInfo*>(&{{v8_class}}::wrapperTypeInfo)));
     {% endif %}
     {% if has_array_iterator %}
-    {% filter runtime_enabled('RuntimeEnabledFeatures::iterableCollectionsEnabled') %}
+    {% filter runtime_enabled('RuntimeEnabledFeatures::iterableCollectionsEnabled()') %}
     {% if is_global %}
     instanceTemplate->SetIntrinsicDataProperty(v8::Symbol::GetIterator(isolate), v8::kArrayProto_values, v8::DontEnum);
     {% else %}
     prototypeTemplate->SetIntrinsicDataProperty(v8::Symbol::GetIterator(isolate), v8::kArrayProto_values, v8::DontEnum);
     {% endif %}
     {% endfilter %}{# runtime_enabled() #}
     {% endif %}
     {% set runtime_enabled_features = dict() %}
     {% for attribute in attributes
-       if attribute.runtime_enabled_function and
+       if attribute.runtime_enabled_function_only and
           not attribute.exposed_test %}
-        {% if attribute.runtime_enabled_function not in runtime_enabled_features %}
-            {% set unused = runtime_enabled_features.update({attribute.runtime_enabled_function: []}) %}
+        {% if attribute.runtime_enabled_function_only not in runtime_enabled_features %}
+            {% set unused = runtime_enabled_features.update({attribute.runtime_enabled_function_only: []}) %}
         {% endif %}
-        {% set unused = runtime_enabled_features.get(attribute.runtime_enabled_function).append(attribute) %}
+        {% set unused = runtime_enabled_features.get(attribute.runtime_enabled_function_only).append(attribute) %}
     {% endfor %}
     {% for runtime_enabled_feature in runtime_enabled_features | sort %}
-    if ({{runtime_enabled_feature}}()) {
+    if ({{runtime_enabled_feature}}) {
         {% set distinct_attributes = [] %}
         {% for attribute in runtime_enabled_features.get(runtime_enabled_feature) | sort
            if attribute.name not in distinct_attributes %}
         {% set unused = distinct_attributes.append(attribute.name) %}
         {% filter conditional(attribute.conditional_string) %}
+        {% filter experimental_framework_runtime_enabled(attribute.api_experiment_name) %}
         {% if attribute.is_data_type_property %}
         const V8DOMConfiguration::AttributeConfiguration attribute{{attribute.name}}Configuration = \
         {{attribute_configuration(attribute)}};
         V8DOMConfiguration::installAttribute(isolate, instanceTemplate, prototypeTemplate, attribute{{attribute.name}}Configuration);
         {% else %}
         const V8DOMConfiguration::AccessorConfiguration accessor{{attribute.name}}Configuration = \
         {{attribute_configuration(attribute)}};
         V8DOMConfiguration::installAccessor(isolate, instanceTemplate, prototypeTemplate, functionTemplate, defaultSignature, accessor{{attribute.name}}Configuration);
         {% endif %}
         {% endfilter %}
+        {% endfilter %}
         {% endfor %}
     }
     {% endfor %}
+    {% for attribute in attributes

[Daniel Nishi, 2015/12/21 21:20:04]

This catches the case of APIExperimentEnabled, but not RuntimeEnabled. I believe
I missed this case above.

+       if not attribute.runtime_enabled_function_only and
+          not attribute.exposed_test and
+          attribute.api_experiment_name %}
+    {% filter conditional(attribute.conditional_string) %}
+    {% filter experimental_framework_runtime_enabled(attribute.api_experiment_name) %}
+    {% if attribute.is_data_type_property %}
+    const V8DOMConfiguration::AttributeConfiguration attribute{{attribute.name}}Configuration = \
+    {{attribute_configuration(attribute)}};
+    V8DOMConfiguration::installAttribute(isolate, instanceTemplate, prototypeTemplate, attribute{{attribute.name}}Configuration);
+    {% else %}
+    const V8DOMConfiguration::AccessorConfiguration accessor{{attribute.name}}Configuration = \
+    {{attribute_configuration(attribute)}};
+    V8DOMConfiguration::installAccessor(isolate, instanceTemplate, prototypeTemplate, functionTemplate, defaultSignature, accessor{{attribute.name}}Configuration);
+    {% endif %}
+    {% endfilter %}
+    {% endfilter %}
+    {% endfor %}
     {% if constants %}
     {{install_constants() | indent}}
     {% endif %}
     {# Special operations #}
     {% if indexed_property_getter %}
     {{install_indexed_property_handler('instanceTemplate') | indent}}
     {% endif %}
     {% if named_property_getter and not has_named_properties_object %}
     {{install_named_property_handler('instanceTemplate') | indent}}
     {% endif %}
@@ skipping 12 matching lines @@
     {% if interface_name == 'HTMLAllCollection' %}
     {# Needed for legacy support of document.all #}
     functionTemplate->InstanceTemplate()->MarkAsUndetectable();
     {% endif %}
     {% for method in custom_registration_methods %}
     {# install_custom_signature #}
     {% filter conditional(method.conditional_string) %}
     {% filter exposed(method.overloads.exposed_test_all
                       if method.overloads else
                       method.exposed_test) %}
-    {% filter runtime_enabled(method.overloads.runtime_enabled_function_all
-                              if method.overloads else
-                              method.runtime_enabled_function) %}
+    {% set runtime_enabled_function, api_experiment_name = (method.overloads.runtime_enabled_function_all, method.overloads.api_experiment_name_all) if method.overloads
+                       else (method.runtime_enabled_function, method.api_experiment_name) %}
+    {% filter runtime_enabled(runtime_enabled_function) %}
     {% if method.is_do_not_check_security %}
     {{install_do_not_check_security_method(method, '', 'instanceTemplate', 'prototypeTemplate') | indent}}
     {% else %}{# is_do_not_check_security #}
     {% set signature = 'v8::Local<v8::Signature>()' if method.is_do_not_check_signature else 'defaultSignature' %}
     {{install_custom_signature(method, 'instanceTemplate', 'prototypeTemplate', 'functionTemplate', signature) | indent}}
     {% endif %}{# is_do_not_check_security #}
     {% endfilter %}{# runtime_enabled() #}
     {% endfilter %}{# exposed() #}
     {% endfilter %}{# conditional() #}
     {% endfor %}
@@ skipping 29 matching lines @@
 {% endfor %}
 {% for attribute in attributes if attribute.is_implemented_in_private_script %}
 {{attribute_getter_implemented_in_private_script(attribute)}}
 {% if attribute.has_setter %}
 {{attribute_setter_implemented_in_private_script(attribute)}}
 {% endif %}
 {% endfor %}
 {% block partial_interface %}{% endblock %}
 } // namespace blink
 {% endfilter %}