Source/bindings/templates/interface_base.cpp - Issue 618373003: [bindings] partial interfaces should not violate componentization

Unified Diff: Source/bindings/templates/interface_base.cpp

Issue 618373003: [bindings] partial interfaces should not violate componentization (Closed) Base URL: svn://svn.chromium.org/blink/trunk

Patch Set: Created 6 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

« Source/bindings/templates/attributes.cpp ('K') | « Source/bindings/templates/interface.cpp ('k') | Source/bindings/templates/methods.cpp » ('j') | Source/bindings/templates/partial_interface.h » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: Source/bindings/templates/interface_base.cpp

diff --git a/Source/bindings/templates/interface_base.cpp b/Source/bindings/templates/interface_base.cpp

index 1188d0575946332f559d2ac2b83622bba6ed701c..a2f72fd9f41aa87f54101f0f2778cc7a1e9afb69 100644

--- a/Source/bindings/templates/interface_base.cpp

+++ b/Source/bindings/templates/interface_base.cpp

@@ -6,12 +6,13 @@

#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' %}

@@ -24,7 +25,9 @@ namespace blink {

{% 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.

@@ -33,7 +36,13 @@ const WrapperTypeInfo {{v8_class}}::wrapperTypeInfo = { gin::kEmbedderBlink, {{v

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

@@ -105,7 +114,7 @@ static void {{cpp_class}}ForceSetAttributeOnThis(v8::Local<v8::String> name, v8:

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 %}

@@ -136,17 +145,26 @@ bool namedSecurityCheck(v8::Local<v8::Object> host, v8::Local<v8::Value> key, v8

{% 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 %}

{% endif %}

-{% if method.overloads %}

+{% if method.overloads and method.overloads.visible %}

{% 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 th

tasak 2014/10/17 07:38:18 https://docs.google.com/document/d/1qBC7Therp437Jb

{# A single callback is generated for overloaded methods #}

+{# with considering partial overloads #}

{% endif %}

-{% if method.is_do_not_check_security %}

+{% endif %}

+{% if method.is_do_not_check_security and method.visible %}

{% endif %}

{% endfor %}

@@ -180,12 +198,13 @@ bool namedSecurityCheck(v8::Local<v8::Object> host, v8::Local<v8::Value> key, v8

{% 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

@@ -206,6 +225,7 @@ static const V8DOMConfiguration::AttributeConfiguration {{v8_class}}Attributes[]

{% 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 %}

@@ -237,10 +257,19 @@ static const V8DOMConfiguration::MethodConfiguration {{v8_class}}Methods[] = {

{##############################################################################}

{% 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 =

@@ -306,7 +335,7 @@ static void install{{v8_class}}Template(v8::Handle<v8::FunctionTemplate> functio

{% 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

@@ -348,7 +377,7 @@ static void install{{v8_class}}Template(v8::Handle<v8::FunctionTemplate> functio

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 #}

@@ -381,6 +410,7 @@ static void install{{v8_class}}Template(v8::Handle<v8::FunctionTemplate> functio

{% 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 gener

{% if interface_name == 'Window' %}

prototypeTemplate->SetInternalFieldCount(V8Window::internalFieldCount);

@@ -398,6 +428,7 @@ static void install{{v8_class}}Template(v8::Handle<v8::FunctionTemplate> functio

// Custom toString template

functionTemplate->Set(v8AtomicString(isolate, "toString"), V8PerIsolateData::from(isolate)->toStringTemplate());

+ {% endif %}

}

{% endblock %}

@@ -407,43 +438,19 @@ static void install{{v8_class}}Template(v8::Handle<v8::FunctionTemplate> functio

{% 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 %}

- {% 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_attribute

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 %}

- {% endfor %}

+{% from 'methods.cpp' import install_conditionally_enabled_methods

+ with context %}

+{% if is_partial or conditionally_enabled_methods %}

+{{install_conditionally_enabled_methods()}}

{% endif %}

{% endblock %}

@@ -463,5 +470,6 @@ void {{v8_class}}::installConditionallyEnabledMethods(v8::Handle<v8::Object> pro

{% endif %}

{% endfor %}

+{% block partial_interface %}{% endblock %}

} // namespace blink

{% endfilter %}