PlzNavigate: Speculatively spawns a renderer process for navigations.

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 <list>
 
 #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"
 #include "ui/base/page_transition_types.h"
 
+struct FrameHostMsg_BeginNavigation_Params;
 struct FrameMsg_Navigate_Params;
 
 namespace content {
 class BrowserContext;
 class CrossProcessFrameConnector;
 class CrossSiteTransferringRequest;
+class FrameTreeNode;
 class InterstitialPageImpl;
-class FrameTreeNode;
 class NavigationControllerImpl;
 class NavigationEntry;
 class NavigationEntryImpl;
 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 CommonNavigationParams;
 
 // Manages RenderFrameHosts for a FrameTreeNode. It maintains a
 // current_frame_host() which is the content currently visible to the user. When
 // a frame is told to navigate to a different web site (as determined by
 // SiteInstance), it will replace its current RenderFrameHost with a new
 // RenderFrameHost dedicated to the new SiteInstance, possibly in a new process.
 //
 // Cross-process navigation works like this:
 //
 // - RFHM::Navigate determines whether the destination is cross-site, and if so,
@@ skipping 168 matching lines @@
 
   // 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();
   }
 
-  // Sets the pending Web UI for the pending navigation, ensuring that the
-  // bindings are appropriate compared to |bindings|.
-  void SetPendingWebUI(const GURL& url, int bindings);
-
   // 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);
 
   // Instructs the various live views to stop. Called when the user directed the
   // page to stop loading.
   void Stop();
 
@@ skipping 39 matching lines @@
 
   // Resume navigation paused after receiving response headers.
   void ResumeResponseDeferredAtStart();
 
   // Clear navigation transition data.
   void ClearNavigationTransitionData();
 
   // Called when a renderer's frame navigates.
   void DidNavigateFrame(RenderFrameHostImpl* render_frame_host);
 
+  // PlzNavigate
+  // Cleans up ongoing navigation data.
+  void CancelNavigation();

[clamy, 2014/11/19 15:03:29]

nit: place this function with the other PlzNavigate ones below.

[carlosk, 2014/11/19 17:24:29]

Done.

[carlosk, 2014/11/21 14:36:34]

Done.

+
   // Called when a renderer sets its opener to null.
   void DidDisownOpener(RenderFrameHost* render_frame_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.
-  // 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);
+  // Creates and initializes a RenderFrameHost that is placed on the swapped out
+  // hosts list and hidden. Returns the routing id of the *view* associated
+  // with the frame.
+  int CreateSwappedOutHiddenRenderFrame(SiteInstance* instance,
+                                        int opener_route_id,
+                                        bool for_main_frame_navigation);
 
   // Helper method to create and initialize a RenderFrameProxyHost and return
   // its routing id.
   int CreateRenderFrameProxy(SiteInstance* instance);
 
   // 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) {
@@ skipping 37 matching lines @@
 
   // Deletes any proxy hosts associated with this node. Used during destruction
   // of WebContentsImpl.
   void ResetProxyHosts();
 
   // 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: Called when a navigation is ready to commit, to select the
-  // renderer that will commit it.
+  // PlzNavigate
+  // Notifies the RFHM that a navigation is about to begin so that it can
+  // speculatively spawn a new renderer process if needed.
+  void BeginNavigation(const FrameHostMsg_BeginNavigation_Params& params,
+                       const CommonNavigationParams& common_params);
+
+  // PlzNavigate
+  // Called when a navigation is ready to commit, to select the renderer that
+  // will commit it.
   RenderFrameHostImpl* GetFrameHostForNavigation(const GURL& url,
                                                  ui::PageTransition transition);
 
+  // PlzNavigate
+  // Returns the speculative RenderFrameHost, or NULL if there is no pending
+  // one.
+  RenderFrameHostImpl* speculative_render_frame_host() const {
+    return speculative_render_frame_host_.get();
+  }
+
  private:
   friend class RenderFrameHostManagerTest;
   friend class TestWebContents;
 
   FRIEND_TEST_ALL_PREFIXES(CrossProcessFrameTreeBrowserTest,
                            CreateCrossProcessSubframeProxies);
 
   // Used with FrameTree::ForEach to erase RenderFrameProxyHosts from a
   // FrameTreeNode's RenderFrameHostManager.
   static bool ClearProxiesInSiteInstance(int32 site_instance_id,
@@ skipping 17 matching lines @@
   // SiteInstance's site and when we later call IsSameWebSite.  If there is no
   // current NavigationEntry, check the current SiteInstance's site, which might
   // already be committed to a Web UI URL (such as the NTP).
   bool ShouldSwapBrowsingInstancesForNavigation(
       const GURL& current_effective_url,
       bool current_is_view_source_mode,
       SiteInstance* new_site_instance,
       const GURL& new_effective_url,
       bool new_is_view_source_mode) const;
 
+  // Sets the pending Web UI for the pending navigation, ensuring that the
+  // bindings are appropriate compared to |bindings|.
+  void SetPendingWebUI(const GURL& url, int bindings);
+
+  // Creates a new Web UI, ensuring that the bindings are appropriate compared
+  // to |bindings|. The caller is responsible for the instance ownership.
+  WebUIImpl* CreateWebUI(const GURL& url, int bindings);
+
   // Returns true if it is safe to reuse the current WebUI when navigating from
   // |current_entry| to |new_url|.
   bool ShouldReuseWebUI(
       const NavigationEntry* current_entry,
       const GURL& new_url) const;
 
   // Returns the SiteInstance to use for the navigation.
   SiteInstance* GetSiteInstanceForNavigation(
       const GURL& dest_url,
       SiteInstance* dest_instance,
       ui::PageTransition dest_transition,
       bool dest_is_restore,
       bool dest_is_view_source_mode);
 
   // Returns an appropriate SiteInstance object for the given |dest_url|,
   // possibly reusing the current SiteInstance.  If --process-per-tab is used,
   // this is only called when ShouldSwapBrowsingInstancesForNavigation returns
   // true. |dest_instance| will be used if it is not null.
   // This is a helper function for GetSiteInstanceForNavigation.
-  SiteInstance* GetSiteInstanceForURL(
-      const GURL& dest_url,
-      SiteInstance* dest_instance,
-      ui::PageTransition dest_transition,
-      bool dest_is_restore,
-      bool dest_is_view_source_mode,
-      SiteInstance* current_instance,
-      bool force_browsing_instance_swap);
+  SiteInstance* GetSiteInstanceForURL(const GURL& dest_url,
+                                      SiteInstance* dest_instance,
+                                      ui::PageTransition dest_transition,
+                                      bool dest_is_restore,
+                                      bool dest_is_view_source_mode,
+                                      SiteInstance* current_instance,
+                                      bool force_browsing_instance_swap);
 
   // Determines the appropriate url to use as the current url for SiteInstance
   // selection.
   const GURL& GetCurrentURLForSiteInstance(
       SiteInstance* current_instance,
       NavigationEntry* current_entry);
 
   // Creates a new RenderFrameHostImpl for the |new_instance| while respecting
   // the opener route if needed and stores it in pending_render_frame_host_.
   void CreateRenderFrameHostForNewSiteInstance(
       SiteInstance* old_instance,
       SiteInstance* new_instance,
       bool is_main_frame);
 
+  // Ensure that we have created RFHs for the new RFH's opener chain if
+  // we are staying in the same BrowsingInstance. This allows the new RFH
+  // to send cross-process script calls to its opener(s). Returns the opener
+  // route ID to be used for the new RenderView to be created.
+  int GetOpenerRouteIDForNewRenderView(SiteInstance* old_instance,
+                                       SiteInstance* new_instance);
+
+  // Helper method to create and initialize a RenderFrameHost. If |swapped_out|
+  // is true, it will be initially placed on the swapped out hosts list.
+  // If |routing_id_ptr| is not NULL it will be set to the routing id of the
+  // *view* associated with the frame.
+  scoped_ptr<RenderFrameHostImpl> CreateRenderFrameInternal(
+      SiteInstance* instance,
+      int opener_route_id,
+      bool swapped_out,
+      bool for_main_frame_navigation,
+      bool hidden,
+      const WebUIImpl* web_ui,
+      int* routing_id_ptr);
+
   // 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);
 
+  // PlzNavigate
+  // Creates a new RenderFrameHost and does all required supporting work for the
+  // speculative creation of a new renderer for an ongoing navigation request.
+  // This RenderFrameHost might be destroyed later if the final navigation
+  // destination doesn't match the initial one.
+  bool CreateSpeculativeRenderFrameHost(const GURL& url,
+                                        SiteInstance* old_instance,
+                                        SiteInstance* new_instance,
+                                        int bindings);
+
+  // PlzNavigate
+  // Cleans up the date related to the speculative RenderFrameHost.
+  void CleanUpSpeculativeRenderFrameHost();
+
   // 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(RenderViewHostImpl* 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(RenderFrameHostImpl* 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();
+  // With PlzNavigate enabled, |use_speculative_rfh| can be set to true which
+  // will cause the speculative RenderFrameHost to be the active one.
+  void CommitPending(bool use_speculative_rfh);
 
   // Runs the unload handler in the old RenderFrameHost, after the new
   // RenderFrameHost has committed.  |old_render_frame_host| will either be
   // deleted or put on the pending delete list during this call.
   void SwapOutOldFrame(scoped_ptr<RenderFrameHostImpl> old_render_frame_host);
 
+  // Called to properly discard a created RenderFrameHost that was never made
+  // active (for active ones SwapOutOldFrame is used instead). It can be swapped
+  // out or fully destroyed.
+  void RecycleRenderFrameHost(
+      scoped_ptr<RenderFrameHostImpl> render_frame_host);
+
   // Holds |render_frame_host| until it can be deleted when its swap out ACK
   // arrives.
   void MoveToPendingDeleteHosts(
       scoped_ptr<RenderFrameHostImpl> render_frame_host);
 
   // 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 86 matching lines @@
   RFHPendingDeleteList 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_;
 
   base::WeakPtrFactory<RenderFrameHostManager> weak_factory_;
 
+  // PlzNavigate
+  // Members to store the speculative RFH created upon starting a navigation
+  // allowing the creation of the renderer process as early as possible.
+  // Might be discarded later on if the final URL's SiteInstance doesn't match
+  // what was assumed in the beginning.
+  // Note: speculative RenderFrameHost is only used for PlzNavigate and pending
+  // only for the regular navigation (not yet true, but will be).
+  scoped_ptr<RenderFrameHostImpl> speculative_render_frame_host_;
+  scoped_ptr<WebUIImpl> speculative_web_ui_;
+
+  // PlzNavigate
+  // If true at navigation commit time the current WebUI will be kept instead of
+  // creating a new one.
+  bool should_reuse_web_ui_;

[nasko, 2014/11/19 01:00:24]

Can we avoid adding yet more state?

[carlosk, 2014/11/19 17:24:29]

As WebUI instances are held with scoped_ptr I can't (shouldn't is more precise)
make the current and speculative point to the same value. So I need something
else to let me know at commit time that the current WebUI should just be kept in
place

For the existing pending logic, this same logic is done with a weak-pointer to
the current WebUI (see pending pending_and_current_web_ui_ above). I didn't see
any advantages in comparison to simply having a boolean flag.

I could also consolidate these 3 speculative-related members into a new struct.

+
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_MANAGER_H_