[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 11 matching lines @@
 {% endmacro %}
 
 
 {##############################################################################}
 {# FIXME: We should return a rejected Promise if an error occurs in this
 function when ALL methods in this overload return Promise. In order to do so,
 we must ensure either ALL or NO methods in this overload return Promise #}
 {% macro overload_resolution_method(overloads, world_suffix) %}
 static void {{overloads.name}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
+    String errorMessage;
+    ALLOW_UNUSED_LOCAL(errorMessage);
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "{{overloads.name}}", "{{interface_name}}", info.Holder(), info.GetIsolate());
     {% if overloads.measure_all_as %}
     UseCounter::countIfNotPrivateScript(info.GetIsolate(), callingExecutionContext(info.GetIsolate()), UseCounter::{{overloads.measure_all_as}});
     {% endif %}
     {% if overloads.deprecate_all_as %}
     UseCounter::countDeprecationIfNotPrivateScript(info.GetIsolate(), callingExecutionContext(info.GetIsolate()), UseCounter::{{overloads.deprecate_all_as}});
     {% endif %}
     {# First resolve by length #}
     {# 2. Initialize argcount to be min(maxarg, n). #}
     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 experiment_enabled(not overloads.experimental_api_name_all and
+                                     method.experimental_api_name, "errorMessage") %}
         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 252 matching lines @@
 V8DOMConfiguration::installMethod(isolate, {{instance_template}}, {{prototype_template}}, {{interface_template}}, {{signature}}, {{method.name}}MethodConfiguration);
 {%- endmacro %}
 
 {######################################}
 {% macro install_conditionally_enabled_methods() %}
 {% if conditionally_enabled_methods %}
 {# Define operations with limited exposure #}
 v8::Local<v8::Signature> defaultSignature = v8::Signature::New(isolate, domTemplate(isolate));
 ExecutionContext* executionContext = toExecutionContext(prototypeObject->CreationContext());
 ASSERT(executionContext);
+String errorMessage;
+ALLOW_UNUSED_LOCAL(errorMessage);
 {% 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 experiment_enabled(method.overloads.experimental_api_name_all
+                        if method.overloads else
+                        method.experimental_api_name, "errorMessage") %}
 const V8DOMConfiguration::MethodConfiguration {{method.name}}MethodConfiguration = {{method_configuration(method)}};
 V8DOMConfiguration::installMethod(isolate, v8::Local<v8::Object>(), prototypeObject, interfaceObject, defaultSignature, {{method.name}}MethodConfiguration);
+{% endfilter %}{# experiment_enabled() #}
 {% endfilter %}{# runtime_enabled() #}
 {% endfilter %}{# exposed() #}
 {% endfor %}
 {% endif %}
 {%- endmacro %}