[bindings] Implement an ExperimentEnabled IDL extended attribute.

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

 {% from 'conversions.cpp' import declare_enum_validation_variable, v8_value_to_local_cpp_value %}
 
 
 {##############################################################################}
 {% macro generate_method(method, world_suffix) %}
 {% filter conditional(method.conditional_string) %}
 {% if method.returns_promise and method.has_exception_state %}
 static void {{method.name}}{{method.overload_index}}Method{{world_suffix}}Promise(const v8::FunctionCallbackInfo<v8::Value>& info, ExceptionState& exceptionState)
 {% else %}
 static void {{method.name}}{{method.overload_index}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info)
@@ skipping 348 matching lines @@
 createMinimumArityTypeErrorForMethod(info.GetIsolate(), "{{method.name}}", "{{interface_name}}", {{number_of_required_arguments}}, info.Length())
 {%- endif %}
 {%- endmacro %}
 
 
 {##############################################################################}
 {% macro runtime_determined_length_method(overloads) %}
 static int {{overloads.name}}MethodLength()
 {
     {% for length, runtime_enabled_functions in overloads.runtime_determined_lengths %}
-    {% for runtime_enabled_function in runtime_enabled_functions %}
+{% for runtime_enabled_function in runtime_enabled_functions %}
     {% filter runtime_enabled(runtime_enabled_function) %}
     return {{length}};
     {% endfilter %}
     {% endfor %}
     {% endfor %}
 }
 {% endmacro %}
 
 
 {##############################################################################}
@@ skipping 30 matching lines @@
     switch (std::min({{overloads.maxarg}}, info.Length())) {
     {# 3. Remove from S all entries whose type list is not of length argcount. #}
     {% for length, tests_methods in overloads.length_tests_methods %}
     {# 10. If i = d, then: #}
     case {{length}}:
         {# Then resolve by testing argument #}
         {% for test, method in tests_methods %}
         {% if method.visible %}
         {% filter runtime_enabled(not overloads.runtime_enabled_function_all and
                                   method.runtime_enabled_function) %}
+        {% filter api_experiment_enabled(not overloads.api_experiment_name_all and
+                                     method.api_experiment_name) %}

[haraken, 2015/12/18 02:35:51]

Ditto. Want to avoid the code duplication.

[Daniel Nishi, 2015/12/18 05:11:42]

Hm. The (not x_all and x) logic on this particular one is dense enough that I'm
not sure I can solve the duplication without overcomplicating it. Unlike the
other two, it doesn't share the method.overloads check.

[haraken, 2015/12/18 05:20:03]

BTW, do we really need to differentiate [APIExperimentEnabled] from
[RuntimeEnabled]? From the perspective that it is a mechanism to conditionally
enable DOM features, these two are the same thing.

Just an idea but would it be possible to implement the API-experiment on top of
the existing mechanism of RuntimeEnabledFeatures? For example, you can introduce
status=api-experiment to RuntimeEnabledFeature.in.

https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

         if ({{test}}) {
             {% if method.measure_as and not overloads.measure_all_as %}
             UseCounter::countIfNotPrivateScript(info.GetIsolate(), callingExecutionContext(info.GetIsolate()), UseCounter::{{method.measure_as('Method')}});
             {% endif %}
             {% if method.deprecate_as and not overloads.deprecate_all_as %}
             UseCounter::countDeprecationIfNotPrivateScript(info.GetIsolate(), callingExecutionContext(info.GetIsolate()), UseCounter::{{method.deprecate_as}});
             {% endif %}
             {{method.name}}{{method.overload_index}}Method{{world_suffix}}(info);
             return;
         }
         {% endfilter %}
+        {% endfilter %}
         {% endif %}
         {% endfor %}
         break;
     {% endfor %}
     {% if is_partial or not overloads.has_partial_overloads %}
     default:
         {# If methods are overloaded between interface and partial interface #}
         {# definitions, need to invoke methods defined in the partial #}
         {# interface. #}
         {# FIXME: we do not need to always generate this code. #}
@@ skipping 259 matching lines @@
 v8::Local<v8::Signature> defaultSignature = v8::Signature::New(isolate, domTemplate(isolate));
 ExecutionContext* executionContext = toExecutionContext(prototypeObject->CreationContext());
 ASSERT(executionContext);
 {% for method in conditionally_enabled_methods %}
 {% 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) %}
+{% filter api_experiment_enabled(method.overloads.api_experiment_name_all
+                        if method.overloads else
+                        method.api_experiment_name) %}

[haraken, 2015/12/18 02:35:51]

Ditto. Want to avoid the code duplication.

[Daniel Nishi, 2015/12/18 05:11:42]

Done in the same manner w/ sharing the method.overloads logic and sharing logic
between the filters.

 const V8DOMConfiguration::MethodConfiguration {{method.name}}MethodConfiguration = {{method_configuration(method)}};
 V8DOMConfiguration::installMethod(isolate, v8::Local<v8::Object>(), prototypeObject, interfaceObject, defaultSignature, {{method.name}}MethodConfiguration);
+{% endfilter %}{# api_experiment_enabled() #}
 {% endfilter %}{# runtime_enabled() #}
 {% endfilter %}{# exposed() #}
 {% endfor %}
 {% endif %}
 {%- endmacro %}