PlzNavigate: Create the speculative renderer earlier.

content/browser/frame_host/navigator_impl.cc

 // 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.
 
 #include "content/browser/frame_host/navigator_impl.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/time/time.h"
 #include "content/browser/frame_host/frame_tree.h"
@@ skipping 582 matching lines @@
   NavigationRequest* navigation_request = frame_tree_node->navigation_request();
 
   // The NavigationRequest may have been canceled while the renderer was
   // executing the BeforeUnload event.
   if (!navigation_request)
     return;
 
   DCHECK_EQ(NavigationRequest::WAITING_FOR_RENDERER_RESPONSE,
             navigation_request->state());
 
+  // If the navigation is allowed to proceed, send the request to the IO thread.
   if (proceed)
-    BeginNavigation(frame_tree_node);
+    navigation_request->BeginNavigation();
   else
     CancelNavigation(frame_tree_node);
 }
 
 // PlzNavigate
 void NavigatorImpl::OnBeginNavigation(
     FrameTreeNode* frame_tree_node,
     const CommonNavigationParams& common_params,
     const BeginNavigationParams& begin_params,
     scoped_refptr<ResourceRequestBody> body) {
@@ skipping 12 matching lines @@
   // request is not user-initiated.
   if (ongoing_navigation_request &&
       (ongoing_navigation_request->browser_initiated() ||
        ongoing_navigation_request->begin_params().has_user_gesture) &&
       !begin_params.has_user_gesture) {
     return;
   }
 
   // In all other cases the current navigation, if any, is canceled and a new
   // NavigationRequest is created for the node.
-  scoped_ptr<NavigationRequest> navigation_request =
+  frame_tree_node->CreatedNavigationRequest(
       NavigationRequest::CreateRendererInitiated(
           frame_tree_node, common_params, begin_params, body,
           controller_->GetLastCommittedEntryIndex(),
-          controller_->GetEntryCount());
-  frame_tree_node->SetNavigationRequest(navigation_request.Pass());
+          controller_->GetEntryCount()));
+  NavigationRequest* navigation_request = frame_tree_node->navigation_request();
 
   if (frame_tree_node->IsMainFrame()) {
     // Renderer-initiated main-frame navigations that need to swap processes
     // will go to the browser via a OpenURL call, and then be handled by the
     // same code path as browser-initiated navigations. For renderer-initiated
     // main frame navigation that start via a BeginNavigation IPC, the
     // RenderFrameHost will not be swapped. Therefore it is safe to call
     // DidStartMainFrameNavigation with the SiteInstance from the current
     // RenderFrameHost.
     DidStartMainFrameNavigation(
         common_params.url,
         frame_tree_node->current_frame_host()->GetSiteInstance());
     navigation_data_.reset();
   }
 
-  BeginNavigation(frame_tree_node);
+  navigation_request->BeginNavigation();
 }
 
 // PlzNavigate
 void NavigatorImpl::CommitNavigation(FrameTreeNode* frame_tree_node,
                                      ResourceResponse* response,
                                      scoped_ptr<StreamHandle> body) {
   CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation));
 
   NavigationRequest* navigation_request = frame_tree_node->navigation_request();
@@ skipping 127 matching lines @@
 
 // PlzNavigate
 void NavigatorImpl::RequestNavigation(
     FrameTreeNode* frame_tree_node,
     const NavigationEntryImpl& entry,
     NavigationController::ReloadType reload_type,
     base::TimeTicks navigation_start) {
   CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation));
   DCHECK(frame_tree_node);
+
+  // This value must be set here because creating a NavigationRequest might
+  // change the renderer live/non-live status and change this result.
+  bool should_dispatch_beforeunload =
+      frame_tree_node->current_frame_host()->ShouldDispatchBeforeUnload();
   FrameMsg_Navigate_Type::Value navigation_type =
       GetNavigationType(controller_->GetBrowserContext(), entry, reload_type);
-  scoped_ptr<NavigationRequest> navigation_request =
+  frame_tree_node->CreatedNavigationRequest(
       NavigationRequest::CreateBrowserInitiated(frame_tree_node, entry,
                                                 navigation_type,
-                                                navigation_start, controller_);
-  frame_tree_node->SetNavigationRequest(navigation_request.Pass());
-  frame_tree_node->navigation_request()->SetWaitingForRendererResponse();
+                                                navigation_start, controller_));
+  NavigationRequest* navigation_request = frame_tree_node->navigation_request();
 
-  // Have the current renderer execute its beforeUnload event if needed. If it
-  // is not needed (eg. the renderer is not live), BeginNavigation should get
-  // called. If the navigation is synchronous and same-site, then it can be sent
-  // directly to the renderer (currently this is the case for navigations that
-  // do not make network requests such as data urls or Javascript urls).
-  if (NavigationRequest::ShouldMakeNetworkRequest(
-          frame_tree_node->navigation_request()->common_params().url)) {
+  // Have the current renderer execute its beforeunload event if needed. If it
+  // is not needed (when beforeunload dispatch is not needed or this navigation
+  // is synchronous and same-site) then NavigationRequest::BeginNavigation
+  // should be directly called instead.
+  if (should_dispatch_beforeunload &&
+      NavigationRequest::ShouldMakeNetworkRequest(
+          navigation_request->common_params().url)) {
+    navigation_request->SetWaitingForRendererResponse();
     frame_tree_node->current_frame_host()->DispatchBeforeUnload(true);
   } else {
-    BeginNavigation(frame_tree_node);
+    navigation_request->BeginNavigation();
   }
 }
 
-void NavigatorImpl::BeginNavigation(FrameTreeNode* frame_tree_node) {
-  NavigationRequest* navigation_request = frame_tree_node->navigation_request();
-
-  // A browser-initiated navigation could have been cancelled while it was
-  // waiting for the BeforeUnload event to execute.
-  if (!navigation_request)
-    return;
-
-  // Start the request.
-   if (navigation_request->BeginNavigation()) {
-    // If the request was sent to the IO thread, notify the
-    // RenderFrameHostManager so it can speculatively create a RenderFrameHost
-    // (and potentially a new renderer process) in parallel.
-    frame_tree_node->render_manager()->BeginNavigation(*navigation_request);
-  }
-}
-
 void NavigatorImpl::RecordNavigationMetrics(
     const LoadCommittedDetails& details,
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params,
     SiteInstance* site_instance) {
   DCHECK(site_instance->HasProcess());
 
   if (!details.is_in_page)
     RecordAction(base::UserMetricsAction("FrameLoad"));
 
   if (!details.is_main_frame || !navigation_data_ ||
@@ skipping 67 matching lines @@
       entry->set_should_replace_entry(pending_entry->should_replace_entry());
       entry->SetRedirectChain(pending_entry->GetRedirectChain());
     }
     controller_->SetPendingEntry(entry);
     if (delegate_)
       delegate_->NotifyChangedNavigationState(content::INVALIDATE_TYPE_URL);
   }
 }
 
 }  // namespace content