binding: Makes Window/Location's attributes accessor-type properties.

third_party/WebKit/Source/bindings/templates/attributes.cpp

 {% from 'utilities.cpp' import declare_enum_validation_variable, v8_value_to_local_cpp_value, check_origin_trial %}
 
 {##############################################################################}
 {% macro attribute_getter(attribute, world_suffix) %}
 static void {{attribute.name}}AttributeGetter{{world_suffix}}(
 {%- if attribute.is_data_type_property %}
 const v8::PropertyCallbackInfo<v8::Value>& info
 {%- else %}
 const v8::FunctionCallbackInfo<v8::Value>& info
 {%- endif %})
 {
     {% if attribute.origin_trial_enabled_function %}
     {{check_origin_trial(attribute) | indent}}
     {% endif %}
     {% if attribute.is_reflect and not attribute.is_url
           and attribute.idl_type == 'DOMString' and is_node
           and not attribute.is_implemented_in_private_script %}
     {% set cpp_class, v8_class = 'Element', 'V8Element' %}
     {% endif %}
     {# holder #}
     {% if not attribute.is_static %}
     {% if attribute.is_lenient_this %}
     {# Make sure that info.Holder() really points to an instance if [LenientThis]. #}
-    if (!{{v8_class}}::hasInstance(info.Holder(), info.GetIsolate()))
+    v8::Local<v8::Object> holder = {{v8_class}}::findInstanceInPrototypeChain(info.This(), info.GetIsolate());
+    if (holder.IsEmpty())
         return; // Return silently because of [LenientThis].
+    {% else %}
+    v8::Local<v8::Object> holder = info.Holder();
     {% endif %}
-    v8::Local<v8::Object> holder = info.Holder();
     {% endif %}
     {# impl #}
     {% if attribute.cached_attribute_validation_method %}
     v8::Local<v8::String> propertyName = v8AtomicString(info.GetIsolate(), "{{attribute.name}}");
     {{cpp_class}}* impl = {{v8_class}}::toImpl(holder);
     if (!impl->{{attribute.cached_attribute_validation_method}}()) {
         v8::Local<v8::Value> v8Value = V8HiddenValue::getHiddenValue(ScriptState::current(info.GetIsolate()), holder, propertyName);
         if (!v8Value.IsEmpty() && !v8Value->IsUndefined()) {
             v8SetReturnValue(info, v8Value);
             return;
@@ skipping 31 matching lines @@
     {% endif %}
     {# Checks #}
     {% if attribute.is_getter_raises_exception %}
     if (UNLIKELY(exceptionState.throwIfNeeded()))
         return;
     {% endif %}
     {# Security checks #}
     {% if not attribute.is_data_type_property %}
     {% if attribute.is_check_security_for_receiver %}
     if (!BindingSecurity::shouldAllowAccessTo(info.GetIsolate(), callingDOMWindow(info.GetIsolate()), impl, exceptionState)) {
-        v8SetReturnValueNull(info);
+        {{attribute.v8_set_return_value_for_security_failure}};
         exceptionState.throwIfNeeded();
         return;
     }
     {% endif %}
     {% endif %}
     {% if attribute.is_check_security_for_return_value %}
     if (!BindingSecurity::shouldAllowAccessTo(info.GetIsolate(), callingDOMWindow(info.GetIsolate()), {{attribute.cpp_value}}, exceptionState)) {
         v8SetReturnValueNull(info);

[haraken, 2016/04/27 16:15:12]

Does this need to be checked as well?

[Yuki, 2016/04/28 07:53:39]

I was on the fence at this point, but now I follow your suggestion.

FYI, this is inside |attribute.is_check_security_for_return_value|.  This means
that we're performing the access check to the returned object.  It means that
the returned object is not a simple number, string, or boolean, because
primitive values do not transfer the context.

Thus, the return value here must always be an Object, so it's okay to always
return null (unless the attribute requires undefined specifically).

Having said that, I replace this line with
|v8_set_return_value_for_security_failure|.  Hope it's more readable and/or
consistent.

         exceptionState.throwIfNeeded();
         return;
     }
     {% endif %}
     {% if attribute.reflect_only %}
     {{release_only_check(attribute.reflect_only, attribute.reflect_missing,
                          attribute.reflect_invalid, attribute.reflect_empty,
                          attribute.cpp_value)
       | indent}}
     {% endif %}
@@ skipping 141 matching lines @@
     {% else %}
     {% set raise_exception = 0 %}
     {% endif %}
     {# Local variables #}
     {% if (not attribute.is_static and
            not attribute.is_replaceable and
            not attribute.constructor_type) or
           raise_exception %}
     {% if attribute.is_lenient_this %}
     {# Make sure that info.Holder() really points to an instance if [LenientThis]. #}
-    if (!{{v8_class}}::hasInstance(info.Holder(), info.GetIsolate()))
+    v8::Local<v8::Object> holder = {{v8_class}}::findInstanceInPrototypeChain(info.This(), info.GetIsolate());
+    if (holder.IsEmpty())
         return; // Return silently because of [LenientThis].
+    {% else %}
+    v8::Local<v8::Object> holder = info.Holder();
     {% endif %}
-    v8::Local<v8::Object> holder = info.Holder();
     {% endif %}
     {% if raise_exception %}
     ExceptionState exceptionState(ExceptionState::SetterContext, "{{attribute.name}}", "{{interface_name}}", holder, info.GetIsolate());
     {% endif %}
     {% if attribute.is_replaceable or
           attribute.constructor_type %}
     v8::Local<v8::String> propertyName = v8AtomicString(info.GetIsolate(), "{{attribute.name}}");
     {% endif %}
     {# impl #}
     {% if attribute.is_put_forwards %}
@@ skipping 236 matching lines @@
        setter_callback_for_main_world,
        wrapper_type_info,
        access_control,
        property_attribute,
        only_exposed_to_private_script,
        property_location(attribute),
        holder_check,
    ] %}
 {{'{'}}{{attribute_configuration_list | join(', ')}}{{'}'}}
 {%- endmacro %}