binding: Reimplements V8HiddenValue as V8PrivateProperty.

third_party/WebKit/Source/core/events/MessageEvent.cpp

 /*
  * Copyright (C) 2007 Henry Mason (hmason@mac.com)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 12 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
 
 #include "core/events/MessageEvent.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
+#include "bindings/core/v8/V8PrivateProperty.h"
 
 namespace blink {
 
 static inline bool isValidSource(EventTarget* source)
 {
     return !source || source->toLocalDOMWindow() || source->toMessagePort();
 }
 
 MessageEvent::MessageEvent()
     : m_dataType(DataTypeScriptValue)
@@ skipping 168 matching lines @@
     visitor->trace(m_ports);
     Event::trace(visitor);
 }
 
 v8::Local<v8::Object> MessageEvent::associateWithWrapper(v8::Isolate* isolate, const WrapperTypeInfo* wrapperType, v8::Local<v8::Object> wrapper)
 {
     wrapper = Event::associateWithWrapper(isolate, wrapperType, wrapper);
 
     // Ensures a wrapper is created for the data to return now so that V8 knows how
     // much memory is used via the wrapper. To keep the wrapper alive, it's set to
-    // the wrapper of the MessageEvent as a hidden value.
+    // the wrapper of the MessageEvent as a private value.
     switch (getDataType()) {
     case MessageEvent::DataTypeScriptValue:
     case MessageEvent::DataTypeSerializedScriptValue:
         break;
     case MessageEvent::DataTypeString:
-        V8HiddenValue::setHiddenValue(ScriptState::current(isolate), wrapper, V8HiddenValue::stringData(isolate), v8String(isolate, dataAsString()));
+        V8PrivateProperty::getMessageEventCachedData(isolate).set(wrapper, v8String(isolate, dataAsString()));

[haraken, 2016/05/24 17:33:53]

Another possible API would be:

  V8PrivateProperty::get(context, V8PrivateProperty::messageEventCacheData());
  V8PrivateProperty::set(context, V8PrivateProperty::messageEventCacheData());

V8PrivateProperty::messageEventCacheData() returns v8::Local<v8::Private>. With
this API, you don't need to create a Symbol object, which might decrease the
overhead of accessing private properties (I'm not sure).

[Ken Russell (switch to Gerrit), 2016/05/24 21:49:18]

In this scenario, would the private property be associated with the context, or
the MessageEvent?

WebGL uses V8HiddenValue to add properties to multiple types of objects: the JS
wrappers for WebGLRenderingContextBase, WebGLFramebuffer, WebGLProgram, etc. It
wouldn't work if it were only possible to hang private properties off of the JS
context.

[Yuki, 2016/05/26 10:52:11]

Symbol class only holds two simple members, so the overhead should be negligible
compared to a) creating a new v8::Symbol, or b) accessing a private property
through v8::Object::GetPrivate.  Especially when it's inlined, the cost will be
zero.

Another option in my mind is to move the initialization of
ScopedPersistent<v8::Private> members in V8PrivateProperty into the constructor.
 Then, we don't need any check in getMessageEventCachedData() if we need to
create a new v8::Symbol or not.  Then, it's highly likely that everything will
be inlined and optimized.

         break;
     case MessageEvent::DataTypeBlob:
         break;
     case MessageEvent::DataTypeArrayBuffer:
-        V8HiddenValue::setHiddenValue(ScriptState::current(isolate), wrapper, V8HiddenValue::arrayBufferData(isolate), toV8(dataAsArrayBuffer(), wrapper, isolate));
+        V8PrivateProperty::getMessageEventCachedData(isolate).set(wrapper, toV8(dataAsArrayBuffer(), wrapper, isolate));
         break;
     }
 
     return wrapper;
 }
 
 } // namespace blink