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 86 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::ContextInitialized);
+  m_lifecycle = behavior == DetachGlobal ? Lifecycle::GlobalObjectDetached
+                                         : Lifecycle::ContextDetachedFromFrame;
 }
 
 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);
+  DCHECK(m_lifecycle == Lifecycle::ContextUninitialized ||
+         m_lifecycle == Lifecycle::GlobalObjectDetached);
   m_lifecycle = Lifecycle::ContextInitialized;
   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 99 matching lines @@
   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)
     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::GlobalObjectDetached) {
     initialize();
     DCHECK_EQ(Lifecycle::ContextInitialized, m_lifecycle);
     // Initialization internally updates the document properties, so just
     // return afterwards.
     return;
   }
 
   updateDocumentInternal();
 }
 
@@ skipping 48 matching lines @@
               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)
-    return;
+  DCHECK(m_lifecycle == Lifecycle::ContextInitialized ||
+         m_lifecycle == Lifecycle::ContextDetachedFromFrame);

[haraken, 2017/03/28 11:12:42]

I might want to change this to CHECK.

Are you pretty sure that we don't hit this path with m_lifecycle being
Lifecycle::GlobalObjectDetached?

[Yuki, 2017/03/28 12:22:16]

Hmm, IIUC, the guideline suggests DCHECK for detecting programming errors, and
we're using DCHECK for all other places about m_lifecycle.
Yes.  If the state is GlobalObjectDetached, then

    windowProxy(world)->namedItemAdded(...);

triggers the re-initialization of WindowProxy.  After that, the state must be
ContextInitialized.

 
   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)
-    return;
+  DCHECK(m_lifecycle == Lifecycle::ContextInitialized ||
+         m_lifecycle == Lifecycle::ContextDetachedFromFrame);

[haraken, 2017/03/28 11:12:42]

Ditto.

[Yuki, 2017/03/28 12:22:16]

Ditto.

 
   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)
+
+  if (m_lifecycle == Lifecycle::GlobalObjectDetached)

[haraken, 2017/03/28 11:12:42]

Why can't this be:

  DCHECK(m_lifecycle == Lifecycle::ContextInitialized || m_lifecycle ==
Lifecycle::ContextDetachedFromFrame);

?

[Yuki, 2017/03/28 12:22:16]

It seems that I confused you.  In case of GlobalObjectDetached, the WindowProxy
is expected to be re-initialized as same as ContextUninitialized.  I've updated
this part of code as well as the comment at WindowProxy::Lifecycle in
WindowProxy.h.

In short, the state after a navigation remains being GlobalObjectDetached until
it gets re-initialized on demand, mostly the same as ContextUninitialized.  So
it's possible to be GlobalObjectDetached here.

     return;
 
   setSecurityToken(origin);
 }
 
 LocalWindowProxy::LocalWindowProxy(v8::Isolate* isolate,
                                    LocalFrame& frame,
                                    RefPtr<DOMWrapperWorld> world)
     : WindowProxy(isolate, frame, std::move(world)) {}
 
 }  // namespace blink