[bindings] partial interfaces should not violate componentization

Source/bindings/templates/attributes.cpp

 {##############################################################################}
 {% macro attribute_getter(attribute, world_suffix) %}
 {% filter conditional(attribute.conditional_string) %}
 static void {{attribute.name}}AttributeGetter{{world_suffix}}(
 {%- if attribute.is_expose_js_accessors %}
 const v8::FunctionCallbackInfo<v8::Value>& info
 {%- else %}
 const v8::PropertyCallbackInfo<v8::Value>& info
 {%- endif %})
 {
@@ skipping 147 matching lines @@
     {% if attribute.activity_logging_world_check %}
     if (scriptState->world().isIsolatedWorld() && contextData && contextData->activityLogger())
     {% else %}
     if (contextData && contextData->activityLogger())
     {% endif %}
         contextData->activityLogger()->logGetter("{{interface_name}}.{{attribute.name}}");
     {% endif %}
     {% if attribute.has_custom_getter %}
     {{v8_class}}::{{attribute.name}}AttributeGetterCustom(info);
     {% else %}
+    {% if is_partial %}
+    {{cpp_class}}PartialV8Internal::{{attribute.name}}AttributeGetter{{world_suffix}}(info);
+    {% else %}
     {{cpp_class}}V8Internal::{{attribute.name}}AttributeGetter{{world_suffix}}(info);
     {% endif %}
+    {% endif %}
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 {% endfilter %}
 {% endmacro %}
 
 
 {##############################################################################}
 {% macro constructor_getter_callback(attribute, world_suffix) %}
 {% filter conditional(attribute.conditional_string) %}
 static void {{attribute.name}}ConstructorGetterCallback{{world_suffix}}(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter");
     {% if attribute.deprecate_as %}
     UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::{{attribute.deprecate_as}});
     {% endif %}
     {% if attribute.measure_as %}
     UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::{{attribute.measure_as}});
     {% endif %}
+    {% if is_partial %}
+    {{cpp_class}}PartialV8Internal::{{cpp_class}}ConstructorGetter{{world_suffix}}(property, info);

[haraken, 2014/10/09 04:24:00]

Is it possible that a partial interface has a constructor?

[tasak, 2014/10/10 07:52:23]

This code is used for ServiceWorker, i.e.:

partial interface ServiceWorkerGlobalScope {
    [RuntimeEnabled=EncodingAPI] attribute TextDecoderConstructor TextDecoder;
    [RuntimeEnabled=EncodingAPI] attribute TextEncoderConstructor TextEncoder;
...
};

c.f. gen/blink/bindings/modules/ServiceWorkerGlobalScopeModulesConstructors.idl

+    {% else %}
     {{cpp_class}}V8Internal::{{cpp_class}}ConstructorGetter{{world_suffix}}(property, info);
+    {% endif %}
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 {% endfilter %}
 {% endmacro %}
 
 
 {##############################################################################}
 {% macro attribute_setter(attribute, world_suffix) %}
 {% filter conditional(attribute.conditional_string) %}
 static void {{attribute.name}}AttributeSetter{{world_suffix}}(
@@ skipping 116 matching lines @@
     {% endif %}
         contextData->activityLogger()->logSetter("{{interface_name}}.{{attribute.name}}", v8Value);
     }
     {% endif %}
     {% if attribute.is_custom_element_callbacks or attribute.is_reflect %}
     CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
     {% endif %}
     {% if attribute.has_custom_setter %}
     {{v8_class}}::{{attribute.name}}AttributeSetterCustom(v8Value, info);
     {% else %}
+    {% if is_partial %}
+    {{cpp_class}}PartialV8Internal::{{attribute.name}}AttributeSetter{{world_suffix}}(v8Value, info);
+    {% else %}
     {{cpp_class}}V8Internal::{{attribute.name}}AttributeSetter{{world_suffix}}(v8Value, info);
     {% endif %}
+    {% endif %}
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 {% endfilter %}
 {% endmacro %}
 
 
 {##############################################################################}
 {% macro attribute_getter_implemented_in_private_script(attribute) %}
 bool {{v8_class}}::PrivateScript::{{attribute.name}}AttributeGetter(LocalFrame* frame, {{cpp_class}}* holderImpl, {{attribute.cpp_type}}* result)
 {
@@ skipping 43 matching lines @@
     v8::Handle<v8::Value> holder = toV8(holderImpl, scriptState->context()->Global(), scriptState->isolate());
 
     ExceptionState exceptionState(ExceptionState::SetterContext, "{{attribute.name}}", "{{cpp_class}}", scriptState->context()->Global(), scriptState->isolate());
     return PrivateScriptRunner::runDOMAttributeSetter(scriptState, scriptStateInUserScript, "{{cpp_class}}", "{{attribute.name}}", holder, {{attribute.private_script_cpp_value_to_v8_value}});
 }
 {% endmacro %}
 
 
 {##############################################################################}
 {% macro attribute_configuration(attribute) %}
+{% set empty_or_partial = '' if not is_partial else 'Partial' %}

[haraken, 2014/10/09 04:24:00]

As commented in another place, we want to avoid creating the namespace name
repeatedly in templates. Can we create the namespace name once in the code
generator and pass it to the templates?

[tasak, 2014/10/10 07:52:23]

Done.
Added "acutal_cpp_class" and "actual_v8_class" for
"{{cpp_class}}{{empty_or_partial}}" and "{{v8_class}}{{empty_or_partial}}".

 {% set getter_callback =
-       '%sV8Internal::%sAttributeGetterCallback' %
-            (cpp_class, attribute.name)
+       '%s%sV8Internal::%sAttributeGetterCallback' %
+            (cpp_class, empty_or_partial, attribute.name)
        if not attribute.constructor_type else
-       ('%sV8Internal::%sConstructorGetterCallback' %
-            (cpp_class, attribute.name)
+       ('%s%sV8Internal::%sConstructorGetterCallback' %
+            (cpp_class, empty_or_partial, attribute.name)
         if attribute.needs_constructor_getter_callback else
-       '{0}V8Internal::{0}ConstructorGetter'.format(cpp_class)) %}
+       '%s%sV8Internal::%sConstructorGetter' % (cpp_class, empty_or_partial, cpp_class)) %}
 {% set getter_callback_for_main_world =
-       '%sV8Internal::%sAttributeGetterCallbackForMainWorld' %
-            (cpp_class, attribute.name)
+       '%s%sV8Internal::%sAttributeGetterCallbackForMainWorld' %
+            (cpp_class, empty_or_partial, attribute.name)
        if attribute.is_per_world_bindings else '0' %}
 {% set setter_callback = attribute.setter_callback %}
 {% set setter_callback_for_main_world =
-       '%sV8Internal::%sAttributeSetterCallbackForMainWorld' %
-           (cpp_class, attribute.name)
+       '%s%sV8Internal::%sAttributeSetterCallbackForMainWorld' %
+           (cpp_class, empty_or_partial, attribute.name)
        if attribute.is_per_world_bindings and
           (not attribute.is_read_only or attribute.put_forwards) else '0' %}
 {% set wrapper_type_info =
        'const_cast<WrapperTypeInfo*>(&V8%s::wrapperTypeInfo)' %
             attribute.constructor_type
         if attribute.constructor_type else '0' %}
 {% set access_control = 'static_cast<v8::AccessControl>(%s)' %
                         ' | '.join(attribute.access_control_list) %}
 {% set property_attribute = 'static_cast<v8::PropertyAttribute>(%s)' %
                             ' | '.join(attribute.property_attributes) %}
@@ skipping 11 matching lines @@
        access_control,
        property_attribute,
        only_exposed_to_private_script,
    ] %}
 {% if not attribute.is_expose_js_accessors %}
 {% set attribute_configuration_list = attribute_configuration_list
                                     + [on_prototype] %}
 {% endif %}
 {{'{'}}{{attribute_configuration_list | join(', ')}}{{'}'}}
 {%- endmacro %}