IDL compiler: [InitializedByEventConstructor] attribute any

Source/bindings/templates/interface.cpp

 {% extends 'interface_base.cpp' %}
 
 
 {##############################################################################}
 {% macro attribute_configuration(attribute) %}
 {% set getter_callback =
        '%sV8Internal::%sAttributeGetterCallback' %
             (interface_name, attribute.name)
        if not attribute.constructor_type else
        '{0}V8Internal::{0}ConstructorGetter'.format(interface_name) %}
@@ skipping 145 matching lines @@
 {% block event_constructor %}
 {% if has_event_constructor %}
 static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1) {
         throwTypeError(ExceptionMessages::failedToConstruct("{{interface_name}}", "An event name must be provided."), info.GetIsolate());
         return;
     }
 
     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, type, info[0]);
+    {% for attribute in attributes if attribute.idl_type == 'any' %}
+    v8::Local<v8::Value> {{attribute.name}};
+    {% endfor %}
     {{cpp_class}}Init eventInit;
     if (info.Length() >= 2) {
         V8TRYCATCH_VOID(Dictionary, options, Dictionary(info[1], info.GetIsolate()));
         ExceptionState exceptionState(info.Holder(), info.GetIsolate());
         if (!initialize{{cpp_class}}(eventInit, options, exceptionState)) {
             exceptionState.throwIfNeeded();
             return;
         }
+        {# Store attributes of type |any| on the wrapper to avoid leaking them
+           between isolated worlds. #}
+        {% for attribute in attributes if attribute.idl_type == 'any' %}
+        options.get("{{attribute.name}}", {{attribute.name}});
+        if (!{{attribute.name}}.IsEmpty())
+            info.Holder()->SetHiddenValue(V8HiddenPropertyName::{{attribute.name}}(info.GetIsolate()), {{attribute.name}});
+        {% endfor %}
     }
     RefPtr<{{cpp_class}}> event = {{cpp_class}}::create(type, eventInit);
+    {% if has_any_type_attributes %}

[haraken, 2013/12/09 08:37:00]

Nit: You're passing the result of

  any(attribute for attribute in interface.attributes if attribute.idl_type ==
'any')

from the code generator to the template file as |has_any_type_attributes|. On
the other hand, you're writing

You're writing

  for attribute in attributes if attribute.idl_type == 'any'

in the template file.

Isn't there a better way to remove the redundancy?

[Nils Barth (inactive), 2013/12/09 09:55:01]

In this case, no, because we need to add a special case for
[Unserializable], which changes 2 of these 4 lists,
and thus this would get confusing if we try to abstract it away.
(It's a bit verbose, but the logic really is that verbose.)

In general I've been putting the filters directly at the loop sites,
so we can see directly from the template what's going on, and
to flatten the logic.

For example, we have:
{% for attribute in attributes if attribute.runtime_enabled_function %}
...instead of
template:
{% for attribute in runtime_enabled_attributes %}
Python:
runtime_enabled_attributes = [attribute for attribute in attributes if
attribute.runtime_enabled_function]

In this case there are 3 loops, so it's a bit redundant and we
could use an auxiliary variable for the loop range, but as noted, the
logic is about to get more complicated and we can't do this.

In the followup CL (implementing [Unserialized]) I'll see what we
can do to keep this simple.

+    {# If we're in an isolated world, create a SerializedScriptValue and store
+       it in the event for later cloning if the property is accessed from
+       another world. The main world case is handled lazily (in Custom code). #}

[haraken, 2013/12/09 08:37:00]

Custom => custom

[Nils Barth (inactive), 2013/12/09 09:55:01]

Done.

+    if (isolatedWorldForIsolate(info.GetIsolate())) {
+        {% for attribute in attributes if attribute.idl_type == 'any' %}
+        if (!{{attribute.name}}.IsEmpty())
+            event->{{attribute.set_serialized}}(SerializedScriptValue::createAndSwallowExceptions({{attribute.name}}, info.GetIsolate()));

[haraken, 2013/12/09 08:37:00]

set_serialized => set_serialized_script_value (since SerializedScriptValue is a
well-know class name) ?

[Nils Barth (inactive), 2013/12/09 09:55:01]

Done.

+        {% endfor %}
+    }
+
+    {% endif %}
     v8::Handle<v8::Object> wrapper = info.Holder();
     V8DOMWrapper::associateObjectWithWrapper<{{v8_class}}>(event.release(), &{{v8_class}}::wrapperTypeInfo, wrapper, info.GetIsolate(), WrapperConfiguration::Dependent);
     v8SetReturnValue(info, wrapper);
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
@@ skipping 68 matching lines @@
 {% if has_event_constructor %}
 bool initialize{{cpp_class}}({{cpp_class}}Init& eventInit, const Dictionary& options, ExceptionState& exceptionState, const String& forEventName)
 {
     Dictionary::ConversionContext conversionContext(forEventName.isEmpty() ? String("{{interface_name}}") : forEventName, "", exceptionState);
     {% if parent_interface %}{# any Event interface except Event itself #}
     if (!initialize{{parent_interface}}(eventInit, options, exceptionState, forEventName.isEmpty() ? String("{{interface_name}}") : forEventName))
         return false;
 
     {% endif %}
     {% for attribute in attributes
-           if attribute.is_initialized_by_event_constructor %}
+           if (attribute.is_initialized_by_event_constructor and
+               not attribute.idl_type == 'any')%}
     {# FIXME: implement [ImplementedAs] #}
     {# FIXME: implement [DeprecateAs] #}
     {# FIXME: special-case any #}
     {# FIXME: implement withPropertyAttributes #}
     if (!options.convert(conversionContext, "{{attribute.name}}", eventInit.{{attribute.name}}))
         return false;
     {% endfor %}
     return true;
 }
 
@@ skipping 358 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 %}