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),
+      expected_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 (expected_render_process_host_id_ != ChildProcessHost::kInvalidUniqueID) {
+    RenderProcessHost* process =
+        RenderProcessHost::FromID(expected_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())
+    SetExpectedProcess(render_frame_host->GetProcess());
+
   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::SetExpectedProcess(
+    RenderProcessHost* expected_process) {
+  if (expected_process &&
+      expected_process->GetID() == expected_render_process_host_id_) {
+    // This |expected_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(expected_render_process_host_id_);
+  if (old_process) {
+    RenderProcessHostImpl::RemoveExpectedNavigationToSite(
+        frame_tree_node_->navigator()->GetController()->GetBrowserContext(),
+        old_process, site_url_);
+  }
+
+  if (expected_process == nullptr) {
+    expected_render_process_host_id_ = ChildProcessHost::kInvalidUniqueID;
+    return;
+  }
+
+  // Keep track of the speculative RenderProcessHost and tell it to expect a
+  // navigation to |site_url_|.
+  expected_render_process_host_id_ = expected_process->GetID();
+  RenderProcessHostImpl::AddExpectedNavigationToSite(
+      frame_tree_node_->navigator()->GetController()->GetBrowserContext(),
+      expected_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.
+  SetExpectedProcess(nullptr);
+  site_url_ = new_site_url;
+}
+
 }  // namespace content