Implement cross-origin attributes using access check interceptors.

third_party/WebKit/Source/bindings/templates/interface.cpp.tmpl

 {% extends 'interface_base.cpp.tmpl' %}
 
 {% set has_prepare_prototype_and_interface_object =
     unscopables or has_conditional_attributes_on_prototype or
     methods | conditionally_exposed(is_partial) %}
 {% set prepare_prototype_and_interface_object_func =
     '%s::preparePrototypeAndInterfaceObject' % v8_class
     if has_prepare_prototype_and_interface_object
     else 'nullptr' %}
 
@@ skipping 470 matching lines @@
   {% else %}
   {{cpp_class}}V8Internal::namedPropertyEnumerator(info);
   {% endif %}
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
+{# TODO(dcheng): This shouldn't be necessary with cross-origin interceptors, but
+   v8 doesn't support querying the incumbent context. For now, always

[Yuki, 2016/12/07 12:03:40]

"incumbent realm" is an idea of HTML, hence it should be implemented in Blink, I
think.  It's not V8's fault.

[dcheng, 2016/12/08 09:04:10]

It's awkward to implement in Blink though: according to domenic@, we should not
be creating per-realm function objects except for cross-origin accesses.

If we're OK with keeping this behavior in the long-term, I will just change the
comments to explain the implementation strategy. WDYT?

[Yuki, 2016/12/09 07:02:49]

I'm not saying that it's okay to create per-realm function objects
(originSafeMethodGetter), but I'm saying that Blink may/should be responsible to
support a way to control "incumbent realm" because it's out of scope of
ECMAScript.  "incumbent realm" is defined in HTML spec.

I'm saying that Blink should support "incumbent realm" on Blink side and remove
the ugly hack of originSafeMethodGetter.  It's possible that Blink needs some
help from V8, but in general, HTML things should be handled in Blink, not in V8,
I think.

I think/suppose that, once Blink supports "incumbent realm", we can implement
postMessage in a correct way using incumbent realm and we no longer need
originSafeMethodGetter.

[dcheng, 2016/12/09 07:35:20]

Ah, I understand. I've updated the comment to talk specifically about supporting
the incumbent realm. WDYT?

[Yuki, 2016/12/09 08:40:23]

I like the new comment.  Thanks.  :)

+   incorrectly create per-realm representations. #}
 {% block origin_safe_method_setter %}
 {% if has_origin_safe_method_setter %}
 static void {{cpp_class}}OriginSafeMethodSetter(v8::Local<v8::Name> name, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) {
   if (!name->IsString())
     return;
   v8::Local<v8::Object> holder = {{v8_class}}::findInstanceInPrototypeChain(info.Holder(), info.GetIsolate());
   if (holder.IsEmpty())
     return;
   {{cpp_class}}* impl = {{v8_class}}::toImpl(holder);
   v8::String::Utf8Value attributeName(name);
@@ skipping 148 matching lines @@
   {% else %}
   {{cpp_class}}V8Internal::constructor(info);
   {% endif %}
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
-{% macro install_do_not_check_security_method(method, world_suffix, instance_template, prototype_template) %}
+{% macro install_origin_safe_method(method, world_suffix, instance_template, prototype_template) %}
 {% from 'utilities.cpp.tmpl' import property_location %}
-{# Methods that are [DoNotCheckSecurity] are always readable, but if they are
-   changed and then accessed from a different origin, we do not return the
-   underlying value, but instead return a new copy of the original function.
-   This is achieved by storing the changed value as a hidden property. #}
+{# TODO(dcheng): This shouldn't be necessary with cross-origin interceptors, but
+   v8 doesn't support querying the incumbent context. For now, always

[Yuki, 2016/12/07 12:03:40]

ditto.

+   incorrectly create per-realm representations. #}
 {% set getter_callback =
        '%sV8Internal::%sOriginSafeMethodGetterCallback%s' %
        (cpp_class, method.name, world_suffix) %}
 {% set setter_callback =
        '{0}V8Internal::{0}OriginSafeMethodSetterCallback'.format(cpp_class)
        if not method.is_unforgeable else '0' %}
 {% if method.is_per_world_bindings %}
 {% set getter_callback_for_main_world = '%sForMainWorld' % getter_callback %}
 {% set setter_callback_for_main_world = '%sForMainWorld' % setter_callback
        if not method.is_unforgeable else '0' %}
 {% else %}
 {% set getter_callback_for_main_world = '0' %}
 {% set setter_callback_for_main_world = '0' %}
 {% endif %}
 {% set property_attribute =
        'static_cast<v8::PropertyAttribute>(%s)' %
        ' | '.join(method.property_attributes or ['v8::None']) %}
 {% set only_exposed_to_private_script = 'V8DOMConfiguration::OnlyExposedToPrivateScript' if method.only_exposed_to_private_script else 'V8DOMConfiguration::ExposedToAllScripts' %}
 {% set holder_check = 'V8DOMConfiguration::CheckHolder' %}
 const V8DOMConfiguration::AttributeConfiguration {{method.name}}OriginSafeAttributeConfiguration = {
-    "{{method.name}}", {{getter_callback}}, {{setter_callback}}, {{getter_callback_for_main_world}}, {{setter_callback_for_main_world}}, nullptr, &{{v8_class}}::wrapperTypeInfo, v8::ALL_CAN_READ, {{property_attribute}}, {{only_exposed_to_private_script}}, {{property_location(method)}}, {{holder_check}},
+    "{{method.name}}", {{getter_callback}}, {{setter_callback}}, {{getter_callback_for_main_world}}, {{setter_callback_for_main_world}}, nullptr, &{{v8_class}}::wrapperTypeInfo, v8::DEFAULT, {{property_attribute}}, {{only_exposed_to_private_script}}, {{property_location(method)}}, {{holder_check}},
 };
 V8DOMConfiguration::installAttribute(isolate, world, {{instance_template}}, {{prototype_template}}, {{method.name}}OriginSafeAttributeConfiguration);
 {%- endmacro %}
 
 
 {##############################################################################}
 {% macro install_indexed_property_handler(target) %}
 {% set indexed_property_getter_callback =
        '%sV8Internal::indexedPropertyGetterCallback' % cpp_class %}
 {% set indexed_property_setter_callback =
        '%sV8Internal::indexedPropertySetterCallback' % cpp_class
        if indexed_property_setter or named_property_setter else '0' %}
 {% set indexed_property_query_callback = '0' %}{# Unused #}
 {% set indexed_property_deleter_callback =
        '%sV8Internal::indexedPropertyDeleterCallback' % cpp_class
        if indexed_property_deleter or named_property_deleter else '0' %}
 {% set indexed_property_enumerator_callback =
        'indexedPropertyEnumerator<%s>' % cpp_class
        if indexed_property_getter.is_enumerable else '0' %}
 {% set property_handler_flags =
-       'v8::PropertyHandlerFlags::kAllCanRead'
-       if indexed_property_getter.do_not_check_security
-       else 'v8::PropertyHandlerFlags::kNone' %}
+       'v8::PropertyHandlerFlags::kNone' %}
 v8::IndexedPropertyHandlerConfiguration indexedPropertyHandlerConfig({{indexed_property_getter_callback}}, {{indexed_property_setter_callback}}, {{indexed_property_query_callback}}, {{indexed_property_deleter_callback}}, {{indexed_property_enumerator_callback}}, v8::Local<v8::Value>(), {{property_handler_flags}});
 {{target}}->SetHandler(indexedPropertyHandlerConfig);
 {%- endmacro %}
 
 
 {##############################################################################}
 {% macro install_named_property_handler(target) %}
 {% 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' %}
 {% set property_handler_flags_list =
        ['int(v8::PropertyHandlerFlags::kOnlyInterceptStrings)'] %}
-{% if named_property_getter.do_not_check_security %}
-{% set property_handler_flags_list =
-       property_handler_flags_list + ['int(v8::PropertyHandlerFlags::kAllCanRead)'] %}
-{% endif %}
 {% if not is_override_builtins %}
 {% set property_handler_flags_list =
        property_handler_flags_list + ['int(v8::PropertyHandlerFlags::kNonMasking)'] %}
 {% endif %}
 {% set property_handler_flags =
        'static_cast<v8::PropertyHandlerFlags>(%s)' %
            ' | '.join(property_handler_flags_list) %}
 v8::NamedPropertyHandlerConfiguration namedPropertyHandlerConfig({{named_property_getter_callback}}, {{named_property_setter_callback}}, {{named_property_query_callback}}, {{named_property_deleter_callback}}, {{named_property_enumerator_callback}}, v8::Local<v8::Value>(), {{property_handler_flags}});
 {{target}}->SetHandler(namedPropertyHandlerConfig);
 {%- endmacro %}
@@ skipping 215 matching lines @@
 }
 
 {% for method in methods if method.overloads and method.overloads.has_partial_overloads %}
 void {{v8_class}}::register{{method.name | blink_capitalize}}MethodForPartialInterface(void (*method)(const v8::FunctionCallbackInfo<v8::Value>&)) {
   {{cpp_class}}V8Internal::{{method.name}}MethodForPartialInterface = method;
 }
 
 {% endfor %}
 {% endif %}
 {% endblock %}