V8-binding: Use v8::Template::SetNativeDataProperty without setter for [Replaceable].

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

 {% include 'copyright_block.txt' %}
 #include "{{v8_class_or_partial}}.h"
 
 {% for filename in cpp_includes if filename != '%s.h' % cpp_class_or_partial %}
 #include "{{filename}}"
 {% endfor %}
 
 namespace blink {
 {% set visit_dom_wrapper = '%s::visitDOMWrapper' % v8_class
                            if has_visit_dom_wrapper else '0' %}
@@ skipping 32 matching lines @@
 {% endfor %}
 {% endif %}
 
 {# Constants #}
 {% from 'constants.cpp' import constant_getter_callback
        with context %}
 {% for constant in special_getter_constants %}
 {{constant_getter_callback(constant)}}
 {% endfor %}
 {# Attributes #}
-{% block replaceable_attribute_setter_and_callback %}
-{% if has_replaceable_attributes or has_constructor_attributes %}
+{% if has_replaceable_attributes %}
 template<class CallbackInfo>
 static bool {{cpp_class}}CreateDataProperty(v8::Local<v8::Name> name, v8::Local<v8::Value> v8Value, const CallbackInfo& info)
 {
     {% if is_check_security %}
-    {{cpp_class}}* impl = {{v8_class}}::toImpl(info.Holder());
-    v8::String::Utf8Value attributeName(name);
-    ExceptionState exceptionState(ExceptionState::SetterContext, *attributeName, "{{interface_name}}", info.Holder(), info.GetIsolate());
-    if (!BindingSecurity::shouldAllowAccessTo(info.GetIsolate(), callingDOMWindow(info.GetIsolate()), impl, exceptionState)) {
-        exceptionState.throwIfNeeded();
-        return false;
-    }
+#error TODO(yukishiino): Supports [Replaceable] accessor-type properties with security check (if we really need it).
     {% endif %}
     ASSERT(info.This()->IsObject());
     return v8CallBoolean(v8::Local<v8::Object>::Cast(info.This())->CreateDataProperty(info.GetIsolate()->GetCurrentContext(), name, v8Value));
 }
 
-{% if needs_constructor_setter_callback %}
-static void {{cpp_class}}ConstructorAttributeSetterCallback(v8::Local<v8::Name>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
-{
-    do {
-        v8::Local<v8::Value> data = info.Data();
-        ASSERT(data->IsExternal());
-        V8PerContextData* perContextData = V8PerContextData::from(info.Holder()->CreationContext());
-        if (!perContextData)
-            break;
-        const WrapperTypeInfo* wrapperTypeInfo = WrapperTypeInfo::unwrap(data);
-        if (!wrapperTypeInfo)
-            break;
-        {{cpp_class}}CreateDataProperty(v8String(info.GetIsolate(), wrapperTypeInfo->interfaceName), v8Value, info);
-    } while (false); // do ... while (false) just for use of break
-}
-
 {% endif %}
-{% endif %}
-{% endblock %}
 {##############################################################################}
 {% from 'attributes.cpp' import constructor_getter_callback,
        attribute_getter, attribute_getter_callback,
        attribute_setter, attribute_setter_callback,
        attribute_getter_implemented_in_private_script,
        attribute_setter_implemented_in_private_script
        with context %}
 {% for attribute in attributes if attribute.should_be_exposed_to_script %}
 {% for world_suffix in attribute.world_suffixes %}
-{% if not attribute.constructor_type %}
-{% if not attribute.has_custom_getter %}
+{% if not attribute.has_custom_getter and not attribute.constructor_type %}
 {{attribute_getter(attribute, world_suffix)}}
 {% endif %}
+{% if not attribute.constructor_type %}
 {{attribute_getter_callback(attribute, world_suffix)}}
+{% elif attribute.needs_constructor_getter_callback %}
+{{constructor_getter_callback(attribute, world_suffix)}}
 {% endif %}
 {% if attribute.has_setter %}
-{% if not attribute.has_custom_setter and
-       (not attribute.constructor_type or attribute.needs_constructor_setter_callback) %}
+{% if not attribute.has_custom_setter %}
 {{attribute_setter(attribute, world_suffix)}}
 {% endif %}
-{% if not attribute.constructor_type or attribute.needs_constructor_setter_callback %}
 {{attribute_setter_callback(attribute, world_suffix)}}
 {% endif %}
-{% endif %}
 {% endfor %}
 {% endfor %}
 {##############################################################################}
-{% for attribute in attributes if attribute.needs_constructor_getter_callback %}
-{% for world_suffix in attribute.world_suffixes %}
-{{constructor_getter_callback(attribute, world_suffix)}}
-{% endfor %}
-{% endfor %}
-{##############################################################################}
 {% block security_check_functions %}
 {% if has_access_check_callbacks %}
 bool securityCheck(v8::Local<v8::Context> accessingContext, v8::Local<v8::Object> accessedObject, v8::Local<v8::Value> data)
 {
     // TODO(jochen): Take accessingContext into account.
     {{cpp_class}}* impl = {{v8_class}}::toImpl(accessedObject);
     return BindingSecurity::shouldAllowAccessTo(v8::Isolate::GetCurrent(), callingDOMWindow(v8::Isolate::GetCurrent()), impl, DoNotReportSecurityError);
 }
 
 {% endif %}
@@ skipping 303 matching lines @@
 {{method_implemented_in_private_script(method)}}
 {% endfor %}
 {% for attribute in attributes if attribute.is_implemented_in_private_script %}
 {{attribute_getter_implemented_in_private_script(attribute)}}
 {% if attribute.has_setter %}
 {{attribute_setter_implemented_in_private_script(attribute)}}
 {% endif %}
 {% endfor %}
 {% block partial_interface %}{% endblock %}
 } // namespace blink