Revert of bindings: Makes almost all attributes accessor-type properties.

Source/bindings/templates/interface_base.cpp

 {% include 'copyright_block.txt' %}
 #include "config.h"
 {% filter conditional(conditional_string) %}
 #include "{{v8_class_or_partial}}.h"
 
 {% for filename in cpp_includes if filename != '%s.h' % cpp_class_or_partial %}
 #include "{{filename}}"
 {% endfor %}
 
 namespace blink {
@@ skipping 209 matching lines @@
 {% block install_attributes %}
 {% from 'attributes.cpp' import attribute_configuration with context %}
 {% if has_attribute_configuration %}
 // Suppress warning: global constructors, because AttributeConfiguration is trivial
 // and does not depend on another global objects.
 #if defined(COMPONENT_BUILD) && defined(WIN32) && COMPILER(CLANG)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wglobal-constructors"
 #endif
 static const V8DOMConfiguration::AttributeConfiguration {{v8_class}}Attributes[] = {
-    {# [Unforgeable] attributes in Window are defined as shadow_attributes, so
-       excluded here. #}
     {% for attribute in attributes
-       if not (attribute.exposed_test or
-               attribute.runtime_enabled_function) and
-          attribute.is_data_type_property and
-          attribute.should_be_exposed_to_script and
-          not (interface_name == 'Window' and attribute.is_unforgeable) %}
+       if not (attribute.is_expose_js_accessors or
+               attribute.is_static or
+               attribute.runtime_enabled_function or
+               attribute.exposed_test or
+               (interface_name == 'Window' and attribute.is_unforgeable))
+           and attribute.should_be_exposed_to_script %}
     {% filter conditional(attribute.conditional_string) %}
     {{attribute_configuration(attribute)}},
     {% endfilter %}
     {% endfor %}
 };
 #if defined(COMPONENT_BUILD) && defined(WIN32) && COMPILER(CLANG)
 #pragma clang diagnostic pop
 #endif
 
 {% endif %}
 {% endblock %}
 {##############################################################################}
 {% block install_accessors %}
 {% from 'attributes.cpp' import attribute_configuration with context %}
 {% if has_accessor_configuration %}
 static const V8DOMConfiguration::AccessorConfiguration {{v8_class}}Accessors[] = {
-    {# [Unforgeable] attributes in Window are defined as shadow_attributes, so
-       excluded here. #}
     {% for attribute in attributes
-       if not (attribute.exposed_test or
-               attribute.runtime_enabled_function) and
-          not attribute.is_data_type_property and
-          attribute.should_be_exposed_to_script and
-          not (interface_name == 'Window' and attribute.is_unforgeable) %}
+       if (attribute.is_expose_js_accessors and
+           not (attribute.is_static or
+                attribute.runtime_enabled_function or
+                attribute.exposed_test) and
+           attribute.should_be_exposed_to_script) %}
     {% filter conditional(attribute.conditional_string) %}
     {{attribute_configuration(attribute)}},
     {% endfilter %}
     {% endfor %}
 };
 
 {% endif %}
 {% endblock %}
 {##############################################################################}
 {% block install_methods %}
@@ skipping 77 matching lines @@
     ALLOW_UNUSED_LOCAL(prototypeTemplate);
     {% if has_access_check_callbacks %}
     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.exposed_test and
           not attribute.is_static %}
     {% filter conditional(attribute.conditional_string) %}
     if ({{attribute.runtime_enabled_function}}()) {
-        {% if attribute.is_data_type_property %}
-        static const V8DOMConfiguration::AttributeConfiguration attributeConfiguration = \
+        {% if attribute.is_expose_js_accessors %}
+        static const V8DOMConfiguration::AccessorConfiguration accessorConfiguration =\
+        {{attribute_configuration(attribute)}};
+        V8DOMConfiguration::installAccessor(isolate, instanceTemplate, prototypeTemplate, functionTemplate, defaultSignature, accessorConfiguration);
+        {% else %}
+        static const V8DOMConfiguration::AttributeConfiguration attributeConfiguration =\
         {{attribute_configuration(attribute)}};
         V8DOMConfiguration::installAttribute(isolate, instanceTemplate, prototypeTemplate, attributeConfiguration);
-        {% else %}
-        static const V8DOMConfiguration::AccessorConfiguration accessorConfiguration = \
-        {{attribute_configuration(attribute)}};
-        V8DOMConfiguration::installAccessor(isolate, instanceTemplate, prototypeTemplate, functionTemplate, defaultSignature, accessorConfiguration);
         {% endif %}
     }
     {% 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.
@@ skipping 83 matching lines @@
                               method.runtime_enabled_function) %}
     {% if method.is_do_not_check_security %}
     {{install_do_not_check_security_signature(method) | indent}}
     {% else %}{# is_do_not_check_security #}
     {{install_custom_signature(method) | indent}}
     {% endif %}{# is_do_not_check_security #}
     {% endfilter %}{# runtime_enabled() #}
     {% endfilter %}{# exposed() #}
     {% endfilter %}{# conditional() #}
     {% endfor %}
+    {% for attribute in attributes if attribute.is_static %}
+    {% set getter_callback = '%sV8Internal::%sAttributeGetterCallback' %
+               (cpp_class, attribute.name) %}
+    {% set setter_callback = '%sV8Internal::%sAttributeSetterCallback' %
+               (cpp_class, attribute.name)
+           if attribute.has_setter else '0' %}
+    {% filter conditional(attribute.conditional_string) %}
+    functionTemplate->SetNativeDataProperty(v8AtomicString(isolate, "{{attribute.name}}"), {{getter_callback}}, {{setter_callback}}, v8::External::New(isolate, 0), static_cast<v8::PropertyAttribute>(v8::None), v8::Local<v8::AccessorSignature>(), static_cast<v8::AccessControl>(v8::DEFAULT));
+    {% endfilter %}
+    {% endfor %}
     {# Special interfaces #}
     {% if not is_partial %}
     {% if interface_name == 'Window' %}
 
     prototypeTemplate->SetInternalFieldCount(V8Window::internalFieldCount);
     functionTemplate->SetHiddenPrototype(true);
     instanceTemplate->SetInternalFieldCount(V8Window::internalFieldCount);
     {% elif interface_name in [
            'HTMLDocument', 'DedicatedWorkerGlobalScope', 'CompositorWorkerGlobalScope',
            'SharedWorkerGlobalScope', 'ServiceWorkerGlobalScope'] %}
@@ skipping 24 matching lines @@
 {% 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
 {% endfilter %}