[bindings] partial interfaces should not violate componentization

Source/bindings/templates/interface_base.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file has been auto-generated by {{code_generator}}. DO NOT MODIFY!
 
 #include "config.h"
 {% filter conditional(conditional_string) %}
-#include "{{v8_class}}.h"
+#include "{{actual_v8_class}}.h"
 
-{% for filename in cpp_includes if filename != '%s.h' % v8_class %}
+{% for filename in cpp_includes if filename != '%s.h' % actual_cpp_class %}
 #include "{{filename}}"
 {% endfor %}
 
+{% block initialize_script_wrappable %}{% endblock %}
 namespace blink {
 {% set to_active_dom_object = '%s::toActiveDOMObject' % v8_class
                               if is_active_dom_object else '0' %}
 {% set to_event_target = '%s::toEventTarget' % v8_class
                          if is_event_target else '0' %}
 {% set visit_dom_wrapper = '%s::visitDOMWrapper' % v8_class
                            if has_visit_dom_wrapper else '0' %}
 {% set parent_wrapper_type_info = '&V8%s::wrapperTypeInfo' % parent_interface
                                   if parent_interface else '0' %}
 {% set wrapper_type_prototype = 'WrapperTypeExceptionPrototype' if is_exception else
                                 'WrapperTypeObjectPrototype' %}
 
-const WrapperTypeInfo {{v8_class}}::wrapperTypeInfo = { gin::kEmbedderBlink, {{v8_class}}::domTemplate, {{v8_class}}::refObject, {{v8_class}}::derefObject, {{v8_class}}::createPersistentHandle, {{to_active_dom_object}}, {{to_event_target}}, {{visit_dom_wrapper}}, {{v8_class}}::installConditionallyEnabledMethods, {{v8_class}}::installConditionallyEnabledProperties, {{parent_wrapper_type_info}}, WrapperTypeInfo::{{wrapper_type_prototype}}, WrapperTypeInfo::{{wrapper_class_id}}, WrapperTypeInfo::{{lifetime}}, WrapperTypeInfo::{{gc_type}} };
+{% set wrapper_type_info_type = '' if has_partial_interface else 'const ' %}

[haraken, 2014/10/16 04:24:08]

wrapper_type_info_type => wrapper_type_info_const ?

[tasak, 2014/10/17 07:38:18]

Done.

+{% if not is_partial %}
+{{wrapper_type_info_type}}WrapperTypeInfo {{v8_class}}::wrapperTypeInfo = { gin::kEmbedderBlink, {{v8_class}}::domTemplate, {{v8_class}}::refObject, {{v8_class}}::derefObject, {{v8_class}}::createPersistentHandle, {{to_active_dom_object}}, {{to_event_target}}, {{visit_dom_wrapper}}, {{v8_class}}::installConditionallyEnabledMethods, {{v8_class}}::installConditionallyEnabledProperties, {{parent_wrapper_type_info}}, WrapperTypeInfo::{{wrapper_type_prototype}}, WrapperTypeInfo::{{wrapper_class_id}}, WrapperTypeInfo::{{lifetime}}, WrapperTypeInfo::{{gc_type}} };
 
 {% if is_script_wrappable %}
 // This static member must be declared by DEFINE_WRAPPERTYPEINFO in {{cpp_class}}.h.
 // For details, see the comment of DEFINE_WRAPPERTYPEINFO in
 // bindings/core/v8/ScriptWrappable.h.
 const WrapperTypeInfo& {{cpp_class}}::s_wrapperTypeInfo = {{v8_class}}::wrapperTypeInfo;
 
 {% endif %}
-namespace {{cpp_class}}V8Internal {
+{% endif %}
+namespace {{actual_cpp_class}}V8Internal {
+{% if has_partial_interface %}
+{% for method in methods if method.overloads and method.overloads.has_partial_overloads %}
+static void (*{{method.name}}MethodForPartialInterface)(const v8::FunctionCallbackInfo<v8::Value>&) = 0;
+{% endfor %}
+{% endif %}
 
 {# Constants #}
 {% from 'constants.cpp' import constant_getter_callback
        with context %}
 {% for constant in special_getter_constants %}
 {{constant_getter_callback(constant)}}
 {% endfor %}
 {# Attributes #}
 {% from 'attributes.cpp' import constructor_getter_callback,
        attribute_getter, attribute_getter_callback,
@@ skipping 51 matching lines @@
         exceptionState.throwIfNeeded();
         return;
     }
     {% endif %}
     if (info.This()->IsObject())
         v8::Handle<v8::Object>::Cast(info.This())->ForceSet(name, v8Value);
 }
 
 static void {{cpp_class}}ForceSetAttributeOnThisCallback(v8::Local<v8::String> name, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 {
-    {{cpp_class}}V8Internal::{{cpp_class}}ForceSetAttributeOnThis(name, v8Value, info);
+    {{actual_cpp_class}}V8Internal::{{cpp_class}}ForceSetAttributeOnThis(name, v8Value, info);
 }
 
 {% endif %}
 {% endblock %}
 {##############################################################################}
 {% block security_check_functions %}
 {% if has_access_check_callbacks %}
 bool indexedSecurityCheck(v8::Local<v8::Object> host, uint32_t index, v8::AccessType type, v8::Local<v8::Value>)
 {
     {{cpp_class}}* impl = {{v8_class}}::toImpl(host);
@@ skipping 10 matching lines @@
 {% endblock %}
 {##############################################################################}
 {# Methods #}
 {% from 'methods.cpp' import generate_method, overload_resolution_method,
        method_callback, origin_safe_method_getter, generate_constructor,
        method_implemented_in_private_script
        with context %}
 {% for method in methods %}
 {% if method.should_be_exposed_to_script %}
 {% for world_suffix in method.world_suffixes %}
-{% if not method.is_custom %}
+{% if not method.is_custom and method.visible %}
 {{generate_method(method, world_suffix)}}
 {% endif %}
-{% if method.overloads %}
+{% if method.overloads and method.overloads.visible %}
 {{overload_resolution_method(method.overloads, world_suffix)}}
 {% endif %}
 {% if not method.overload_index or method.overloads %}
+{# If overloads_callback_visible_in_partial is True, method callback #}

[haraken, 2014/10/16 04:24:08]

What is overloads_callback_visible_in_partial?

[tasak, 2014/10/17 07:38:18]

Removed.

+{# function used by installAttribute is generated in this partial interface. #}
+{# Otherwise, not generated. Because only 1 callback is available for
+{# each method. #}
+{% if (method.overloads and method.overloads.visible and
+        (not method.overloads.has_partial_overloads or not is_partial)) or
+      (not method.overloads and method.visible) %}

[haraken, 2014/10/16 04:24:08]

Discussed offline and I finally understood what this condition means. Let's add
more comments. In particular, I'd like to have a very good comment about when
method.visible, method.overloads.visible, method.overloads.has_partial_overloads
etc become true.

[tasak, 2014/10/17 07:38:18]

https://docs.google.com/document/d/1qBC7Therp437Jbt_QYAtNYMZs6zQ_7_tnMkNUG_AC...

 {# A single callback is generated for overloaded methods #}
+{# with considering partial overloads #}
 {{method_callback(method, world_suffix)}}
 {% endif %}
-{% if method.is_do_not_check_security %}
+{% endif %}
+{% if method.is_do_not_check_security and method.visible %}
 {{origin_safe_method_getter(method, world_suffix)}}
 {% endif %}
 {% endfor %}
 {% endif %}
 {% endfor %}
 {% if iterator_method %}
 {{generate_method(iterator_method)}}
 {{method_callback(iterator_method)}}
 {% endif %}
 {% block origin_safe_method_setter %}{% endblock %}
@@ skipping 13 matching lines @@
 {% block named_property_getter %}{% endblock %}
 {% block named_property_getter_callback %}{% endblock %}
 {% block named_property_setter %}{% endblock %}
 {% block named_property_setter_callback %}{% endblock %}
 {% block named_property_query %}{% endblock %}
 {% block named_property_query_callback %}{% endblock %}
 {% block named_property_deleter %}{% endblock %}
 {% block named_property_deleter_callback %}{% endblock %}
 {% block named_property_enumerator %}{% endblock %}
 {% block named_property_enumerator_callback %}{% endblock %}
-} // namespace {{cpp_class}}V8Internal
+} // namespace {{actual_cpp_class}}V8Internal
 
 {% block visit_dom_wrapper %}{% endblock %}
 {% block shadow_attributes %}{% endblock %}
 {##############################################################################}
 {% block install_attributes %}
+{% from 'attributes.cpp' import attribute_configuration with context %}
 {% if has_attribute_configuration %}
 static const V8DOMConfiguration::AttributeConfiguration {{v8_class}}Attributes[] = {
     {% for attribute in attributes
        if not (attribute.is_expose_js_accessors or
                attribute.is_static or
                attribute.runtime_enabled_function or
                attribute.per_context_enabled_function or
                attribute.exposed_test or
                (interface_name == 'Window' and attribute.is_unforgeable))
            and attribute.should_be_exposed_to_script %}
     {% filter conditional(attribute.conditional_string) %}
     {{attribute_configuration(attribute)}},
     {% endfilter %}
     {% endfor %}
 };
 
 {% endif %}
 {% endblock %}
 {##############################################################################}
 {% block install_accessors %}
+{% from 'attributes.cpp' import attribute_configuration with context %}
 {% if has_accessors %}
 static const V8DOMConfiguration::AccessorConfiguration {{v8_class}}Accessors[] = {
     {% for attribute in attributes if attribute.is_expose_js_accessors and attribute.should_be_exposed_to_script %}
     {{attribute_configuration(attribute)}},
     {% endfor %}
 };
 
 {% endif %}
 {% endblock %}
 {##############################################################################}
@@ skipping 11 matching lines @@
 {% endif %}
 {% endblock %}
 {##############################################################################}
 {% block named_constructor %}{% endblock %}
 {% block initialize_event %}{% endblock %}
 {% block constructor_callback %}{% endblock %}
 {% block configure_shadow_object_template %}{% endblock %}
 {##############################################################################}
 {% block install_dom_template %}
 {% from 'methods.cpp' import install_custom_signature with context %}
+{% from 'attributes.cpp' import attribute_configuration with context %}
 {% from 'constants.cpp' import install_constants with context %}
+{% if has_partial_interface or is_partial %}
+void {{actual_v8_class}}::install{{v8_class}}Template(v8::Handle<v8::FunctionTemplate> functionTemplate, v8::Isolate* isolate)
+{% else %}
 static void install{{v8_class}}Template(v8::Handle<v8::FunctionTemplate> functionTemplate, v8::Isolate* isolate)
+{% endif %}
 {
+    {% if is_partial %}
+    {{v8_class}}::install{{v8_class}}Template(functionTemplate, isolate);
+    {% else %}
     functionTemplate->ReadOnlyPrototype();
+    {% endif %}
 
     v8::Local<v8::Signature> defaultSignature;
     {% set parent_template =
            'V8%s::domTemplate(isolate)' % parent_interface
            if parent_interface else 'v8::Local<v8::FunctionTemplate>()' %}
     {% if runtime_enabled_function %}
     if (!{{runtime_enabled_function}}())
         defaultSignature = V8DOMConfiguration::installDOMClassTemplate(functionTemplate, "", {{parent_template}}, {{v8_class}}::internalFieldCount, 0, 0, 0, 0, 0, 0, isolate);
     else
     {% endif %}
@@ skipping 45 matching lines @@
         static const V8DOMConfiguration::AttributeConfiguration attributeConfiguration =\
         {{attribute_configuration(attribute)}};
         V8DOMConfiguration::installAttribute(instanceTemplate, prototypeTemplate, attributeConfiguration, isolate);
     }
     {% endfilter %}
     {% endfor %}
     {% if constants %}
     {{install_constants() | indent}}
     {% endif %}
     {# Special operations #}
-    {# V8 has access-check callback API and it's used on Window instead of
+    {# V8 has access-check callback API and it\'s used on Window instead of
        deleters or enumerators; see ObjectTemplate::SetAccessCheckCallbacks.
        In addition, the getter should be set on the prototype template, to get
        the implementation straight out of the Window prototype, regardless of
        what prototype is actually set on the object. #}
     {% set set_on_template = 'PrototypeTemplate' if interface_name == 'Window'
                         else 'InstanceTemplate' %}
     {% if indexed_property_getter %}
     {# if have indexed properties, MUST have an indexed property getter #}
     {% set indexed_property_getter_callback =
            '%sV8Internal::indexedPropertyGetterCallback' % cpp_class %}
@@ skipping 21 matching lines @@
            if named_property_getter.is_enumerable else '0' %}
     {% set named_property_deleter_callback =
            '%sV8Internal::namedPropertyDeleterCallback' % cpp_class
            if named_property_deleter else '0' %}
     {% set named_property_enumerator_callback =
            '%sV8Internal::namedPropertyEnumeratorCallback' % cpp_class
            if named_property_getter.is_enumerable else '0' %}
     functionTemplate->{{set_on_template}}()->SetNamedPropertyHandler({{named_property_getter_callback}}, {{named_property_setter_callback}}, {{named_property_query_callback}}, {{named_property_deleter_callback}}, {{named_property_enumerator_callback}});
     {% endif %}
     {% if iterator_method %}
-    static const V8DOMConfiguration::SymbolKeyedMethodConfiguration symbolKeyedIteratorConfiguration = { v8::Symbol::GetIterator, {{cpp_class}}V8Internal::iteratorMethodCallback, 0, V8DOMConfiguration::ExposedToAllScripts };
+    static const V8DOMConfiguration::SymbolKeyedMethodConfiguration symbolKeyedIteratorConfiguration = { v8::Symbol::GetIterator, {{actual_cpp_class}}V8Internal::iteratorMethodCallback, 0, V8DOMConfiguration::ExposedToAllScripts };
     V8DOMConfiguration::installMethod(prototypeTemplate, defaultSignature, v8::DontDelete, symbolKeyedIteratorConfiguration, isolate);
     {% endif %}
     {# End special operations #}
     {% if has_custom_legacy_call_as_function %}
     functionTemplate->InstanceTemplate()->SetCallAsFunctionHandler({{v8_class}}::legacyCallCustom);
     {% endif %}
     {% if interface_name == 'HTMLAllCollection' %}
     {# Needed for legacy support of document.all #}
     functionTemplate->InstanceTemplate()->MarkAsUndetectable();
     {% endif %}
@@ skipping 12 matching lines @@
     {% endfilter %}{# conditional() #}
     {% endfor %}
     {% for attribute in attributes if attribute.is_static %}
     {% set getter_callback = '%sV8Internal::%sAttributeGetterCallback' %
            (cpp_class, attribute.name) %}
     {% filter conditional(attribute.conditional_string) %}
     functionTemplate->SetNativeDataProperty(v8AtomicString(isolate, "{{attribute.name}}"), {{getter_callback}}, {{attribute.setter_callback}}, v8::External::New(isolate, 0), static_cast<v8::PropertyAttribute>(v8::None), v8::Handle<v8::AccessorSignature>(), static_cast<v8::AccessControl>(v8::DEFAULT));
     {% endfilter %}
     {% endfor %}
     {# Special interfaces #}
+    {% if not is_partial %}

[haraken, 2014/10/16 04:24:08]

Do we need this check?

[tasak, 2014/10/17 07:38:18]

Yes, because interface_name is 'Window' when generating V8WindowPartial.cpp.

     {% if interface_name == 'Window' %}
 
     prototypeTemplate->SetInternalFieldCount(V8Window::internalFieldCount);
     functionTemplate->SetHiddenPrototype(true);
     instanceTemplate->SetInternalFieldCount(V8Window::internalFieldCount);
     // Set access check callbacks, but turned off initially.
     // When a context is detached from a frame, turn on the access check.
     // Turning on checks also invalidates inline caches of the object.
     instanceTemplate->SetAccessCheckCallbacks(V8Window::namedSecurityCheckCustom, V8Window::indexedSecurityCheckCustom, v8::External::New(isolate, const_cast<WrapperTypeInfo*>(&V8Window::wrapperTypeInfo)), false);
     {% elif interface_name in [
            'HTMLDocument', 'DedicatedWorkerGlobalScope',
            'SharedWorkerGlobalScope', 'ServiceWorkerGlobalScope'] %}
     functionTemplate->SetHiddenPrototype(true);
     {% endif %}
 
     // Custom toString template
     functionTemplate->Set(v8AtomicString(isolate, "toString"), V8PerIsolateData::from(isolate)->toStringTemplate());
+    {% endif %}
 }
 
 {% endblock %}
 {##############################################################################}
 {% block get_dom_template %}{% endblock %}
 {% block has_instance %}{% endblock %}
 {% block to_impl_with_type_check %}{% endblock %}
 {##############################################################################}
 {% block install_conditional_attributes %}
-{% if has_conditional_attributes %}
-void {{v8_class}}::installConditionallyEnabledProperties(v8::Handle<v8::Object> instanceObject, v8::Isolate* isolate)
-{
-    v8::Local<v8::Object> prototypeObject = v8::Local<v8::Object>::Cast(instanceObject->GetPrototype());
-    ExecutionContext* context = toExecutionContext(prototypeObject->CreationContext());
-
-    {% for attribute in attributes if attribute.per_context_enabled_function or attribute.exposed_test %}
-    {% filter per_context_enabled(attribute.per_context_enabled_function) %}
-    {% filter exposed(attribute.exposed_test) %}
-    static const V8DOMConfiguration::AttributeConfiguration attributeConfiguration =\
-    {{attribute_configuration(attribute)}};
-    V8DOMConfiguration::installAttribute(instanceObject, prototypeObject, attributeConfiguration, isolate);
-    {% endfilter %}
-    {% endfilter %}
-    {% endfor %}
-}
+{% from 'attributes.cpp' import install_conditionally_enabled_properties
+        with context %}
+{% if is_partial or has_conditional_attributes %}

[haraken, 2014/10/16 04:24:08]

Not related to your CL, |has_conditional_attributes| should be renamed to
|conditionally_enabled_properties| (for consistency with
|conditionally_enabled_methods|).

[tasak, 2014/10/17 07:38:18]

I will do in another CL.

+{{install_conditionally_enabled_properties()}}
 
 {% endif %}
 {% endblock %}
 {##############################################################################}
 {% block install_conditional_methods %}
-{% if conditionally_enabled_methods %}
-void {{v8_class}}::installConditionallyEnabledMethods(v8::Handle<v8::Object> prototypeObject, v8::Isolate* isolate)
-{
-    {# Define per-context enabled operations #}
-    v8::Local<v8::Signature> defaultSignature = v8::Signature::New(isolate, domTemplate(isolate));
-    ExecutionContext* context = toExecutionContext(prototypeObject->CreationContext());
-    ASSERT(context);
-
-    {% for method in conditionally_enabled_methods %}
-    {% filter per_context_enabled(method.per_context_enabled_function) %}
-    {% filter exposed(method.exposed_test) %}
-    prototypeObject->Set(v8AtomicString(isolate, "{{method.name}}"), v8::FunctionTemplate::New(isolate, {{cpp_class}}V8Internal::{{method.name}}MethodCallback, v8Undefined(), defaultSignature, {{method.number_of_required_arguments}})->GetFunction());
-    {% endfilter %}
-    {% endfilter %}
-    {% endfor %}
-}
+{% from 'methods.cpp' import install_conditionally_enabled_methods
+        with context %}
+{% if is_partial or conditionally_enabled_methods %}
+{{install_conditionally_enabled_methods()}}
 
 {% endif %}
 {% endblock %}
 {##############################################################################}
 {% block to_active_dom_object %}{% endblock %}
 {% block to_event_target %}{% endblock %}
 {% block get_shadow_object_template %}{% endblock %}
 {% block wrap %}{% endblock %}
 {% block create_wrapper %}{% endblock %}
 {% block deref_object_and_to_v8_no_inline %}{% endblock %}
 {% for method in methods if method.is_implemented_in_private_script %}
 {{method_implemented_in_private_script(method)}}
 {% endfor %}
 {% for attribute in attributes if attribute.is_implemented_in_private_script %}
 {{attribute_getter_implemented_in_private_script(attribute)}}
 {% if not attribute.is_read_only or attribute.put_forwards %}
 {{attribute_setter_implemented_in_private_script(attribute)}}
 {% endif %}
 {% endfor %}
+{% block partial_interface %}{% endblock %}
 } // namespace blink
 {% endfilter %}