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;

[nasko, 2014/11/10 17:35:31]

Why are these structs outside of the content namespace?

[clamy, 2014/11/12 13:01:13]

They are defined that way in frame_messages.h (and so are resource_messages.h).

[carlosk, 2014/11/13 14:40:26]

Yes, that.

 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 231 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();
+
   // 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,
@@ skipping 48 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.

[clamy, 2014/11/12 13:01:13]

nit: add "if needed" at the end of the comment.

[carlosk, 2014/11/13 14:40:26]

Done.

+  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);
 
  private:
   friend class RenderFrameHostManagerTest;
   friend class TestWebContents;
 
   FRIEND_TEST_ALL_PREFIXES(CrossProcessFrameTreeBrowserTest,
                            CreateCrossProcessSubframeProxies);
 
@@ skipping 32 matching lines @@
   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);
+      bool dest_is_view_source_mode,
+      bool create_unbounded_site_instance);
 
   // 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,
+                                      bool create_unbounded_site_instance);
+
+  SiteInstance* CreateSiteInstanceForURL(BrowserContext* browser_context,
+                                         const GURL& creation_url,
+                                         bool create_unbounded_site_instance,
+                                         SiteInstanceImpl* current_instance);
+
+  SiteInstance* GetRelatedSiteInstanceForURL(
+      SiteInstanceImpl* current_instance,
+      const GURL& creation_url,
+      bool create_unbounded_site_instance);
 
   // 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);
 
   // 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 later destroyed if the final navigation

[nasko, 2014/11/10 17:35:32]

nit: swap the ordering of "later" and "destroyed"

[carlosk, 2014/11/13 14:40:26]

Done.

+  // destination doesn't match the initial one.
+  bool CreateSpeculativeRenderFrameHost(const GURL& url,
+                                        SiteInstance* old_instance,
+                                        SiteInstance* new_instance);
+
+  // 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 what

[nasko, 2014/11/10 17:35:32]

nit: s/what/which/

[carlosk, 2014/11/13 14:40:26]

Done.

+  // 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 whether be

[nasko, 2014/11/10 17:35:32]

nit: s/whether//

[carlosk, 2014/11/13 14:40:26]

Done.

+  // 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_;
+
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_MANAGER_H_