Move asserts for tracking global object detachment to WindowProxy.

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 74 matching lines @@
       // TODO(yukishiino): This DCHECK failed on Canary (M57) and Dev (M56).
       // We need to figure out why m_globalProxy != context->Global().
       DCHECK(m_globalProxy == context->Global());
       DCHECK_EQ(toScriptWrappable(context->Global()),
                 toScriptWrappable(
                     context->Global()->GetPrototype().As<v8::Object>()));
       m_globalProxy.get().SetWrapperClassId(0);
     }
     V8DOMWrapper::clearNativeInfo(isolate(), context->Global());
     m_scriptState->detachGlobalObject();
+
+#if DCHECK_IS_ON()
+    didDetachGlobalProxy();

[Yuki, 2017/03/09 07:15:17]

nit: Is this name appropriate?

The old implementation was tracking that a global object gets detached from a
global proxy.  didDetachGlobalProxy sounds like we're detaching a global proxy
rather than global object.  It looks weird to me.

[dcheng, 2017/03/09 07:19:56]

Hmm... so what we want to track here is that the fields on the global proxy were
cleared. If you have other suggestions for what to call this, I'm open to ideas.

[Yuki, 2017/03/09 07:26:31]

A global object of V8 must be tightly bound to a DOMWindow instance of Blink, so
it should be equivalent to track the detachment of a global object.

But if we want to emphasize the internal fields, we can call it
didDetachDOMWindow(Instance), didDetachGlobalAndDOMWindow or something like
that.

Anyway, I'm thinking we're detaching something from a global proxy, not a global
proxy from something, because we keep the global proxy as m_globalProxy.

[dcheng, 2017/03/09 08:00:52]

Remote contexts have an inner global object, so that receiver lookup when using
v8::Signature works. However, remote contexts don't (currently) have an
equivalent concept of global object detachment.
OK, makes sense. Renamed it to didDetachGlobalObject(). I'll figure out a way to
make the semantics work for a remote context.

+#endif
   }
 
   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());
 
@@ skipping 99 matching lines @@
   v8::Local<v8::Context> context = m_scriptState->context();
 
   // The global proxy object.  Note this is not the global object.
   v8::Local<v8::Object> globalProxy = context->Global();
   CHECK(m_globalProxy == globalProxy);
   V8DOMWrapper::setNativeInfo(isolate(), globalProxy, wrapperTypeInfo, window);
   // Mark the handle to be traced by Oilpan, since the global proxy has a
   // reference to the DOMWindow.
   m_globalProxy.get().SetWrapperClassId(wrapperTypeInfo->wrapperClassId);
 
+#if DCHECK_IS_ON()
+  didAttachGlobalProxy();
+#endif
+
   // The global object, aka window wrapper object.
   v8::Local<v8::Object> windowWrapper =
       globalProxy->GetPrototype().As<v8::Object>();
   windowWrapper = V8DOMWrapper::associateObjectWithWrapper(
       isolate(), window, wrapperTypeInfo, windowWrapper);
 
   // The prototype object of Window interface.
   v8::Local<v8::Object> windowPrototype =
       windowWrapper->GetPrototype().As<v8::Object>();
   CHECK(!windowPrototype.IsEmpty());
@@ skipping 207 matching lines @@
 
   setSecurityToken(origin);
 }
 
 LocalWindowProxy::LocalWindowProxy(v8::Isolate* isolate,
                                    LocalFrame& frame,
                                    RefPtr<DOMWrapperWorld> world)
     : WindowProxy(isolate, frame, std::move(world)) {}
 
 }  // namespace blink