[Bindings] Refactoring of binding code around runtime enabled features

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

 {% filter format_blink_cpp_source_code %}
 
 {% include 'copyright_block.txt' %}
 #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 409 matching lines @@
   // Global object prototype chain consists of Immutable Prototype Exotic Objects
   prototypeTemplate->SetImmutableProto();
   {% endif %}
 
   {% if is_global %}
   // Global objects are Immutable Prototype Exotic Objects
   instanceTemplate->SetImmutableProto();
   {% endif %}
 
   // Register DOM constants, attributes and operations.
-  {% filter runtime_enabled(runtime_enabled_function) %}
+  {% filter runtime_enabled(runtime_enabled_feature_name) %}
   {% if constants %}
   {{install_constants() | indent(2)}}
   {% endif %}
   {% if data_attributes %}
   V8DOMConfiguration::installAttributes(isolate, world, instanceTemplate, prototypeTemplate, {{'%sAttributes' % v8_class}}, {{'WTF_ARRAY_LENGTH(%sAttributes)' % v8_class}});
   {% endif %}
   {% if lazy_data_attributes %}
   V8DOMConfiguration::installLazyDataAttributes(isolate, world, instanceTemplate, prototypeTemplate, {{'%sLazyDataAttributes' % v8_class}}, {{'WTF_ARRAY_LENGTH(%sLazyDataAttributes)' % v8_class}});
   {% endif %}
   {% if accessors %}
   V8DOMConfiguration::installAccessors(isolate, world, instanceTemplate, prototypeTemplate, interfaceTemplate, signature, {{'%sAccessors' % v8_class}}, {{'WTF_ARRAY_LENGTH(%sAccessors)' % v8_class}});
   {% endif %}
   {% if methods | has_method_configuration(is_partial) %}
   V8DOMConfiguration::installMethods(isolate, world, instanceTemplate, prototypeTemplate, interfaceTemplate, signature, {{'%sMethods' % v8_class}}, {{'WTF_ARRAY_LENGTH(%sMethods)' % v8_class}});
   {% endif %}
   {% endfilter %}
 
   {% if has_access_check_callbacks and not is_partial %}
   // Cross-origin access check
   {% set cross_origin_named_getter = '%sV8Internal::crossOriginNamedGetter' % cpp_class if has_cross_origin_named_getter else 'nullptr' %}
   {% set cross_origin_named_setter = '%sV8Internal::crossOriginNamedSetter' % cpp_class if has_cross_origin_named_setter else 'nullptr' %}
   {% set cross_origin_named_enumerator = '%sV8Internal::crossOriginNamedEnumerator' % cpp_class if has_cross_origin_named_enumerator else 'nullptr' %}
   {% set cross_origin_indexed_getter = '%sV8Internal::crossOriginIndexedGetter' % cpp_class if has_cross_origin_indexed_getter else 'nullptr' %}
   instanceTemplate->SetAccessCheckCallbackAndHandler({{cpp_class}}V8Internal::securityCheck, v8::NamedPropertyHandlerConfiguration({{cross_origin_named_getter}}, {{cross_origin_named_setter}}, nullptr, nullptr, {{cross_origin_named_enumerator}}), v8::IndexedPropertyHandlerConfiguration({{cross_origin_indexed_getter}}), v8::External::New(isolate, const_cast<WrapperTypeInfo*>(&{{v8_class}}::wrapperTypeInfo)));
   {% endif %}
 
-  {% for group in runtime_enabled_attributes | groupby('runtime_feature_name') %}
-  if ({{group.list[0].runtime_enabled_function}}()) {
-    {% for attribute in group.list | unique_by('name') | sort %}
-    {% if attribute.is_data_type_property %}
-    const V8DOMConfiguration::AttributeConfiguration attribute{{attribute.name}}Configuration = {{attribute_configuration(attribute)}};
-    V8DOMConfiguration::installAttribute(isolate, world, instanceTemplate, prototypeTemplate, attribute{{attribute.name}}Configuration);
-    {% else %}
-    const V8DOMConfiguration::AccessorConfiguration accessor{{attribute.name}}Configuration = {{attribute_configuration(attribute)}};
-    V8DOMConfiguration::installAccessor(isolate, world, instanceTemplate, prototypeTemplate, interfaceTemplate, signature, accessor{{attribute.name}}Configuration);
-    {% endif %}
-    {% endfor %}
-  }
+  {% for group in runtime_enabled_attributes | groupby('runtime_enabled_feature_name') %}
+  {% filter runtime_enabled(group.list[0].runtime_enabled_feature_name) %}
+  {% for attribute in group.list | unique_by('name') | sort %}
+  {% if attribute.is_data_type_property %}
+  const V8DOMConfiguration::AttributeConfiguration attribute{{attribute.name}}Configuration = {{attribute_configuration(attribute)}};
+  V8DOMConfiguration::installAttribute(isolate, world, instanceTemplate, prototypeTemplate, attribute{{attribute.name}}Configuration);
+  {% else %}
+  const V8DOMConfiguration::AccessorConfiguration accessor{{attribute.name}}Configuration = {{attribute_configuration(attribute)}};
+  V8DOMConfiguration::installAccessor(isolate, world, instanceTemplate, prototypeTemplate, interfaceTemplate, signature, accessor{{attribute.name}}Configuration);
+  {% endif %}
+  {% endfor %}
+  {% endfilter %}
   {% endfor %}
 
   {% if (indexed_property_getter or named_property_getter) and not is_partial %}
   // Indexed properties
   {{install_indexed_property_handler('instanceTemplate') | indent(2)}}
   {% endif %}
   {% if named_property_getter and not is_partial and not has_named_properties_object %}
   // Named properties
   {{install_named_property_handler('instanceTemplate') | indent(2)}}
   {% endif %}
 
   {% if has_array_iterator and not is_partial %}
   // Array iterator (@@iterator)
   {%+ if is_global %}instanceTemplate{% else %}prototypeTemplate{% endif %}->SetIntrinsicDataProperty(v8::Symbol::GetIterator(isolate), v8::kArrayProto_values, v8::DontEnum);
   {% endif %}
 
   {% if iterator_method %}
   {% filter exposed(iterator_method.exposed_test) %}
-  {% filter runtime_enabled(iterator_method.runtime_enabled_function) %}
+  {% filter runtime_enabled(iterator_method.runtime_enabled_feature_name) %}
   // Iterator (@@iterator)
   const V8DOMConfiguration::SymbolKeyedMethodConfiguration symbolKeyedIteratorConfiguration = { v8::Symbol::GetIterator, {{cpp_class_or_partial}}V8Internal::iteratorMethodCallback, 0, v8::DontEnum, V8DOMConfiguration::OnPrototype };
   V8DOMConfiguration::installMethod(isolate, world, prototypeTemplate, signature, symbolKeyedIteratorConfiguration);
   {% endfilter %}
   {% endfilter %}
   {% endif %}
 
   {% if legacy_caller and not is_partial %}
   instanceTemplate->SetCallAsFunctionHandler({{cpp_class_or_partial}}V8Internal::{{legacy_caller.name}}MethodCallback);
   {% elif has_custom_legacy_call_as_function and not is_partial %}
   instanceTemplate->SetCallAsFunctionHandler({{v8_class}}::legacyCallCustom);
   {% endif %}
 
   {% if interface_name == 'HTMLAllCollection' and not is_partial %}
   // Needed for legacy support of document.all
   instanceTemplate->MarkAsUndetectable();
   {% endif %}
 
   {% if methods | custom_registration(is_partial) %}
   {% for method in methods | custom_registration(is_partial) %}
   {# install_custom_signature #}
   {% 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 runtime_enabled(method.overloads.runtime_enabled_all
+                            if method.overloads else method.runtime_enabled_feature_name) %}
   {% if method.is_cross_origin %}
   {# TODO(dcheng): Currently, bindings must create a function object for each
      realm as a hack to support the incumbent realm. Remove this when Blink
      properly supports the incumbent realm. #}
   {{install_origin_safe_method(method, '', 'instanceTemplate', 'prototypeTemplate') | indent(2)}}
   {% else %}
   {{install_custom_signature(method, 'instanceTemplate', 'prototypeTemplate', 'interfaceTemplate', 'signature') | indent(2)}}
   {% endif %}
   {% endfilter %}
   {% endfilter %}
@@ skipping 61 matching lines @@
 {% block has_instance %}{% endblock %}
 {% block to_impl %}{% endblock %}
 {% block to_impl_with_type_check %}{% endblock %}
 {##############################################################################}
 {% block prepare_prototype_and_interface_object %}{% endblock %}
 {##############################################################################}
 {% block partial_interface %}{% endblock %}
 }  // namespace blink
 
 {% endfilter %}{# format_blink_cpp_source_code #}