bindings: Simplifies WindowProxyManager and its relation to Frame.

third_party/WebKit/Source/bindings/core/v8/WindowProxyManager.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef WindowProxyManager_h
 #define WindowProxyManager_h
 
 #include <utility>
 
 #include "bindings/core/v8/LocalWindowProxy.h"
 #include "bindings/core/v8/RemoteWindowProxy.h"
 #include "core/CoreExport.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/RemoteFrame.h"
 #include "platform/heap/Handle.h"
 #include "v8/include/v8.h"
 
 namespace blink {
 
 class DOMWrapperWorld;
 class SecurityOrigin;
-class ScriptController;
 
-class WindowProxyManagerBase : public GarbageCollected<WindowProxyManagerBase> {
+class WindowProxyManager : public GarbageCollected<WindowProxyManager> {
  public:
   DECLARE_TRACE();
 
   v8::Isolate* isolate() const { return m_isolate; }
 
   void clearForClose();
   void CORE_EXPORT clearForNavigation();
 
   void CORE_EXPORT
   releaseGlobals(HashMap<DOMWrapperWorld*, v8::Local<v8::Object>>&);
   void CORE_EXPORT
   setGlobals(const HashMap<DOMWrapperWorld*, v8::Local<v8::Object>>&);
 
+  bool isMainWorldContextInitialized() const {
+    return !m_windowProxy->contextIfInitialized().IsEmpty();

[dcheng, 2017/03/10 09:52:13]

Can we move this to LocalWindowProxyManager, since it's only used for local
frames?

[Yuki, 2017/03/10 15:21:51]

Done.

+  }
+
+  WindowProxy* mainWorldProxy() {
+    m_windowProxy->initializeIfNeeded();
+    return m_windowProxy;
+  }
+
+  WindowProxy* windowProxy(DOMWrapperWorld& world) {

[dcheng, 2017/03/10 09:52:13]

It's not necessary to do it now, but maybe there is possibility for cleanup here
in the future, since there are two ways to get to the main world proxy (and they
behave identically now)

[Yuki, 2017/03/10 15:21:51]

Acknowledged.

+    WindowProxy* windowProxy = windowProxyMaybeUninitialized(world);
+    windowProxy->initializeIfNeeded();
+    return windowProxy;
+  }
+
  protected:
   using IsolatedWorldMap = HeapHashMap<int, Member<WindowProxy>>;
 
-  explicit WindowProxyManagerBase(Frame&);
-
-  Frame* frame() const { return m_frame; }
-  WindowProxy* mainWorldProxy() const { return m_windowProxy.get(); }
-  WindowProxy* windowProxy(DOMWrapperWorld&);
-
-  IsolatedWorldMap& isolatedWorlds() { return m_isolatedWorlds; }
+  explicit WindowProxyManager(Frame&);
 
  private:
+  WindowProxy* windowProxyMaybeUninitialized(DOMWrapperWorld&);
+
   v8::Isolate* const m_isolate;
   const Member<Frame> m_frame;
+
+ protected:
   const Member<WindowProxy> m_windowProxy;
   IsolatedWorldMap m_isolatedWorlds;
 };
 
 template <typename FrameType, typename ProxyType>
-class WindowProxyManagerImplHelper : public WindowProxyManagerBase {
+class WindowProxyManagerImplHelper : public WindowProxyManager {
  private:
-  using Base = WindowProxyManagerBase;
+  using Base = WindowProxyManager;
 
  public:
-  FrameType* frame() const { return static_cast<FrameType*>(Base::frame()); }
-  ProxyType* mainWorldProxy() const {
+  ProxyType* mainWorldProxy() {
     return static_cast<ProxyType*>(Base::mainWorldProxy());
   }
   ProxyType* windowProxy(DOMWrapperWorld& world) {
     return static_cast<ProxyType*>(Base::windowProxy(world));
   }
 
  protected:
   explicit WindowProxyManagerImplHelper(Frame& frame)
-      : WindowProxyManagerBase(frame) {}
+      : WindowProxyManager(frame) {}
 };
 
 class LocalWindowProxyManager
     : public WindowProxyManagerImplHelper<LocalFrame, LocalWindowProxy> {
  public:
   static LocalWindowProxyManager* create(LocalFrame& frame) {
     return new LocalWindowProxyManager(frame);
   }
 
+  // TODO(yukishiino): Remove this method.
+  LocalWindowProxy* mainWorldProxyMaybeUninitialized() {
+    return static_cast<LocalWindowProxy*>(m_windowProxy.get());
+  }
+
   // Sets the given security origin to the main world's context.  Also updates
   // the security origin of the context for each isolated world.
   void updateSecurityOrigin(SecurityOrigin*);
 
  private:
-  // TODO(dcheng): Merge LocalWindowProxyManager and ScriptController?
-  friend class ScriptController;
-
   explicit LocalWindowProxyManager(LocalFrame& frame)
       : WindowProxyManagerImplHelper<LocalFrame, LocalWindowProxy>(frame) {}
 };
 
 class RemoteWindowProxyManager
     : public WindowProxyManagerImplHelper<RemoteFrame, RemoteWindowProxy> {
  public:
   static RemoteWindowProxyManager* create(RemoteFrame& frame) {
     return new RemoteWindowProxyManager(frame);
   }
 
  private:
   explicit RemoteWindowProxyManager(RemoteFrame& frame)
       : WindowProxyManagerImplHelper<RemoteFrame, RemoteWindowProxy>(frame) {}
 };
 
 }  // namespace blink
 
 #endif  // WindowProxyManager_h