PlzNavigate: implement process reuse for ServiceWorkers

content/browser/frame_host/navigation_handle_impl.cc

 // Copyright 2015 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/navigation_handle_impl.h"
 
 #include <iterator>
 
 #include "base/logging.h"
 #include "content/browser/appcache/appcache_navigation_handle.h"
 #include "content/browser/appcache/appcache_service_impl.h"
 #include "content/browser/browsing_data/clear_site_data_throttle.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/devtools/render_frame_devtools_agent_host.h"
 #include "content/browser/frame_host/ancestor_throttle.h"
 #include "content/browser/frame_host/data_url_navigation_throttle.h"
 #include "content/browser/frame_host/debug_urls.h"
 #include "content/browser/frame_host/form_submission_throttle.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/mixed_content_navigation_throttle.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/frame_host/navigator.h"
 #include "content/browser/frame_host/navigator_delegate.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_navigation_handle.h"
+#include "content/common/child_process_host_impl.h"
 #include "content/common/frame_messages.h"
 #include "content/common/resource_request_body_impl.h"
 #include "content/common/site_isolation_policy.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/navigation_ui_data.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/net_errors.h"
@@ skipping 74 matching lines @@
       should_replace_current_entry_(false),
       redirect_chain_(redirect_chain),
       is_download_(false),
       is_stream_(false),
       started_from_context_menu_(started_from_context_menu),
       reload_type_(ReloadType::NONE),
       restore_type_(RestoreType::NONE),
       navigation_type_(NAVIGATION_TYPE_UNKNOWN),
       should_check_main_world_csp_(should_check_main_world_csp),
       is_form_submission_(is_form_submission),
+      speculative_render_process_host_id_(ChildProcessHost::kInvalidUniqueID),
       weak_factory_(this) {
   TRACE_EVENT_ASYNC_BEGIN2("navigation", "NavigationHandle", this,
                            "frame_tree_node",
                            frame_tree_node_->frame_tree_node_id(), "url",
                            url_.possibly_invalid_spec());
   DCHECK(!navigation_start.is_null());
+
+  site_url_ = SiteInstance::GetSiteForURL(
+      frame_tree_node_->navigator()->GetController()->GetBrowserContext(),
+      url_);
   if (redirect_chain_.empty())
     redirect_chain_.push_back(url);
 
   starting_site_instance_ =
       frame_tree_node_->current_frame_host()->GetSiteInstance();
 
   if (pending_nav_entry_id_) {
     NavigationControllerImpl* nav_controller =
         static_cast<NavigationControllerImpl*>(
             frame_tree_node_->navigator()->GetController());
@@ skipping 21 matching lines @@
         navigation_start, "Initial URL", url_.spec());
   }
 
   if (is_same_page_) {
     TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
                                  "Same document");
   }
 }
 
 NavigationHandleImpl::~NavigationHandleImpl() {
+  // Inform the RenderProcessHost to no longer expect a navigation.
+  if (speculative_render_process_host_id_ !=
+      ChildProcessHost::kInvalidUniqueID) {
+    RenderProcessHost* process =
+        RenderProcessHost::FromID(speculative_render_process_host_id_);
+    if (process) {
+      RenderProcessHostImpl::RemoveExpectedNavigationToSite(
+          frame_tree_node_->navigator()->GetController()->GetBrowserContext(),
+          process, site_url_);
+    }
+  }
+
   // Transfer requests that have not matched up with another navigation request
   // from the renderer need to be cleaned up. These are marked as protected in
   // the RDHI, so they do not get cancelled when frames are destroyed.
   if (is_transferring()) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&NotifyAbandonedTransferNavigation, GetGlobalRequestID()));
   }
 
   if (!IsRendererDebugURL(url_))
@@ skipping 405 matching lines @@
     scoped_refptr<net::HttpResponseHeaders> response_headers,
     net::HttpResponseInfo::ConnectionInfo connection_info,
     const ThrottleChecksFinishedCallback& callback) {
   TRACE_EVENT_ASYNC_STEP_INTO1("navigation", "NavigationHandle", this,
                                "WillRedirectRequest", "url",
                                new_url.possibly_invalid_spec());
 
   // Update the navigation parameters.
   url_ = new_url;
   method_ = new_method;
+  UpdateSiteURL();
 
   if (!(transition_ & ui::PAGE_TRANSITION_CLIENT_REDIRECT)) {
     sanitized_referrer_.url = new_referrer_url;
     sanitized_referrer_ =
         Referrer::SanitizeForRequest(url_, sanitized_referrer_);
   }
 
   is_external_protocol_ = new_is_external_protocol;
   response_headers_ = response_headers;
   connection_info_ = connection_info;
@@ skipping 70 matching lines @@
 
 void NavigationHandleImpl::ReadyToCommitNavigation(
     RenderFrameHostImpl* render_frame_host) {
   TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
                                "ReadyToCommitNavigation");
 
   DCHECK(!render_frame_host_ || render_frame_host_ == render_frame_host);
   render_frame_host_ = render_frame_host;
   state_ = READY_TO_COMMIT;
 
+  if (IsBrowserSideNavigationEnabled())
+    SetSpeculativeProcess(render_frame_host->GetProcess());

[Charlie Reis, 2017/05/23 07:29:13]

Naming nit: This RFH/process isn't speculative anymore, is it?  When we call
from ReadyToCommitNavigation, I think it's the one we definitely plan to use,
whether it matches the earlier speculative one or not.

What if we renamed the NavigationHandle concept from SetSpeculativeProcess to
SetExpectedProcess (which parallels Add/RemoveExpectedNavigationToSite and can
be called with either the speculative or final RFH)?  Same for
expected_render_process_host_id_.

[clamy, 2017/05/23 13:41:15]

Done.

+
   if (!IsRendererDebugURL(url_) && !IsSameDocument())
     GetDelegate()->ReadyToCommitNavigation(this);
 }
 
 void NavigationHandleImpl::DidCommitNavigation(
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params,
     bool navigation_entry_committed,
     bool did_replace_entry,
     const GURL& previous_url,
     NavigationType navigation_type,
@@ skipping 25 matching lines @@
     TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
                                  "DidCommitNavigation: error page");
     state_ = DID_COMMIT_ERROR_PAGE;
   } else {
     TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
                                  "DidCommitNavigation");
     state_ = DID_COMMIT;
   }
 }
 
+void NavigationHandleImpl::SetSpeculativeProcess(
+    RenderProcessHost* speculative_process) {
+  if (speculative_process &&
+      speculative_process->GetID() == speculative_render_process_host_id_) {
+    // This |speculative_process| has already been informed of the navigation,
+    // no need to update it again.
+    return;
+  }
+
+  // If a RenderProcessHost was expecting this navigation to commit, have it
+  // stop tracking this site.
+  RenderProcessHost* old_process =
+      RenderProcessHost::FromID(speculative_render_process_host_id_);
+  if (old_process) {
+    RenderProcessHostImpl::RemoveExpectedNavigationToSite(
+        frame_tree_node_->navigator()->GetController()->GetBrowserContext(),
+        old_process, site_url_);
+  }
+
+  if (speculative_process == nullptr) {
+    speculative_render_process_host_id_ = ChildProcessHost::kInvalidUniqueID;
+    return;
+  }
+
+  // Keep track of the speculative RenderProcessHost and tell it to expect a
+  // navigation to |site_url_|.
+  speculative_render_process_host_id_ = speculative_process->GetID();
+  RenderProcessHostImpl::AddExpectedNavigationToSite(
+      frame_tree_node_->navigator()->GetController()->GetBrowserContext(),
+      speculative_process, site_url_);
+}
+
 void NavigationHandleImpl::Transfer() {
   DCHECK(!IsBrowserSideNavigationEnabled());
   // This is an actual transfer. Inform the NavigationResourceThrottle. This
   // will allow to mark the URLRequest as transferring. When it is marked as
   // transferring, the URLRequest can no longer be cancelled by its original
   // RenderFrame. Instead it will persist until being picked up by the transfer
   // RenderFrame, even if the original RenderFrame is destroyed.
   // Note: |transfer_callback_| can be null in unit tests.
   if (!transfer_callback_.is_null())
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, transfer_callback_);
@@ skipping 307 matching lines @@
        node = node->parent()) {
     if (node->current_url().EqualsIgnoringRef(url_)) {
       if (found_self_reference)
         return true;
       found_self_reference = true;
     }
   }
   return false;
 }
 
+void NavigationHandleImpl::UpdateSiteURL() {
+  GURL new_site_url = SiteInstance::GetSiteForURL(
+      frame_tree_node_->navigator()->GetController()->GetBrowserContext(),
+      url_);
+  if (new_site_url == site_url_)
+    return;
+
+  // When redirecting cross-site, stop telling the speculative
+  // RenderProcessHost to expect a navigation commit.
+  SetSpeculativeProcess(nullptr);
+  site_url_ = new_site_url;
+}
+
 }  // namespace content