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 20 matching lines @@
 
 #include <memory>
 #include "bindings/core/v8/serialization/SerializedScriptValue.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/bindings/DOMWrapperWorld.h"
+#include "platform/bindings/TraceWrapperV8Reference.h"
 #include "platform/wtf/Compiler.h"
 
 namespace blink {
 
 class CORE_EXPORT MessageEvent final : public Event {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
   static MessageEvent* Create() { return new MessageEvent; }
   static MessageEvent* Create(MessagePortArray* ports,
@@ skipping 29 matching lines @@
   static MessageEvent* Create(Blob* data,
                               const String& origin = String(),
                               const String& suborigin = String()) {
     return new MessageEvent(data, origin, suborigin);
   }
   static MessageEvent* Create(DOMArrayBuffer* data,
                               const String& origin = String(),
                               const String& suborigin = String()) {
     return new MessageEvent(data, origin, suborigin);
   }
-  static MessageEvent* Create(const AtomicString& type,
+  static MessageEvent* Create(ScriptState*,
+                              const AtomicString& type,
                               const MessageEventInit& initializer,
                               ExceptionState&);
   ~MessageEvent() override;
 
-  void initMessageEvent(const AtomicString& type,
+  void initMessageEvent(ScriptState*,
+                        const AtomicString& type,
                         bool can_bubble,
                         bool cancelable,
                         ScriptValue data,
                         const String& origin,
                         const String& last_event_id,
                         EventTarget* source,
                         MessagePortArray*);
   void initMessageEvent(const AtomicString& type,
                         bool can_bubble,
                         bool cancelable,
@@ skipping 16 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(ScriptState*, const AtomicString&, const MessageEventInit&);
   MessageEvent(const String& origin,
                const String& last_event_id,
                EventTarget* source,
                MessagePortArray*,
                const String& suborigin);
   MessageEvent(PassRefPtr<SerializedScriptValue> data,
                const String& origin,
                const String& last_event_id,
                EventTarget* source,
                MessagePortArray*,
                const String& suborigin);
   MessageEvent(PassRefPtr<SerializedScriptValue> data,
                const String& origin,
                const String& last_event_id,
                EventTarget* source,
                MessagePortChannelArray,
                const String& suborigin);
 
   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_;
+  RefPtr<DOMWrapperWorld> world_;
+  TraceWrapperV8Reference<v8::Value> data_as_v8_value_reference_;
   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