Refactor WindowProxy into Local and Remote subclasses.

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

Index: third_party/WebKit/Source/bindings/core/v8/WindowProxyManager.h
diff --git a/third_party/WebKit/Source/bindings/core/v8/WindowProxyManager.h b/third_party/WebKit/Source/bindings/core/v8/WindowProxyManager.h
index e785aff91e4b21695a72637a0407f71273d9c028..a70c384d0242296dd1daa1e7f12bc0ca2fe7d931 100644
--- a/third_party/WebKit/Source/bindings/core/v8/WindowProxyManager.h
+++ b/third_party/WebKit/Source/bindings/core/v8/WindowProxyManager.h
@@ -5,52 +5,101 @@
 #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 "wtf/Vector.h"
 #include <utility>
 #include <v8.h>
 
 namespace blink {
 
 class DOMWrapperWorld;
-class Frame;
 class SecurityOrigin;
-class WindowProxy;
+class ScriptController;
 
-class CORE_EXPORT WindowProxyManager final
-    : public GarbageCollected<WindowProxyManager> {
+class WindowProxyManagerBase : public GarbageCollected<WindowProxyManagerBase> {
  public:
-  static WindowProxyManager* create(Frame&);
-
   DECLARE_TRACE();
 
-  Frame* frame() const { return m_frame.get(); }
   v8::Isolate* isolate() const { return m_isolate; }
-  WindowProxy* mainWorldProxy() const { return m_windowProxy.get(); }
 
+  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>>&);
+
+ 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&);
 
-  void clearForClose();
-  void clearForNavigation();
+  IsolatedWorldMap& isolatedWorlds() { return m_isolatedWorlds; }
+
+ private:
+  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 {
+ private:
+  using Base = WindowProxyManagerBase;
+
+ 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) {}
+};
+
+class LocalWindowProxyManager
+    : public WindowProxyManagerImplHelper<LocalFrame, LocalWindowProxy> {
+ public:
+  static LocalWindowProxyManager* create(LocalFrame& frame) {
+    return new LocalWindowProxyManager(frame);
+  }
 
   // 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*);
 
-  void releaseGlobals(HashMap<DOMWrapperWorld*, v8::Local<v8::Object>>&);
-  void setGlobals(const HashMap<DOMWrapperWorld*, v8::Local<v8::Object>>&);
-
  private:
-  typedef HeapHashMap<int, Member<WindowProxy>> IsolatedWorldMap;
+  // TODO(dcheng): Merge LocalWindowProxyManager and ScriptController?
+  friend class ScriptController;
 
-  explicit WindowProxyManager(Frame&);
+  explicit LocalWindowProxyManager(LocalFrame& frame)
+      : WindowProxyManagerImplHelper<LocalFrame, LocalWindowProxy>(frame) {}
+};
 
-  Member<Frame> m_frame;
-  v8::Isolate* const m_isolate;
+class RemoteWindowProxyManager
+    : public WindowProxyManagerImplHelper<RemoteFrame, RemoteWindowProxy> {
+ public:
+  static RemoteWindowProxyManager* create(RemoteFrame& frame) {
+    return new RemoteWindowProxyManager(frame);
+  }
 
-  const Member<WindowProxy> m_windowProxy;
-  IsolatedWorldMap m_isolatedWorlds;
+ private:
+  explicit RemoteWindowProxyManager(RemoteFrame& frame)
+      : WindowProxyManagerImplHelper<RemoteFrame, RemoteWindowProxy>(frame) {}
 };
 
 }  // namespace blink