Add a FrameHostMsg_BeginNavigation IPC

content/browser/frame_host/render_frame_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_FRAME_HOST_MANAGER_H_
 #define CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_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/global_request_id.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/common/referrer.h"
 
 struct FrameHostMsg_BeginNavigation_Params;
+struct FrameMsg_Navigate_Params;
 
 namespace content {
 class BrowserContext;
 class CrossProcessFrameConnector;
 class CrossSiteTransferringRequest;
 class InterstitialPageImpl;
 class FrameTreeNode;
 class NavigationControllerImpl;
 class NavigationEntry;
 class NavigationEntryImpl;
 class NavigationRequest;
 class RenderFrameHost;
 class RenderFrameHostDelegate;
 class RenderFrameHostImpl;
 class RenderFrameHostManagerTest;
 class RenderFrameProxyHost;
 class RenderViewHost;
 class RenderViewHostImpl;
 class RenderWidgetHostDelegate;
 class RenderWidgetHostView;
 class TestWebContents;
 class WebUIImpl;
+struct NavigationCommitInfo;
 
 // Manages RenderFrameHosts for a FrameTreeNode.  This class acts as a state
 // machine to make cross-process navigations in a frame possible.
 class CONTENT_EXPORT RenderFrameHostManager : public NotificationObserver {
  public:
   // Functions implemented by our owner that we need.
   //
   // TODO(brettw) Clean this up! These are all the functions in WebContentsImpl
   // that are required to run this class. The design should probably be better
   // such that these are more clear.
@@ skipping 127 matching lines @@
   // Sets the pending Web UI for the pending navigation, ensuring that the
   // bindings are appropriate for the given NavigationEntry.
   void SetPendingWebUI(const NavigationEntryImpl& entry);
 
   // Called when we want to instruct the renderer to navigate to the given
   // navigation entry. It may create a new RenderFrameHost or re-use an existing
   // one. The RenderFrameHost to navigate will be returned. Returns NULL if one
   // could not be created.
   RenderFrameHostImpl* Navigate(const NavigationEntryImpl& entry);
 
+  // As part of the PlzNavigate refactoring project, sends a RequestNavigation
+  // IPC to the renderer to ask it to navigate. If no live renderer is present,
+  // then the navigation request will be sent directly to the
+  // ResourceDispatcherHost.
+  bool RequestNavigation(const NavigationEntryImpl& entry,
+                         const FrameMsg_Navigate_Params& navigate_params);
+
   // Instructs the various live views to stop. Called when the user directed the
   // page to stop loading.
   void Stop();
 
   // Notifies the regular and pending RenderViewHosts that a load is or is not
   // happening. Even though the message is only for one of them, we don't know
   // which one so we tell both.
   void SetIsLoading(bool is_loading);
 
   // Whether to close the tab or not when there is a hang during an unload
@@ skipping 39 matching lines @@
   void SwappedOut(RenderFrameHostImpl* render_frame_host);
 
   // Called when a renderer's frame navigates.
   void DidNavigateFrame(RenderFrameHostImpl* render_frame_host);
 
   // Called when a renderer sets its opener to null.
   void DidDisownOpener(RenderViewHost* render_view_host);
 
   // Helper method to create and initialize a RenderFrameHost.  If |swapped_out|
   // is true, it will be initially placed on the swapped out hosts list.
+  // Else if |is_speculative| is true, then it will used as a speculatively
+  // spawned renderer in the PlzNavigate navigation refactoring project.
   // Otherwise, it will be used for a pending cross-site navigation.
   // Returns the routing id of the *view* associated with the frame.
   int CreateRenderFrame(SiteInstance* instance,
                         int opener_route_id,
                         bool swapped_out,
-                        bool hidden);
+                        bool hidden,
+                        bool is_speculative);
 
   // 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);
     interstitial_page_ = interstitial_page;
   }
 
@@ skipping 33 matching lines @@
   void ClearPendingShutdownRFHForSiteInstance(int32 site_instance_id,
                                               RenderFrameHostImpl* rfh);
 
   // Deletes any proxy hosts associated with this node. Used during destruction
   // of WebContentsImpl.
   void ResetProxyHosts();
 
   // Used to start a navigation, part of browser-side navigation project.
   void OnBeginNavigation(const FrameHostMsg_BeginNavigation_Params& params);
 
+  // Used to signal the commit of a navigation request, part of PlzNavigate
+  // navigation refactoring project.
+  void CommitNavigation(const NavigationCommitInfo& info);
+
  private:
   friend class RenderFrameHostManagerTest;
   friend class TestWebContents;
 
   // Tracks information about a navigation while a cross-process transition is
   // in progress, in case we need to transfer it to a new RenderFrameHost.
   // When a request is being transferred, deleting the PendingNavigationParams,
   // and thus |cross_site_transferring_request|, will cancel the request being
   // transferred, unless its ReleaseRequest method has been called.
   struct PendingNavigationParams {
@@ skipping 69 matching lines @@
 
   // Returns an appropriate SiteInstance object for the given NavigationEntry,
   // possibly reusing the current SiteInstance.  If --process-per-tab is used,
   // this is only called when ShouldSwapBrowsingInstancesForNavigation returns
   // true.
   SiteInstance* GetSiteInstanceForEntry(
       const NavigationEntryImpl& entry,
       SiteInstance* current_instance,
       bool force_browsing_instance_swap);
 
+  // Creates a new RenderFrameHostImpl for the |new_instance| while respecting
+  // the opener route if needed. If |is_speculative| is true, then the newly
+  // created RFH will be stored in speculative_render_frame_host_, otherwise it
+  // will be stored in pending_render_frame_host_. Also returns a pointer to the
+  // newly created RFH.
+  RenderFrameHostImpl* CreateRenderFrameHostForCrossSite(
+      SiteInstance* old_instance,
+      SiteInstance* new_instance,
+      bool is_speculative);
+
   // Creates a RenderFrameHost and corresponding RenderViewHost if necessary.
   scoped_ptr<RenderFrameHostImpl> CreateRenderFrameHost(SiteInstance* instance,
                                                         int view_routing_id,
                                                         int frame_routing_id,
                                                         bool swapped_out,
                                                         bool hidden);
 
   // Sets up the necessary state for a new RenderViewHost with the given opener,
   // if necessary.  It creates a RenderFrameProxy in the target renderer process
   // with the given |proxy_routing_id|, which is used to route IPC messages when
   // in swapped out state.  Returns early if the RenderViewHost has already been
   // initialized for another RenderFrameHost.
   // TODO(creis): opener_route_id is currently for the RenderViewHost but should
   // be for the RenderFrame, since frames can have openers.
   bool InitRenderView(RenderViewHost* render_view_host,
                       int opener_route_id,
                       int proxy_routing_id,
                       bool for_main_frame);
 
+  // Initializes |dest_render_frame_host| and |render_frame_host_| if necessary
+  // before navigating.
+  bool InitRenderFrameHostsBeforeNavigation(
+      RenderFrameHostImpl* dest_render_frame_host);
+
+  // Returns the SiteInstance to use for the navigation.
+  SiteInstance* GetSiteInstanceForNavigation(const NavigationEntryImpl& entry);
+
   // 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 RenderFrameHosts in a SiteInstance. This is called to shutdown
   // frames when all the frames in a SiteInstance are confirmed to be swapped
   // out.
   void ShutdownRenderFrameHostsInSiteInstance(int32 site_instance_id);
 
@@ skipping 49 matching lines @@
   // associated with the navigation.
   scoped_ptr<RenderFrameHostImpl> pending_render_frame_host_;
 
   // Tracks information about any current pending cross-process navigation.
   scoped_ptr<PendingNavigationParams> pending_nav_params_;
 
   // Tracks information about any navigation paused after receiving response
   // headers.
   scoped_ptr<GlobalRequestID> response_started_id_;
 
+  // A RenderFrameHost speculatively created when receiving a navigation
+  // request. It should be used or deleted when the current navigation request
+  // commits.
+  scoped_ptr<RenderFrameHostImpl> speculative_render_frame_host_;
+
   // 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 RenderFrameProxyHosts.
   typedef base::hash_map<int32, RenderFrameProxyHost*> RenderFrameProxyHostMap;
   RenderFrameProxyHostMap proxy_hosts_;
@@ skipping 13 matching lines @@
   scoped_ptr<NavigationRequest> navigation_request_;
 
   base::WeakPtrFactory<RenderFrameHostManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_MANAGER_H_