Stop storing ScriptValue in MessageEvent

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

 /*
  * Copyright (C) 2007 Henry Mason (hmason@mac.com)
  * Copyright (C) 2003, 2004, 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.
@@ skipping 13 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.
  *
  */
 
 #ifndef MessageEvent_h
 #define MessageEvent_h
 
 #include <memory>
 #include "bindings/core/v8/SerializedScriptValue.h"
+#include "bindings/core/v8/TraceWrapperV8Reference.h"
 #include "core/CoreExport.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/MessagePort.h"
 #include "core/events/Event.h"
 #include "core/events/EventTarget.h"
 #include "core/events/MessageEventInit.h"
 #include "core/fileapi/Blob.h"
 #include "platform/wtf/Compiler.h"
 
 namespace blink {
@@ skipping 78 matching lines @@
   const String& lastEventId() const { return last_event_id_; }
   EventTarget* source() const { return source_.Get(); }
   MessagePortArray ports(bool& is_null) const;
   MessagePortArray ports() const;
 
   MessagePortChannelArray ReleaseChannels() { return std::move(channels_); }
 
   const AtomicString& InterfaceName() const override;
 
   enum DataType {
-    kDataTypeScriptValue,
+    kDataTypeV8Reference,
     kDataTypeSerializedScriptValue,
     kDataTypeString,
     kDataTypeBlob,
     kDataTypeArrayBuffer
   };
   DataType GetDataType() const { return data_type_; }
-  ScriptValue DataAsScriptValue() const {
-    DCHECK_EQ(data_type_, kDataTypeScriptValue);
-    return data_as_script_value_;
-  }
+  ScriptValue DataAsScriptValue(ScriptState*) const;
   SerializedScriptValue* DataAsSerializedScriptValue() const {
     DCHECK_EQ(data_type_, kDataTypeSerializedScriptValue);
     return data_as_serialized_script_value_.Get();
   }
   String DataAsString() const {
     DCHECK_EQ(data_type_, kDataTypeString);
     return data_as_string_;
   }
   Blob* DataAsBlob() const {
     DCHECK_EQ(data_type_, kDataTypeBlob);
     return data_as_blob_.Get();
   }
   DOMArrayBuffer* DataAsArrayBuffer() const {
     DCHECK_EQ(data_type_, kDataTypeArrayBuffer);
     return data_as_array_buffer_.Get();
   }
 
   void SetSerializedData(PassRefPtr<SerializedScriptValue> data) {
     DCHECK(!data_as_serialized_script_value_);
     data_as_serialized_script_value_ = std::move(data);
   }
 
   void EntangleMessagePorts(ExecutionContext*);
 
   DECLARE_VIRTUAL_TRACE();
 
+  DECLARE_VIRTUAL_TRACE_WRAPPERS();
+
   WARN_UNUSED_RESULT v8::Local<v8::Object> AssociateWithWrapper(
       v8::Isolate*,
       const WrapperTypeInfo*,
       v8::Local<v8::Object> wrapper) override;
 
  private:
   MessageEvent();
   MessageEvent(const AtomicString&, const MessageEventInit&);
   MessageEvent(const String& origin,
                const String& last_event_id,
@@ skipping 15 matching lines @@
 
   MessageEvent(const String& data,
                const String& origin,
                const String& suborigin);
   MessageEvent(Blob* data, const String& origin, const String& suborigin);
   MessageEvent(DOMArrayBuffer* data,
                const String& origin,
                const String& suborigin);
 
   DataType data_type_;
-  ScriptValue data_as_script_value_;
+  TraceWrapperV8Reference<v8::Value> data_as_v8_value_reference_;

[haraken, 2017/05/02 08:10:14]

In a follow-up CL, I'd prefer introducing:

  WorldAwareV8Reference<v8::Value> ...;

which takes care of all the complexity about the per-world wrappers. Then we can
remove ScriptValue.V8ValueFor().

[bashi, 2017/05/02 08:46:22]

Agreed that we should have such class or mechanism. I'll try to think about it
next week.

   RefPtr<SerializedScriptValue> data_as_serialized_script_value_;
   String data_as_string_;
   Member<Blob> data_as_blob_;
   Member<DOMArrayBuffer> data_as_array_buffer_;
   String origin_;
   String last_event_id_;
   Member<EventTarget> source_;
   // m_ports are the MessagePorts in an entangled state, and m_channels are
   // the MessageChannels in a disentangled state. Only one of them can be
   // non-empty at a time. entangleMessagePorts() moves between the states.
   Member<MessagePortArray> ports_;
   MessagePortChannelArray channels_;
   String suborigin_;
 };
 
 }  // namespace blink
 
 #endif  // MessageEvent_h