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 "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 <utility>
 #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>>&);
 
+  Frame* frame() const { return m_frame; }
+  WindowProxy* windowProxy(DOMWrapperWorld& world) {
+    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&);
+  explicit WindowProxyManager(Frame&);
 
   IsolatedWorldMap& isolatedWorlds() { return m_isolatedWorlds; }
 
+  WindowProxy* mainWorldProxyMaybeUninitialized() {
+    return m_windowProxy;
+  }
+
  private:
+  WindowProxy* windowProxyMaybeUninitialized(DOMWrapperWorld&);
+
   v8::Isolate* const m_isolate;
   const Member<Frame> m_frame;
   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 {
-    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);
   }
 
+  LocalWindowProxy* mainWorldProxyMaybeUninitialized() {

[dcheng, 2017/02/22 01:07:06]

I would prefer not to expose this publicly if possible. My original approach was
to find the things that depended on this (there aren't that many) and add
explicit helpers for them.

[Yuki, 2017/02/22 09:01:33]

Hmm, I added WindowProxy::isInitialized() and changed ScriptController to use
it.  See PS2.  This way, we don't need to expose ...MaybeUninitialized, however,
now the decision making is moved from WindowProxy to ScriptController about
whether we can skip task X on WindowProxy.  I'm on the fence which is better,
and I'm fine with either way.

+    return static_cast<LocalWindowProxy*>(
+        WindowProxyManagerImplHelper<LocalFrame, LocalWindowProxy>::
+        mainWorldProxyMaybeUninitialized());
+  }
+
   // 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