[Bindings] Code cleanup: Early return if funtime enabled interface is false

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 387 matching lines @@
          if has_named_properties_object else
          'V8%s::domTemplate(isolate, world)' % parent_interface
          if parent_interface else
          'v8::Local<v8::FunctionTemplate>()' %}
   V8DOMConfiguration::initializeDOMInterfaceTemplate(isolate, interfaceTemplate, {{v8_class}}::wrapperTypeInfo.interfaceName, {{parent_interface_template}}, {{v8_class}}::internalFieldCount);
   {% if constructors or has_custom_constructor or has_event_constructor or has_html_constructor %}
   interfaceTemplate->SetCallHandler({{v8_class}}::constructorCallback);
   interfaceTemplate->SetLength({{interface_length}});
   {% endif %}
   {% endif %}{# is_partial #}
+
+  {% if runtime_enabled_feature_name %}
+  if (!{{runtime_enabled_feature_name | runtime_enabled_function}}) {

[Yuki, 2017/01/13 02:38:37]

This is okay, but I guess you should be able to write:
  if (!{{is_runtime_enabled(runtime_enabled_feature_name)}}) {
  }
They're equivalent, though.

[Yuki, 2017/01/13 02:38:37]

If the feature is disabled, we shouldn't hit this line.  Do you have any clues
why we're calling V8Type::installTypeTemplate() even when Type is disabled?  Who
is calling the function?

[peria, 2017/01/13 05:54:26]

V8Type::domTemplate() calls it through V8DOMConfiguration::domClassTemplate(),
and domTemplate()'s caller is handler of V8Type::wrapperTypeInfo.

So if we want to avoid calling V8Type::installV8TypeTemplate()
depending on runtime enabled flags, we need to make a branch in
V8Type::domTemplate().

[peria, 2017/01/13 05:54:26]

As a context of Jinja, I think it better to make the content of
|runtime_enabled_feature_name| (e.g. "FooBar") to be the function name (e.g.
"RuntimeEnabledFeatures::fooBarEnabled()").

+    return;
+  }
+  {% endif %}
+
   v8::Local<v8::Signature> signature = v8::Signature::New(isolate, interfaceTemplate);
   ALLOW_UNUSED_LOCAL(signature);
   v8::Local<v8::ObjectTemplate> instanceTemplate = interfaceTemplate->InstanceTemplate();
   ALLOW_UNUSED_LOCAL(instanceTemplate);
   v8::Local<v8::ObjectTemplate> prototypeTemplate = interfaceTemplate->PrototypeTemplate();
   ALLOW_UNUSED_LOCAL(prototypeTemplate);
 
   {% if interface_name == 'Window' and not is_partial %}
   prototypeTemplate->SetInternalFieldCount(V8Window::internalFieldCount);
   {% endif %}
 
   {% if is_immutable_prototype %}
   // 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_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_enabled_feature_name') %}
-  {% filter runtime_enabled(group.list[0].runtime_enabled_feature_name) %}
-  {% for attribute in group.list | unique_by('name') | sort %}
+  {% for feature_name, attribute_list in runtime_enabled_attributes | groupby('runtime_enabled_feature_name') %}
+  {% filter runtime_enabled(feature_name) %}
+  {% for attribute in attribute_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 %}
@@ skipping 179 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 #}