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

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

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 43 matching lines @@
 {
     CustomEvent* event = V8CustomEvent::toImpl(info.Holder());
 
     v8::Local<v8::Value> result = V8HiddenValue::getHiddenValue(info.GetIsolate(), info.Holder(), V8HiddenValue::detail(info.GetIsolate()));
 
     if (!result.IsEmpty()) {
         v8SetReturnValue(info, result);
         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;
     bool cancelableArg;
     if (!v8Call(info[1]->BooleanValue(info.GetIsolate()->GetCurrentContext()), canBubbleArg)
         || !v8Call(info[2]->BooleanValue(info.GetIsolate()->GetCurrentContext()), cancelableArg))
         return;
     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