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 NavigationControllerImpl;
 class NavigationEntry;
 class NavigationEntryImpl;
 class RenderFrameHost;
 class RenderFrameHostDelegate;
 class RenderFrameHostImpl;
-class RenderFrameHostManagerTest;

[Charlie Reis, 2014/12/04 01:11:30]

I'm not sure we want to delete this.  It may not be strictly necessary, but it's
consistent with other code (e.g., see render_view_host_impl.h, render_widget.h),
and it's in the spirit of "include what you use."  Let's avoid this churn unless
there's a good reason for it.

[carlosk, 2014/12/09 07:55:43]

Done.

 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 304 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

[Charlie Reis, 2014/12/04 01:11:32]

nit: renderer -> RenderFrameHost

[carlosk, 2014/12/09 07:55:42]

Done.

+  // will commit it.
   RenderFrameHostImpl* GetFrameHostForNavigation(const GURL& url,
                                                  ui::PageTransition transition);
 
+  // PlzNavigate
+  // Cancels any ongoing navigation.

[Charlie Reis, 2014/12/04 01:11:31]

nit: Cancels any state for any ongoing navigation.

This code doesn't cancel the navigation itself.

[carlosk, 2014/12/09 07:55:42]

Done.

+  void CleanUpNavigation();
+
  private:
+  friend class NavigatorTestWithBrowserSideNavigation;
   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,
                                          FrameTreeNode* node);
@@ skipping 74 matching lines @@
   // route ID to be used for the new RenderView to be created.
   int CreateOpenerRenderViewsIfNeeded(SiteInstance* old_instance,
                                       SiteInstance* new_instance);
 
   // Creates a RenderFrameHost and corresponding RenderViewHost if necessary.
   scoped_ptr<RenderFrameHostImpl> CreateRenderFrameHost(SiteInstance* instance,
                                                         int view_routing_id,
                                                         int frame_routing_id,
                                                         int flags);
 
+  // PlzNavigate
+  // Creates a new RenderFrameHost and does all required supporting work for the
+  // speculative creation of a new renderer for an ongoing navigation request.

[Charlie Reis, 2014/12/04 01:11:31]

creation of a new speculative RenderFrameHost for...

[carlosk, 2014/12/09 07:55:42]

Done.

+  // 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);
+
   // 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.
+  // If PlzNavigate is enabled the method will set the speculative
+  // RenderFrameHost to be the active one instead of the pending.

[Charlie Reis, 2014/12/04 01:11:31]

nit: set the speculative (not pending) RenderFrameHost to be the active one.

[carlosk, 2014/12/09 07:55:43]

Done.

   void CommitPending();
 
   // 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);
 
   // Discards a RenderFrameHost that was never made active (for active ones
   // SwapOutOldFrame is used instead).
   void DiscardUnusedFrame(scoped_ptr<RenderFrameHostImpl> render_frame_host);
@@ skipping 61 matching lines @@
   // 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_frame_host_| is NULL. This will happen when we're
   // 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.
   scoped_ptr<RenderFrameHostImpl> pending_render_frame_host_;

[Charlie Reis, 2014/12/04 01:11:31]

Let's add:
Note: This is not used in PlzNavigate.

[carlosk, 2014/12/09 07:55:42]

Done.

 
   // If a pending request needs to be transferred to another process, this
   // owns the request until it's transferred to the new process, so it will be
   // cleaned up if the navigation is cancelled.  Otherwise, this is NULL.
   scoped_ptr<CrossSiteTransferringRequest> cross_site_transferring_request_;
 
   // Tracks information about any navigation paused after receiving response
   // headers.
   scoped_ptr<GlobalRequestID> response_started_id_;
 
@@ skipping 13 matching lines @@
   // because sets don't appear to support linked_ptrs.
   typedef std::list<linked_ptr<RenderFrameHostImpl> > RFHPendingDeleteList;
   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_;

[Charlie Reis, 2014/12/04 01:11:30]

WeakPtrFactories always have to be the last member of the class.

[carlosk, 2014/12/09 07:55:42]

Done.

 
+  // PlzNavigate
+  // Members to store the speculative RFH created upon starting a navigation
+  // allowing the creation of the renderer process as early as possible.

[Charlie Reis, 2014/12/04 21:46:28]

This first sentence is a bit awkward.  Maybe simplify to just convey the intent,
and mention it's an optimization:

We create a speculative RenderFrameHost early during a navigation to give the
renderer process time to start.  It is purely an optimization and is not
required for correct behavior.

[carlosk, 2014/12/09 07:55:42]

Done.

+  // The created instance might be discarded later on if the final URL's
+  // SiteInstance isn't compatible with what was used to create it.
+  // Note: speculative RenderFrameHost is only used for PlzNavigate and the
+  // pending one only for the regular navigation.

[Charlie Reis, 2014/12/04 01:11:32]

"for the regular navigation" is a bit awkward.  Maybe:

Note: PlzNavigate only uses speculative RenderFrameHosts and not pending ones.

[carlosk, 2014/12/09 07:55:42]

Done.

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