PlzNavigate: implement RequestNavigation in the no live renderer case

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 RenderFrameHost;
 class RenderFrameHostImpl;
 class RenderFrameHostManagerTest;
 class RenderFrameProxyHost;
 class RenderViewHost;
 class RenderViewHostImpl;
 class RenderWidgetHostDelegate;
 class RenderWidgetHostView;
 class TestWebContents;
 class WebUIImpl;
+struct NavigationBeforeCommitInfo;
 
 // 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.
   //
   // There is additional complexity that some of the functions we need in
   // WebContentsImpl are inherited and non-virtual. These are named with
   // "RenderManager" so that the duplicate implementation of them will be clear.
+  //
+  // Functions and parameters whose description are prefixed by PlzNavigate are
+  // part of a navigation refactoring project, currently behind the
+  // enable-browser-side-navigation flag. The idea is to move the logic behind
+  // driving navigations from the renderer to the browser.
   class CONTENT_EXPORT Delegate {
    public:
     // Initializes the given renderer if necessary and creates the view ID
     // corresponding to this view host. If this method is not called and the
     // process is not shared, then the WebContentsImpl will act as though the
     // renderer is not running (i.e., it will render "sad tab"). This method is
     // automatically called from LoadURL. |for_main_frame_navigation| indicates
     // whether this RenderViewHost is used to render a top-level frame, so the
     // appropriate RenderWidgetHostView type is used.
     virtual bool CreateRenderViewForRenderManager(
@@ skipping 116 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);
 
+  // PlzNavigate: 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.
-  // 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 for_main_frame_navigation,
                         bool hidden);
 
   // Helper method to create and initialize a RenderFrameProxyHost and return
   // its routing id.
   int CreateRenderFrameProxy(SiteInstance* instance);
@@ skipping 40 matching lines @@
   void SwapOutOldPage();
 
   // Deletes a RenderFrameHost that was pending shutdown.
   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);
+  // PlzNavigate: Used to start a navigation.

[Charlie Reis, 2014/08/08 20:25:29]

Let's explain whether this happens before or after RequestNavigation.

[clamy, 2014/08/12 12:13:16]

Done.

+  void OnBeginNavigation(const FrameHostMsg_BeginNavigation_Params& params,
+                         const NavigationEntryImpl& entry);
 
   // Returns the routing id for a RenderFrameHost or RenderFrameHostProxy
   // that has the given SiteInstance and is associated with this
   // RenderFrameHostManager. Returns MSG_ROUTING_NONE if none is found.
   int GetRoutingIdForSiteInstance(SiteInstance* site_instance);
 
+  // PlzNavigate: Used to signal the commit of a navigation request.

[Charlie Reis, 2014/08/08 20:25:29]

In retrospect, this comment isn't very clear, partly because of how the code
used to work.  The name sounds like CommitPending, which occurs *after* the
navigation has committed in the renderer.  In contrast, this function is closer
to the current OnCrossSiteResponse, which means the network response is ready to
commit but hasn't yet.

I'm not sure I have a better suggestion for the name (CommitNavigation and
DidCommitNavigation might end up as a reasonable pair of functions), but we
should at least be very explicit about which point of the timeline this
represents in the comment.

(This also applies in navigator.h.)

[clamy, 2014/08/12 12:13:16]

Is the comment now clearer?

+  void CommitNavigation(const NavigationBeforeCommitInfo& info);
+
  private:
   friend class RenderFrameHostManagerTest;
   friend class TestWebContents;
 
   FRIEND_TEST_ALL_PREFIXES(CrossProcessFrameTreeBrowserTest,
                            CreateCrossProcessSubframeProxies);
 
   // 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,
@@ skipping 63 matching lines @@
   bool ShouldSwapBrowsingInstancesForNavigation(
       const NavigationEntry* current_entry,
       const NavigationEntryImpl* new_entry) const;
 
   // Returns true if it is safe to reuse the current WebUI when navigating from
   // |current_entry| to |new_entry|.
   bool ShouldReuseWebUI(
       const NavigationEntry* current_entry,
       const NavigationEntryImpl* new_entry) const;
 
-  // 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.
+  // Returns the SiteInstance to use for the navigation.
+  SiteInstance* GetSiteInstanceForNavigation(const NavigationEntryImpl& entry);
+
+  // Helper function that 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. Caller should use
+  // GetSiteInstanceForNavigation.
   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 and stores it in pending_render_frame_host_.
+  // Also returns a pointer to the newly created RFH.
+  RenderFrameHostImpl* CreateRenderFrameHostForNewSiteInstance(
+      SiteInstance* old_instance,
+      SiteInstance* new_instance,
+      bool is_main_frame);
+
   // 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_navigation);
 
   // Initialization for RenderFrameHost uses the same sequence as InitRenderView
   // above.
   bool InitRenderFrame(RenderFrameHost* render_frame_host);
 
+  // Initializes |dest_render_frame_host| and |render_frame_host_| if necessary
+  // before navigating.
+  bool InitRenderFrameHostsBeforeNavigation(
+      RenderFrameHostImpl* dest_render_frame_host);
+
   // 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 RenderFrameProxyHosts in a SiteInstance. This is called to
   // shutdown frames when all the frames in a SiteInstance are confirmed to be
   // swapped out.
   void ShutdownRenderFrameProxyHostsInSiteInstance(int32 site_instance_id);
 
@@ skipping 71 matching lines @@
   typedef base::hash_map<int32, linked_ptr<RenderFrameHostImpl> >
       RFHPendingDeleteMap;
   RFHPendingDeleteMap pending_delete_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_;
 
-  // Owns a navigation request that originated in that frame until it commits.
+  // PlzNavigate: Owns a navigation request that originated in that frame until
+  // it commits.
   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_