Reland: Don't store ScriptValue in PopStateEvent

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

 /*
  * Copyright (C) 2009 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 14 matching lines @@
  */
 
 #include "core/events/PopStateEvent.h"
 
 #include "bindings/core/v8/SerializedScriptValue.h"
 #include "core/frame/History.h"
 
 namespace blink {
 
 PopStateEvent::PopStateEvent()
-    : serialized_state_(nullptr), history_(nullptr) {}
+    : serialized_state_(nullptr), state_(this), history_(nullptr) {}
 
-PopStateEvent::PopStateEvent(const AtomicString& type,
+PopStateEvent::PopStateEvent(ScriptState* script_state,
+                             const AtomicString& type,
                              const PopStateEventInit& initializer)
-    : Event(type, initializer), history_(nullptr) {
-  if (initializer.hasState())
-    state_ = initializer.state();
+    : Event(type, initializer), state_(this), history_(nullptr) {
+  if (initializer.hasState()) {
+    world_ = RefPtr<DOMWrapperWorld>(script_state->World());
+    state_.Set(initializer.state().GetIsolate(), initializer.state().V8Value());
+  }
 }
 
 PopStateEvent::PopStateEvent(PassRefPtr<SerializedScriptValue> serialized_state,
                              History* history)
     : Event(EventTypeNames::popstate, false, true),
       serialized_state_(std::move(serialized_state)),
+      state_(this),
       history_(history) {}
 
 PopStateEvent::~PopStateEvent() {}
 
+ScriptValue PopStateEvent::state(ScriptState* script_state) const {
+  if (state_.IsEmpty())
+    return ScriptValue();
+
+  v8::Isolate* isolate = script_state->GetIsolate();
+  if (world_->GetWorldId() != script_state->World().GetWorldId()) {
+    v8::Local<v8::Value> value = state_.NewLocal(isolate);
+    RefPtr<SerializedScriptValue> serialized =
+        SerializedScriptValue::SerializeAndSwallowExceptions(isolate, value);
+    return ScriptValue(script_state, serialized->Deserialize(isolate));
+  }
+  return ScriptValue(script_state, state_.NewLocal(isolate));
+}
+
 PopStateEvent* PopStateEvent::Create() {
   return new PopStateEvent;
 }
 
 PopStateEvent* PopStateEvent::Create(
     PassRefPtr<SerializedScriptValue> serialized_state,
     History* history) {
   return new PopStateEvent(std::move(serialized_state), history);
 }
 
-PopStateEvent* PopStateEvent::Create(const AtomicString& type,
+PopStateEvent* PopStateEvent::Create(ScriptState* script_state,
+                                     const AtomicString& type,
                                      const PopStateEventInit& initializer) {
-  return new PopStateEvent(type, initializer);
+  return new PopStateEvent(script_state, type, initializer);
 }
 
 const AtomicString& PopStateEvent::InterfaceName() const {
   return EventNames::PopStateEvent;
 }
 
 DEFINE_TRACE(PopStateEvent) {
   visitor->Trace(history_);
   Event::Trace(visitor);
 }
 
+DEFINE_TRACE_WRAPPERS(PopStateEvent) {
+  visitor->TraceWrappers(state_);
+  Event::TraceWrappers(visitor);
+}
+
 }  // namespace blink