[DRAFT] Create RenderFrameHostManager.

content/browser/frame_host/render_view_host_manager.h

 // Copyright 2013 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 CONTENT_BROWSER_FRAME_HOST_RENDER_VIEW_HOST_MANAGER_H_
 #define CONTENT_BROWSER_FRAME_HOST_RENDER_VIEW_HOST_MANAGER_H_
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/common/referrer.h"
 
 
 namespace content {
 class BrowserContext;
+class FrameTreeNode;
 class InterstitialPageImpl;
 class NavigationControllerImpl;
 class NavigationEntry;
 class NavigationEntryImpl;
+class RenderFrameHostImpl;
 class RenderViewHost;
 class RenderViewHostImpl;
 class RenderViewHostManagerTest;
 class RenderWidgetHostDelegate;
 class RenderWidgetHostView;
 class TestWebContents;
 class WebUIImpl;
 
 // Manages RenderViewHosts for a WebContentsImpl. Normally there is only one and
 // it is easy to do. But we can also have transitions of processes (and hence
@@ skipping 71 matching lines @@
     virtual ~Delegate() {}
   };
 
   // All three delegate pointers must be non-NULL and are not owned by this
   // class.  They must outlive this class. The RenderViewHostDelegate and
   // RenderWidgetHostDelegate are what will be installed into all
   // RenderViewHosts that are created.
   //
   // You must call Init() before using this class.
   RenderViewHostManager(
+      FrameTreeNode* frame_tree_node,
       RenderViewHostDelegate* render_view_delegate,
       RenderWidgetHostDelegate* render_widget_delegate,
       Delegate* delegate);
   virtual ~RenderViewHostManager();
 
   // For arguments, see WebContentsImpl constructor.
   void Init(BrowserContext* browser_context,
             SiteInstance* site_instance,
             int routing_id,
             int main_frame_routing_id);
 
   // Returns the currently active RenderViewHost.
   //
   // This will be non-NULL between Init() and Shutdown(). You may want to NULL
   // check it in many cases, however. Windows can send us messages during the
   // destruction process after it has been shut down.
+  // TODO(creis): Change to RenderFrameHostImpl.
   RenderViewHostImpl* current_host() const;
+  RenderFrameHostImpl* current_frame() const {
+    return render_frame_host_;
+  }
 
   // Returns the view associated with the current RenderViewHost, or NULL if
   // there is no current one.
   RenderWidgetHostView* GetRenderWidgetHostView() const;
 
   // Returns the pending render view host, or NULL if there is no pending one.
+  // TODO(creis): Change to RenderFrameHostImpl.
   RenderViewHostImpl* pending_render_view_host() const;
+  RenderFrameHostImpl* pending_render_frame_host() const;
 
   // Returns the current committed Web UI or NULL if none applies.
   WebUIImpl* web_ui() const { return web_ui_.get(); }
 
   // Returns the Web UI for the pending navigation, or NULL of none applies.
   WebUIImpl* pending_web_ui() const {
     return pending_web_ui_.get() ? pending_web_ui_.get() :
                                    pending_and_current_web_ui_.get();
   }
 
@@ skipping 18 matching lines @@
 
   // Whether to close the tab or not when there is a hang during an unload
   // handler. If we are mid-crosssite navigation, then we should proceed
   // with the navigation instead of closing the tab.
   bool ShouldCloseTabOnUnresponsiveRenderer();
 
   // The RenderViewHost has been swapped out, so we should resume the pending
   // network response and allow the pending RenderViewHost to commit.
   void SwappedOut(RenderViewHost* render_view_host);
 
+  // The RenderFrameHost has been swapped out, so we should resume the pending
+  // network response and allow the pending RenderFrameHost to commit.
+  void SwappedOutFrame(RenderFrameHostImpl* render_frame_host);
+
   // Called when a renderer's main frame navigates.
   void DidNavigateMainFrame(RenderViewHost* render_view_host);
 
   // Called when a renderer sets its opener to null.
   void DidDisownOpener(RenderViewHost* render_view_host);
 
   // Helper method to create a RenderViewHost.  If |swapped_out| is true, it
   // will be initially placed on the swapped out hosts list.  Otherwise, it
   // will be used for a pending cross-site navigation.
-  int CreateRenderView(SiteInstance* instance,
-                       int opener_route_id,
-                       bool swapped_out,
-                       bool hidden);
+  int CreateRenderFrame(SiteInstance* instance,
+                        int opener_route_id,
+                        bool swapped_out,
+                        bool hidden);
 
   // Called when a provisional load on the given renderer is aborted.
   void RendererAbortedProvisionalLoad(RenderViewHost* render_view_host);
 
   // Sets the passed passed interstitial as the currently showing interstitial.
   // |interstitial_page| should be non NULL (use the remove_interstitial_page
   // method to unset the interstitial) and no interstitial page should be set
   // when there is already a non NULL interstitial page set.
   void set_interstitial_page(InterstitialPageImpl* interstitial_page) {
     DCHECK(!interstitial_page_ && interstitial_page);
@@ skipping 25 matching lines @@
       int64 frame_id) OVERRIDE;
 
   // NotificationObserver implementation.
   virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) OVERRIDE;
 
   // Called when a RenderViewHost is about to be deleted.
   void RenderViewDeleted(RenderViewHost* rvh);
 
-  // Returns whether the given RenderViewHost is on the list of swapped out
-  // RenderViewHosts.
-  bool IsOnSwappedOutList(RenderViewHost* rvh) const;
+  // Returns whether the given RenderFrameHost is on the list of swapped out
+  // RenderFrameHosts.
+  bool IsRVHOnSwappedOutList(RenderViewHostImpl* rvh) const;
+  bool IsOnSwappedOutList(RenderFrameHostImpl* rfh) const;
 
   // Returns the swapped out RenderViewHost for the given SiteInstance, if any.
-  RenderViewHostImpl* GetSwappedOutRenderViewHost(SiteInstance* instance);
+  RenderViewHostImpl* GetSwappedOutRenderViewHost(SiteInstance* instance) const;
+  RenderFrameHostImpl* GetSwappedOutRenderFrameHost(
+      SiteInstance* instance) const;
 
   // Runs the unload handler in the current page, when we know that a pending
   // cross-process navigation is going to commit.  We may initiate a transfer
   // to a new process after this completes or times out.
   void SwapOutOldPage();
 
  private:
   friend class RenderViewHostManagerTest;
   friend class TestWebContents;
 
@@ skipping 55 matching lines @@
       const NavigationEntryImpl* new_entry) const;
 
   // Returns an appropriate SiteInstance object for the given NavigationEntry,
   // possibly reusing the current SiteInstance.
   // Never called if --process-per-tab is used.
   SiteInstance* GetSiteInstanceForEntry(
       const NavigationEntryImpl& entry,
       SiteInstance* curr_instance);
 
   // Sets up the necessary state for a new RenderViewHost with the given opener.
-  bool InitRenderView(RenderViewHost* render_view_host, int opener_route_id);
+  // This also initializes the RenderView if necessary.
+  // TODO(creis): opener_route_id is currently for the RenderView but should be
+  // the RenderFrame, since frames can have openers.
+  bool InitRenderView(RenderViewHost* render_view_host,
+                      int opener_route_id);
 
-  // Sets the pending RenderViewHost/WebUI to be the active one. Note that this
-  // doesn't require the pending render_view_host_ pointer to be non-NULL, since
-  // there could be Web UI switching as well. Call this for every commit.
+  // Sets the pending RenderFrameHost/WebUI to be the active one. Note that this
+  // doesn't require the pending render_frame_host_ pointer to be non-NULL,
+  // since there could be Web UI switching as well. Call this for every commit.
   void CommitPending();
 
-  // Shutdown all RenderViewHosts in a SiteInstance. This is called
-  // to shutdown views when all the views in a SiteInstance are
-  // confirmed to be swapped out.
-  void ShutdownRenderViewHostsInSiteInstance(int32 site_instance_id);
+  // Shutdown all RenderFrameHosts in a SiteInstance. This is called to shutdown
+  // frames when all the views in a SiteInstance are confirmed to be swapped
+  // out.
+  void ShutdownRenderFrameHostsInSiteInstance(int32 site_instance_id);
 
   // Helper method to terminate the pending RenderViewHost.
   void CancelPending();
 
-  RenderViewHostImpl* UpdateRendererStateForNavigate(
+  RenderFrameHostImpl* UpdateRendererStateForNavigate(
       const NavigationEntryImpl& entry);
 
   // Called when a renderer process is starting to close.  We should not
-  // schedule new navigations in its swapped out RenderViewHosts after this.
+  // schedule new navigations in its swapped out RenderFrameHosts after this.
   void RendererProcessClosing(RenderProcessHost* render_process_host);
 
+  // For use in creating RenderFrameHosts.
+  // TODO(creis): Feels awkward to have pointers in both directions.  Maybe use
+  // an ID here instead?
+  FrameTreeNode* frame_tree_node_;
+
   // Our delegate, not owned by us. Guaranteed non-NULL.
   Delegate* delegate_;
 
-  // Whether a navigation requiring different RenderView's is pending. This is
-  // either cross-site request is (in the new process model), or when required
-  // for the view type (like view source versus not).
+  // Whether a navigation requiring different RenderFrames is pending. This is
+  // either for cross-site requests or when required for the view type (like
+  // WebUI).
   bool cross_navigation_pending_;
 
-  // Implemented by the owner of this class, these delegates are installed into
+  // Implemented by the owner of this class. These delegates are installed into
   // all the RenderViewHosts that we create.
   RenderViewHostDelegate* render_view_delegate_;
   RenderWidgetHostDelegate* render_widget_delegate_;
 
-  // Our RenderView host and its associated Web UI (if any, will be NULL for
-  // non-DOM-UI pages). This object is responsible for all communication with
-  // a child RenderView instance.
-  RenderViewHostImpl* render_view_host_;
+  // Our RenderFrameHost and its associated Web UI (if any, will be NULL for
+  // non-Web-UI pages). This object is responsible for all communication with
+  // a child RenderFrame instance.
+  // For now, RenderFrameHost keeps a RenderViewHost in its SiteInstance alive.
+  // Eventually, RenderViewHost will be replaced with a page context.
+  RenderFrameHostImpl* render_frame_host_;
   scoped_ptr<WebUIImpl> web_ui_;
 
-  // A RenderViewHost used to load a cross-site page. This remains hidden
+  // A RenderFrameHost used to load a cross-site page. This remains hidden
   // while a cross-site request is pending until it calls DidNavigate. It may
   // have an associated Web UI, in which case the Web UI pointer will be non-
   // NULL.
   //
   // The |pending_web_ui_| may be non-NULL even when the
   // |pending_render_view_host_| is NULL. This will happen when we're
-  // transitioning between two Web UI pages: the RVH won't be swapped, so the
+  // transitioning between two Web UI pages: the RFH won't be swapped, so the
   // pending pointer will be unused, but there will be a pending Web UI
   // associated with the navigation.
-  RenderViewHostImpl* pending_render_view_host_;
+  RenderFrameHostImpl* pending_render_frame_host_;
 
   // Tracks information about any current pending cross-process navigation.
   scoped_ptr<PendingNavigationParams> pending_nav_params_;
 
   // If either of these is non-NULL, the pending navigation is to a chrome:
   // page. The scoped_ptr is used if pending_web_ui_ != web_ui_, the WeakPtr is
   // used for when they reference the same object. If either is non-NULL, the
   // other should be NULL.
   scoped_ptr<WebUIImpl> pending_web_ui_;
   base::WeakPtr<WebUIImpl> pending_and_current_web_ui_;
 
-  // A map of site instance ID to swapped out RenderViewHosts.  This may include
-  // pending_render_view_host_ for navigations to existing entries.
-  typedef base::hash_map<int32, RenderViewHostImpl*> RenderViewHostMap;
-  RenderViewHostMap swapped_out_hosts_;
+  // A map of site instance ID to swapped out RenderFrameHosts.  This may
+  // include pending_render_frame_host_ for navigations to existing entries.
+  typedef base::hash_map<int32, RenderFrameHostImpl*> RenderFrameHostMap;
+  RenderFrameHostMap swapped_out_hosts_;
 
   // The intersitial page currently shown if any, not own by this class
   // (the InterstitialPage is self-owned, it deletes itself when hidden).
   InterstitialPageImpl* interstitial_page_;
 
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewHostManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_VIEW_HOST_MANAGER_H_