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 151 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 %}
+    {# 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). #}
+    if (isolatedWorldForIsolate(info.GetIsolate())) {
+        {% for attribute in attributes if attribute.idl_type == 'any' %}
+        if (!{{attribute.name}}.IsEmpty())
+            event->{{attribute.set_serialized_script_value}}(SerializedScriptValue::createAndSwallowExceptions({{attribute.name}}, info.GetIsolate()));
+        {% 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 %}