IDL: Add any support to IDL dictionary and use it in CustomEventInit

Source/bindings/core/v8/custom/V8CustomEventCustom.cpp

Index: Source/bindings/core/v8/custom/V8CustomEventCustom.cpp
diff --git a/Source/bindings/core/v8/custom/V8CustomEventCustom.cpp b/Source/bindings/core/v8/custom/V8CustomEventCustom.cpp
index 29f8d8e26a8d1a0f09c99721ac89f69890f91410..6582206313410403d41cb3a0d143f19a0223234e 100644
--- a/Source/bindings/core/v8/custom/V8CustomEventCustom.cpp
+++ b/Source/bindings/core/v8/custom/V8CustomEventCustom.cpp
@@ -61,27 +61,21 @@ void V8CustomEvent::detailAttributeGetterCustom(const v8::PropertyCallbackInfo<v
         return;
     }
 
-    if (!event->serializedDetail()) {
-        // If we're in an isolated world and the event was created in the main world,
-        // we need to find the 'detail' property on the main world wrapper and clone it.
-        v8::Local<v8::Value> mainWorldDetail = V8HiddenValue::getHiddenValueFromMainWorldWrapper(info.GetIsolate(), event, V8HiddenValue::detail(info.GetIsolate()));
-        if (!mainWorldDetail.IsEmpty())
-            event->setSerializedDetail(SerializedScriptValueFactory::instance().createAndSwallowExceptions(info.GetIsolate(), mainWorldDetail));
-    }
-
-    if (event->serializedDetail()) {
-        result = event->serializedDetail()->deserialize();
-        v8SetReturnValue(info, cacheState(info.GetIsolate(), info.Holder(), result));
-        return;
-    }
-
-    v8SetReturnValue(info, cacheState(info.GetIsolate(), info.Holder(), v8::Null(info.GetIsolate())));
+    // Be careful not to return a V8 value which is created in different world.
+    v8::Local<v8::Value> detail;
+    if (SerializedScriptValue* serializedValue = event->serializedDetail())

[haraken, 2015/05/18 01:59:44]

This will be problematic in the following scenario:

1) An isolated world sets a detail. Then the serialized detail is set.
2) The main world sets a detail.
3) The main world accesses event.detail(). Then we expect that no
deserialization happens during detailAttributeGetterCustom, but it actually
happens (the serialized detail set in 1) is deserialized and returned).

Actually we want to avoid introducing unnecessary complexity here. What we need
is (just) not to regress performance of event.detail() called in the main world.

Can we probably change CustomEvent like:

  class CustomEvent {
    ScriptValue m_detailForMainWorld;
    RefPtr<SerializedScriptValue> m_serializedDetail;
  };

?

Then the detailAttributeGetterCustom() can do something like:

  if (DOMWrapperWorld::current().isMainWorld()) {
    return event->detailForMainWorld();
  }
  return event->serializedDetail()->deserialize();

[bashi, 2015/05/20 00:22:00]

As chatted offline, this CL doesn't invoke unnecessary
serialization/deserialization.
- 'detail' is a readonly attribute and is set only once (in constructor).
- When we create CustomEvent in a world W1 (no matter the world is main or an
isolated), 'detail' is set on a DOM object as a ScriptValue.
- If the world W1 accesses event.detail, we just use a V8 value which the
ScriptValue holds.
- If another world W2 accesses event.detail, we 'clone' the V8 value via
v8ValueFor().
- In both cases, once the getter callback is invoked, it caches the result as a
hidden property on the wrapper object and reuses it in following event.detail
access.

I prefer the current approach if relying on ScriptValue::scriptState() is safe
(I believe so).
- main/isolated world is a concept which should be handled by binding layer. It
would be better not to have world-specific members in DOM classes.
- Some other Events have 'any' attributes. We would want to have a common way to
avoid leaking V8 values between worlds.

WDYT?

+        detail = serializedValue->deserialize();
+    else
+        detail = event->detail().v8ValueFor(ScriptState::current(info.GetIsolate()));
+    // |detail| should be null when it is an empty handle because its default value is null.
+    if (detail.IsEmpty())
+        detail = v8::Null(info.GetIsolate());
+    v8SetReturnValue(info, cacheState(info.GetIsolate(), info.Holder(), detail));
 }
 
 void V8CustomEvent::initCustomEventMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     CustomEvent* event = V8CustomEvent::toImpl(info.Holder());
-    ASSERT(!event->serializedDetail());
 
     TOSTRING_VOID(V8StringResource<>, typeArg, info[0]);
     bool canBubbleArg;
@@ -92,12 +86,7 @@ void V8CustomEvent::initCustomEventMethodCustom(const v8::FunctionCallbackInfo<v
     v8::Local<v8::Value> detailsArg = info[3];
 
     event->initEvent(typeArg, canBubbleArg, cancelableArg);
-
-    if (!detailsArg.IsEmpty()) {
-        V8HiddenValue::setHiddenValue(info.GetIsolate(), info.Holder(), V8HiddenValue::detail(info.GetIsolate()), detailsArg);
-        if (DOMWrapperWorld::current(info.GetIsolate()).isIsolatedWorld())
-            event->setSerializedDetail(SerializedScriptValueFactory::instance().createAndSwallowExceptions(info.GetIsolate(), detailsArg));
-    }
+    event->setDetail(ScriptValue(ScriptState::current(info.GetIsolate()), detailsArg));
 }
 
 } // namespace blink