Add a layer of indirection between Frame and Page

Source/core/frame/Frame.h

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999-2001 Lars Knoll <knoll@kde.org>
  *                     1999-2001 Antti Koivisto <koivisto@kde.org>
  *                     2000-2001 Simon Hausmann <hausmann@kde.org>
  *                     2000-2001 Dirk Mueller <mueller@kde.org>
  *                     2000 Stefan Schimanski <1Stein@gmx.de>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
@@ skipping 37 matching lines @@
     class Color;
     class DOMWindow;
     class Document;
     class DragImage;
     class Editor;
     class Element;
     class EventHandler;
     class FetchContext;
     class FloatSize;
     class FrameDestructionObserver;
+    class FrameHost;
     class FrameSelection;
     class FrameView;
     class HTMLFrameOwnerElement;
     class HTMLTableCellElement;
     class InputMethodController;
     class IntPoint;
     class Node;
+    class Page;
     class Range;
     class RenderPart;
     class RenderView;
     class TreeScope;
     class ScriptController;
     class Settings;
     class SpellChecker;
     class TreeScope;
     class VisiblePosition;
     class Widget;
 
     class FrameInit : public RefCounted<FrameInit> {
     public:
         // For creating a dummy Frame
-        static PassRefPtr<FrameInit> create(int64_t frameID, Page* page, FrameLoaderClient* client)
+        static PassRefPtr<FrameInit> create(int64_t frameID, FrameHost* host, FrameLoaderClient* client)
         {
-            return adoptRef(new FrameInit(frameID, page, client));
+            return adoptRef(new FrameInit(frameID, host, client));
         }
 
+        int64_t frameID() const { return m_frameID; }
+
+        void setFrameHost(FrameHost* host) { m_frameHost = host; }
+        FrameHost* frameHost() const { return m_frameHost; }
+
         void setFrameLoaderClient(FrameLoaderClient* client) { m_client = client; }
         FrameLoaderClient* frameLoaderClient() const { return m_client; }
 
-        int64_t frameID() const { return m_frameID; }
-
-        void setPage(Page* page) { m_page = page; }
-        Page* page() const { return m_page; }
-
         void setOwnerElement(HTMLFrameOwnerElement* ownerElement) { m_ownerElement = ownerElement; }
         HTMLFrameOwnerElement* ownerElement() const { return m_ownerElement; }
 
     protected:
-        FrameInit(int64_t frameID, Page* page = 0, FrameLoaderClient* client = 0)
+        FrameInit(int64_t frameID, FrameHost* host = 0, FrameLoaderClient* client = 0)
             : m_frameID(frameID)
             , m_client(client)
-            , m_page(page)
+            , m_frameHost(host)
             , m_ownerElement(0)
         {
         }
 
     private:
         int64_t m_frameID;
         FrameLoaderClient* m_client;
-        Page* m_page;
+        FrameHost* m_frameHost;
         HTMLFrameOwnerElement* m_ownerElement;
     };
 
     class Frame : public RefCounted<Frame> {
     public:
         static PassRefPtr<Frame> create(PassRefPtr<FrameInit>);
 
         void init();
         void setView(PassRefPtr<FrameView>);
         void createView(const IntSize&, const Color&, bool,
             ScrollbarMode = ScrollbarAuto, bool horizontalLock = false,
             ScrollbarMode = ScrollbarAuto, bool verticalLock = false);
 
         ~Frame();
 
         void addDestructionObserver(FrameDestructionObserver*);
         void removeDestructionObserver(FrameDestructionObserver*);
 
-        void willDetachPage();
-        void detachFromPage();
+        void willDetachFrameHost();
+        void detachFromFrameHost();
         void disconnectOwnerElement();
 
+        // NOTE: Page is moving out of Blink up into the browser process as
+        // part of the site-isolation (out of process iframes) work.
+        // FrameHost should be used in stead where possible.
         Page* page() const;
+        FrameHost* host() const; // Null when the frame is detached.
+
         HTMLFrameOwnerElement* ownerElement() const;
         bool isMainFrame() const;
 
         void setDOMWindow(PassRefPtr<DOMWindow>);
         DOMWindow* domWindow() const;
         Document* document() const;
         FrameView* view() const;
 
         ChromeClient& chromeClient() const;
         Editor& editor() const;
         EventHandler& eventHandler() const;
         FrameLoader& loader() const;
         NavigationScheduler& navigationScheduler() const;
         FrameSelection& selection() const;
         FrameTree& tree() const;
         AnimationController& animation() const;
         InputMethodController& inputMethodController() const;
         FetchContext& fetchContext() const { return loader().fetchContext(); }
         ScriptController& script();
         SpellChecker& spellChecker() const;
 
         RenderView* contentRenderer() const; // Root of the render tree for the document contained in this frame.
         RenderPart* ownerRenderer() const; // Renderer for the element that contains this frame.
 
         void dispatchVisibilityStateChangeEvent();
 
         int64_t frameID() const { return m_frameInit->frameID(); }
 
+        // FIXME: These should move to RemoteFrame once that exists.
+        // RemotePlatformLayer is only ever set for Frames which exist in another process.
         void setRemotePlatformLayer(blink::WebLayer* remotePlatformLayer) { m_remotePlatformLayer = remotePlatformLayer; }
         blink::WebLayer* remotePlatformLayer() const { return m_remotePlatformLayer; }
 
     // ======== All public functions below this point are candidates to move out of Frame into another class. ========
 
         bool inScope(TreeScope*) const;
 
         // See GraphicsLayerClient.h for accepted flags.
         String layerTreeAsText(unsigned flags = 0) const;
         String trackedRepaintRectsAsText() const;
@@ skipping 41 matching lines @@
 
         bool isURLAllowed(const KURL&) const;
 
     // ========
 
     private:
         Frame(PassRefPtr<FrameInit>);
 
         HashSet<FrameDestructionObserver*> m_destructionObservers;
 
-        Page* m_page;
+        FrameHost* m_host;
         mutable FrameTree m_treeNode;
         mutable FrameLoader m_loader;
         mutable NavigationScheduler m_navigationScheduler;
 
         RefPtr<FrameView> m_view;
         RefPtr<DOMWindow> m_domWindow;
 
         OwnPtr<ScriptController> m_script;
         const OwnPtr<Editor> m_editor;
         const OwnPtr<SpellChecker> m_spellChecker;
@@ skipping 84 matching lines @@
     inline void Frame::setInViewSourceMode(bool mode)
     {
         m_inViewSourceMode = mode;
     }
 
     inline FrameTree& Frame::tree() const
     {
         return m_treeNode;
     }
 
-    inline Page* Frame::page() const
-    {
-        return m_page;
-    }
-
     inline EventHandler& Frame::eventHandler() const
     {
         ASSERT(m_eventHandler);
         return *m_eventHandler;
     }
 
 } // namespace WebCore
 
 #endif // Frame_h