IDL compiler: Window-specific code + Window-only features

Source/bindings/templates/interface.cpp

 {% extends 'interface_base.cpp' %}
 
 
 {##############################################################################}
 {% macro attribute_configuration(attribute) %}
 {% set getter_callback =
        '%sV8Internal::%sAttributeGetterCallback' %
             (cpp_class, attribute.name)
        if not attribute.constructor_type else
-       '{0}V8Internal::{0}ConstructorGetter'.format(interface_name) %}
+       '{0}V8Internal::{0}ConstructorGetter'.format(cpp_class) %}
 {% set getter_callback_for_main_world =
        '%sV8Internal::%sAttributeGetterCallbackForMainWorld' %
             (cpp_class, 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)
        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) %}
-{% set on_prototype = ', 0 /* on instance */'
-       if not attribute.is_expose_js_accessors else '' %}
-{"{{attribute.name}}", {{getter_callback}}, {{setter_callback}}, {{getter_callback_for_main_world}}, {{setter_callback_for_main_world}}, {{wrapper_type_info}}, {{access_control}}, {{property_attribute}}{{on_prototype}}}
+{% set on_prototype = '1 /* on prototype */'
+       if interface_name == 'Window' and attribute.idl_type == 'EventHandler'
+       else '0 /* on instance */' %}

[haraken, 2014/02/06 07:57:44]

I don't fully understand why we need to treat EventHandlers on Window specially,
but it's not related to your CL. (I need to consider when moving DOM attributes
to prototype chains.)

[Nils Barth (inactive), 2014/02/06 08:40:14]

Got it; agreed it would be simpler to eliminate this throughout
(this is the main complexity of handling Window).

+{% set attribute_configuration_list = [
+       '"%s"' % attribute.name,
+       getter_callback,
+       setter_callback,
+       getter_callback_for_main_world,
+       setter_callback_for_main_world,
+       wrapper_type_info,
+       access_control,
+       property_attribute,
+   ] %}
+{% if not attribute.is_expose_js_accessors %}
+{% set attribute_configuration_list = attribute_configuration_list
+                                    + [on_prototype] %}
+{% endif %}
+{{'{'}}{{attribute_configuration_list|join(', ')}}{{'}'}}
 {%- endmacro %}
 
 
 {##############################################################################}
 {% macro method_configuration(method) %}
 {% set method_callback =
    '%sV8Internal::%sMethodCallback' % (cpp_class, method.name) %}
 {% set method_callback_for_main_world =
    '%sV8Internal::%sMethodCallbackForMainWorld' % (cpp_class, method.name)
    if method.is_per_world_bindings else '0' %}
 {"{{method.name}}", {{method_callback}}, {{method_callback_for_main_world}}, {{method.number_of_required_or_variadic_arguments}}}
 {%- endmacro %}
 
 
 {##############################################################################}
 {% block constructor_getter %}
 {% if has_constructor_attributes %}
-static void {{interface_name}}ConstructorGetter(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
+static void {{cpp_class}}ConstructorGetter(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 {
     v8::Handle<v8::Value> data = info.Data();
     ASSERT(data->IsExternal());
     V8PerContextData* perContextData = V8PerContextData::from(info.Holder()->CreationContext());
     if (!perContextData)
         return;
     v8SetReturnValue(info, perContextData->constructorForType(WrapperTypeInfo::unwrap(data)));
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
 {% block replaceable_attribute_setter_and_callback %}
 {% if has_replaceable_attributes or has_constructor_attributes %}
 {# FIXME: rename to ForceSetAttributeOnThis, since also used for Constructors #}
-static void {{interface_name}}ReplaceableAttributeSetter(v8::Local<v8::String> name, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)
+static void {{cpp_class}}ReplaceableAttributeSetter(v8::Local<v8::String> name, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)
 {
+    {% if is_check_security %}
+    {{cpp_class}}* imp = {{v8_class}}::toNative(info.Holder());
+    v8::String::Utf8Value attributeName(name);
+    ExceptionState exceptionState(ExceptionState::SetterContext, *attributeName, "{{interface_name}}", info.Holder(), info.GetIsolate());
+    if (!BindingSecurity::shouldAllowAccessToFrame(info.GetIsolate(), imp->frame(), exceptionState)) {
+        exceptionState.throwIfNeeded();
+        return;
+    }
+    {% endif %}
     info.This()->ForceSet(name, jsValue);
 }
 
 {# FIXME: rename to ForceSetAttributeOnThisCallback, since also used for Constructors #}
-static void {{interface_name}}ReplaceableAttributeSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)
+static void {{cpp_class}}ReplaceableAttributeSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)
 {
-    {{interface_name}}V8Internal::{{interface_name}}ReplaceableAttributeSetter(name, jsValue, info);
+    {{cpp_class}}V8Internal::{{cpp_class}}ReplaceableAttributeSetter(name, jsValue, info);
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
 {% block security_check_functions %}
 {% if is_check_security and interface_name != 'Window' %}
 bool indexedSecurityCheck(v8::Local<v8::Object> host, uint32_t index, v8::AccessType type, v8::Local<v8::Value>)
@@ skipping 289 matching lines @@
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
 {% block named_property_query %}
 {% if named_property_getter and named_property_getter.is_enumerable and
       not named_property_getter.is_custom_property_query %}
+{# If there is an enumerator, there MUST be a query method to properly
+   communicate property attributes. #}
 static void namedPropertyQuery(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Integer>& info)
 {
     {{cpp_class}}* collection = {{v8_class}}::toNative(info.Holder());
     AtomicString propertyName = toCoreAtomicString(name);
     ExceptionState exceptionState(info.Holder(), info.GetIsolate());
     bool result = collection->namedPropertyQuery(propertyName, exceptionState);
     if (exceptionState.throwIfNeeded())
         return;
     if (!result)
         return;
@@ skipping 297 matching lines @@
     }
     {% endif %}
     setObjectGroup(object, wrapper, isolate);
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
+{% block shadow_attributes %}
+{% if interface_name == 'Window' %}
+static const V8DOMConfiguration::AttributeConfiguration shadowAttributes[] = {
+    {% for attribute in attributes if attribute.is_unforgeable %}
+    {{attribute_configuration(attribute)}},
+    {% endfor %}
+};
+
+{% endif %}
+{% endblock %}
+
+
+{##############################################################################}
 {% block class_attributes %}
 {# FIXME: rename to install_attributes and put into configure_class_template #}
 {% 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) %}
+               attribute.per_context_enabled_function or
+               (interface_name == 'Window' and attribute.is_unforgeable)) %}

[haraken, 2014/02/06 07:57:44]

Do we need interface_name=='Window'?

[Nils Barth (inactive), 2014/02/06 08:40:14]

Yes - this is exactly the shadowAttributes, directly above.

     {% filter conditional(attribute.conditional_string) %}
     {{attribute_configuration(attribute)}},
     {% endfilter %}
     {% endfor %}
 };
 
 {% endif %}
 {% endblock %}
 
 
@@ skipping 85 matching lines @@
     {% else %}
     {{cpp_class}}V8Internal::constructor(info);
     {% endif %}
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
+{% block configure_shadow_object_template %}
+{% if interface_name == 'Window' %}
+static void configureShadowObjectTemplate(v8::Handle<v8::ObjectTemplate> templ, v8::Isolate* isolate, WrapperWorldType currentWorldType)
+{
+    V8DOMConfiguration::installAttributes(templ, v8::Handle<v8::ObjectTemplate>(), shadowAttributes, WTF_ARRAY_LENGTH(shadowAttributes), isolate, currentWorldType);
+
+    // Install a security handler with V8.
+    templ->SetAccessCheckCallbacks(V8Window::namedSecurityCheckCustom, V8Window::indexedSecurityCheckCustom, v8::External::New(isolate, const_cast<WrapperTypeInfo*>(&V8Window::wrapperTypeInfo)));
+    templ->SetInternalFieldCount(V8Window::internalFieldCount);
+}
+
+{% endif %}
+{% endblock %}
+
+
+{##############################################################################}
 {% block configure_class_template %}
 {# FIXME: rename to install_dom_template and Install{{v8_class}}DOMTemplate #}
 static void configure{{v8_class}}Template(v8::Handle<v8::FunctionTemplate> functionTemplate, v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     functionTemplate->ReadOnlyPrototype();
 
     v8::Local<v8::Signature> defaultSignature;
     {% set parent_template =
            'V8%s::domTemplate(isolate, currentWorldType)' % parent_interface
            if parent_interface else 'v8::Local<v8::FunctionTemplate>()' %}
@@ skipping 27 matching lines @@
     {% if constructors or has_custom_constructor or has_event_constructor %}
     functionTemplate->SetCallHandler({{v8_class}}::constructorCallback);
     functionTemplate->SetLength({{interface_length}});
     {% endif %}
     v8::Local<v8::ObjectTemplate> ALLOW_UNUSED instanceTemplate = functionTemplate->InstanceTemplate();
     v8::Local<v8::ObjectTemplate> ALLOW_UNUSED prototypeTemplate = functionTemplate->PrototypeTemplate();
     {% if is_check_security and interface_name != 'Window' %}
     instanceTemplate->SetAccessCheckCallbacks({{cpp_class}}V8Internal::namedSecurityCheck, {{cpp_class}}V8Internal::indexedSecurityCheck, v8::External::New(isolate, const_cast<WrapperTypeInfo*>(&{{v8_class}}::wrapperTypeInfo)));
     {% endif %}
     {% for attribute in attributes
-       if attribute.runtime_enabled_function and not attribute.is_static %}
+       if attribute.runtime_enabled_function and
+          not attribute.per_context_enabled_function and
+          not attribute.is_static %}
     {% filter conditional(attribute.conditional_string) %}
     if ({{attribute.runtime_enabled_function}}()) {
         static const V8DOMConfiguration::AttributeConfiguration attributeConfiguration =\
         {{attribute_configuration(attribute)}};
         V8DOMConfiguration::installAttribute(instanceTemplate, prototypeTemplate, attributeConfiguration, isolate, currentWorldType);
     }
     {% endfilter %}
     {% endfor %}
     {% if constants %}
     {{install_constants() | indent}}
     {% endif %}
+    {# Special operations #}
+    {# 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 %}
     {% set indexed_property_setter_callback =
            '%sV8Internal::indexedPropertySetterCallback' % cpp_class
            if indexed_property_setter else '0' %}
     {% set indexed_property_query_callback = '0' %}{# Unused #}
     {% set indexed_property_deleter_callback =
            '%sV8Internal::indexedPropertyDeleterCallback' % cpp_class
            if indexed_property_deleter else '0' %}
     {% set indexed_property_enumerator_callback =
            'indexedPropertyEnumerator<%s>' % cpp_class
            if indexed_property_getter.is_enumerable else '0' %}
-    functionTemplate->InstanceTemplate()->SetIndexedPropertyHandler({{indexed_property_getter_callback}}, {{indexed_property_setter_callback}}, {{indexed_property_query_callback}}, {{indexed_property_deleter_callback}}, {{indexed_property_enumerator_callback}});
+    functionTemplate->{{set_on_template}}()->SetIndexedPropertyHandler({{indexed_property_getter_callback}}, {{indexed_property_setter_callback}}, {{indexed_property_query_callback}}, {{indexed_property_deleter_callback}}, {{indexed_property_enumerator_callback}});
     {% endif %}
     {% if named_property_getter %}
     {# if have named properties, MUST have a named property getter #}
     {% set named_property_getter_callback =
            '%sV8Internal::namedPropertyGetterCallback' % cpp_class %}
     {% set named_property_setter_callback =
            '%sV8Internal::namedPropertySetterCallback' % cpp_class
            if named_property_setter else '0' %}
     {% set named_property_query_callback =
            '%sV8Internal::namedPropertyQueryCallback' % cpp_class
            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->InstanceTemplate()->SetNamedPropertyHandler({{named_property_getter_callback}}, {{named_property_setter_callback}}, {{named_property_query_callback}}, {{named_property_deleter_callback}}, {{named_property_enumerator_callback}});
+    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 %}
+    {# 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 %}
     {% for method in methods if not method.do_not_check_signature %}
     {# install_custom_signature #}
     {% if not method.overload_index or method.overload_index == 1 %}
@@ skipping 205 matching lines @@
 EventTarget* {{v8_class}}::toEventTarget(v8::Handle<v8::Object> object)
 {
     return toNative(object);
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
+{% block get_shadow_object_template %}
+{% if interface_name == 'Window' %}
+v8::Handle<v8::ObjectTemplate> V8Window::getShadowObjectTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
+{
+    if (currentWorldType == MainWorld) {
+        DEFINE_STATIC_LOCAL(v8::Persistent<v8::ObjectTemplate>, V8WindowShadowObjectCacheForMainWorld, ());
+        if (V8WindowShadowObjectCacheForMainWorld.IsEmpty()) {
+            TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "BuildDOMTemplate");
+            v8::Handle<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(isolate);
+            configureShadowObjectTemplate(templ, isolate, currentWorldType);
+            V8WindowShadowObjectCacheForMainWorld.Reset(isolate, templ);
+            return templ;
+        }
+        return v8::Local<v8::ObjectTemplate>::New(isolate, V8WindowShadowObjectCacheForMainWorld);
+    } else {
+        DEFINE_STATIC_LOCAL(v8::Persistent<v8::ObjectTemplate>, V8WindowShadowObjectCacheForNonMainWorld, ());
+        if (V8WindowShadowObjectCacheForNonMainWorld.IsEmpty()) {
+            TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "BuildDOMTemplate");
+            v8::Handle<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(isolate);
+            configureShadowObjectTemplate(templ, isolate, currentWorldType);
+            V8WindowShadowObjectCacheForNonMainWorld.Reset(isolate, templ);
+            return templ;
+        }
+        return v8::Local<v8::ObjectTemplate>::New(isolate, V8WindowShadowObjectCacheForNonMainWorld);
+    }
+}
+
+{% endif %}
+{% endblock %}
+
+
+{##############################################################################}
 {% block wrap %}
 {% if special_wrap_for or is_document %}
 v8::Handle<v8::Object> wrap({{cpp_class}}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     ASSERT(impl);
     {% for special_wrap_interface in special_wrap_for %}
     if (impl->is{{special_wrap_interface}}())
         return wrap(to{{special_wrap_interface}}(impl), creationContext, isolate);
     {% endfor %}
     v8::Handle<v8::Object> wrapper = {{v8_class}}::createWrapper(impl, creationContext, isolate);
@@ skipping 73 matching lines @@
     fromInternalPointer(object)->deref();
 }
 
 template<>
 v8::Handle<v8::Value> toV8NoInline({{cpp_class}}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     return toV8(impl, creationContext, isolate);
 }
 
 {% endblock %}