v8binding: Initializes WindowProxy iff it's uninitialized.

third_party/WebKit/Source/bindings/core/v8/LocalWindowProxy.cpp

 /*
  * Copyright (C) 2008, 2009, 2011 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 48 matching lines @@
 #include "platform/heap/Handle.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/SecurityViolationReportingPolicy.h"
 #include "v8/include/v8.h"
 #include "wtf/Assertions.h"
 
 namespace blink {
 
 void LocalWindowProxy::disposeContext(GlobalDetachmentBehavior behavior) {
-  if (m_lifecycle != Lifecycle::ContextInitialized)
+  if (m_lifecycle != Lifecycle::ContextIsInitialized)
     return;
 
   ScriptState::Scope scope(m_scriptState.get());
   v8::Local<v8::Context> context = m_scriptState->context();
   // The embedder could run arbitrary code in response to the
   // willReleaseScriptContext callback, so all disposing should happen after
   // it returns.
   frame()->loader().client()->willReleaseScriptContext(context,
                                                        m_world->worldId());
   MainThreadDebugger::instance()->contextWillBeDestroyed(m_scriptState.get());
@@ skipping 17 matching lines @@
   }
 
   m_scriptState->disposePerContextData();
 
   // It's likely that disposing the context has created a lot of
   // garbage. Notify V8 about this so it'll have a chance of cleaning
   // it up when idle.
   V8GCForContextDispose::instance().notifyContextDisposed(
       frame()->isMainFrame());
 
-  DCHECK(m_lifecycle == Lifecycle::ContextInitialized);
-  m_lifecycle = Lifecycle::ContextDetached;
+  DCHECK_EQ(m_lifecycle, Lifecycle::ContextIsInitialized);
+  m_lifecycle = behavior == DetachGlobal ? Lifecycle::GlobalObjectIsDetached
+                                         : Lifecycle::FrameIsDetached;
 }
 
 void LocalWindowProxy::initialize() {
   TRACE_EVENT1("v8", "LocalWindowProxy::initialize", "isMainWindow",
                frame()->isMainFrame());
   SCOPED_BLINK_UMA_HISTOGRAM_TIMER(
       frame()->isMainFrame()
           ? "Blink.Binding.InitializeMainLocalWindowProxy"
           : "Blink.Binding.InitializeNonMainLocalWindowProxy");
 
@@ skipping 70 matching lines @@
                          m_globalProxy.newLocal(isolate()));
   }
   CHECK(!context.IsEmpty());
 
 #if DCHECK_IS_ON()
   didAttachGlobalObject();
 #endif
 
   m_scriptState = ScriptState::create(context, m_world);
 
-  // TODO(haraken): Currently we cannot enable the following DCHECK because
-  // an already detached window proxy can be re-initialized. This is wrong.
-  // DCHECK(m_lifecycle == Lifecycle::ContextUninitialized);
-  m_lifecycle = Lifecycle::ContextInitialized;
+  DCHECK(m_lifecycle == Lifecycle::ContextIsUninitialized ||
+         m_lifecycle == Lifecycle::GlobalObjectIsDetached);
+  m_lifecycle = Lifecycle::ContextIsInitialized;
   DCHECK(m_scriptState->contextIsValid());
 }
 
 void LocalWindowProxy::setupWindowPrototypeChain() {
   // Associate the window wrapper object and its prototype chain with the
   // corresponding native DOMWindow object.
   DOMWindow* window = frame()->domWindow();
   const WrapperTypeInfo* wrapperTypeInfo = window->wrapperTypeInfo();
   v8::Local<v8::Context> context = m_scriptState->context();
 
@@ skipping 95 matching lines @@
 
   // NOTE: V8 does identity comparison in fast path, must use a symbol
   // as the security token.
   context->SetSecurityToken(v8AtomicString(isolate(), token));
 }
 
 void LocalWindowProxy::updateDocument() {
   DCHECK(m_world->isMainWorld());
   // For an uninitialized main window proxy, there's nothing we need
   // to update. The update is done when the window proxy gets initialized later.
-  if (m_lifecycle == Lifecycle::ContextUninitialized)
+  if (m_lifecycle == Lifecycle::ContextIsUninitialized)
     return;
 
-  // If this WindowProxy was previously initialized, reinitialize it now to
-  // preserve JS object identity. Otherwise, extant references to the
-  // WindowProxy will be broken.
-  if (m_lifecycle == Lifecycle::ContextDetached) {
+  // For a navigated-away window proxy, reinitialize it as a new window with new
+  // context and document.
+  if (m_lifecycle == Lifecycle::GlobalObjectIsDetached) {
     initialize();
-    DCHECK_EQ(Lifecycle::ContextInitialized, m_lifecycle);
+    DCHECK_EQ(Lifecycle::ContextIsInitialized, m_lifecycle);
     // Initialization internally updates the document properties, so just
     // return afterwards.
     return;
   }
 
   updateDocumentInternal();
 }
 
 void LocalWindowProxy::updateDocumentInternal() {
   updateActivityLogger();
@@ skipping 45 matching lines @@
           ->GetRealNamedPropertyInPrototypeChain(
               info.GetIsolate()->GetCurrentContext(), property.As<v8::String>())
           .ToLocal(&value))
     v8SetReturnValue(info, value);
 }
 
 void LocalWindowProxy::namedItemAdded(HTMLDocument* document,
                                       const AtomicString& name) {
   DCHECK(m_world->isMainWorld());
 
-  // Context must be initialized before this point.
-  DCHECK(m_lifecycle >= Lifecycle::ContextInitialized);
-  // TODO(yukishiino): Is it okay to not update named properties
-  // after the context gets detached?
-  if (m_lifecycle == Lifecycle::ContextDetached)
+  // Currently only contexts in attached frames can change the named items.
+  // TODO(yukishiino): Support detached frame's case, too, since the spec is not
+  // saying that the document needs to be attached to the DOM.
+  // https://html.spec.whatwg.org/C/dom.html#dom-document-nameditem
+  DCHECK(m_lifecycle == Lifecycle::ContextIsInitialized);
+  // TODO(yukishiino): Remove the following if-clause due to the above DCHECK.
+  if (m_lifecycle != Lifecycle::ContextIsInitialized)
     return;
 
   ScriptState::Scope scope(m_scriptState.get());
   v8::Local<v8::Object> documentWrapper =
       m_world->domDataStore().get(document, isolate());
-  // TODO(yukishiino,peria): We should check if the own property with the same
-  // name already exists or not, and if it exists, we shouldn't define a new
-  // accessor property (it fails).
   documentWrapper->SetAccessor(isolate()->GetCurrentContext(),
                                v8String(isolate(), name), getter).ToChecked();
 }
 
 void LocalWindowProxy::namedItemRemoved(HTMLDocument* document,
                                         const AtomicString& name) {
   DCHECK(m_world->isMainWorld());
 
-  // Context must be initialized before this point.
-  DCHECK(m_lifecycle >= Lifecycle::ContextInitialized);
-  // TODO(yukishiino): Is it okay to not update named properties
-  // after the context gets detached?
-  if (m_lifecycle == Lifecycle::ContextDetached)
+  // Currently only contexts in attached frames can change the named items.
+  // TODO(yukishiino): Support detached frame's case, too, since the spec is not
+  // saying that the document needs to be attached to the DOM.
+  // https://html.spec.whatwg.org/C/dom.html#dom-document-nameditem
+  DCHECK(m_lifecycle == Lifecycle::ContextIsInitialized);
+  // TODO(yukishiino): Remove the following if-clause due to the above DCHECK.
+  if (m_lifecycle != Lifecycle::ContextIsInitialized)
     return;
 
   if (document->hasNamedItem(name) || document->hasExtraNamedItem(name))
     return;
   ScriptState::Scope scope(m_scriptState.get());
   v8::Local<v8::Object> documentWrapper =
       m_world->domDataStore().get(document, isolate());
   documentWrapper
       ->Delete(isolate()->GetCurrentContext(), v8String(isolate(), name))
       .ToChecked();
 }
 
 void LocalWindowProxy::updateSecurityOrigin(SecurityOrigin* origin) {
-  // For an uninitialized main window proxy, there's nothing we need
-  // to update. The update is done when the window proxy gets initialized later.
-  if (m_lifecycle == Lifecycle::ContextUninitialized)
-    return;
-  // TODO(yukishiino): Is it okay to not update security origin when the context
-  // is detached?
-  if (m_lifecycle == Lifecycle::ContextDetached)
+  // For an uninitialized window proxy, there's nothing we need to update. The
+  // update is done when the window proxy gets initialized later.
+  if (m_lifecycle == Lifecycle::ContextIsUninitialized ||
+      m_lifecycle == Lifecycle::GlobalObjectIsDetached)
     return;
 
   setSecurityToken(origin);
 }
 
 LocalWindowProxy::LocalWindowProxy(v8::Isolate* isolate,
                                    LocalFrame& frame,
                                    RefPtr<DOMWrapperWorld> world)
     : WindowProxy(isolate, frame, std::move(world)) {}
 
 }  // namespace blink