Introduce chrome://flags/#network-prediction-options-for-service-worker

content/browser/service_worker/service_worker_context_wrapper.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/service_worker/service_worker_context_wrapper.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_process_manager.h"
 #include "content/browser/service_worker/service_worker_quota_client.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 786 matching lines @@
     context_core_.reset();
     return;
   }
   context_core_.reset(new ServiceWorkerContextCore(context_core_.get(), this));
   DVLOG(1) << "Restarted ServiceWorkerContextCore successfully.";
 
   observer_list_->Notify(FROM_HERE,
                          &ServiceWorkerContextObserver::OnStorageWiped);
 }
 
+void ServiceWorkerContextWrapper::StartServiceWorkerForNavigationPreconnect(
+    const GURL& document_url,
+    RenderProcessHost* host,
+    const ResultCallback& callback) {
+  TRACE_EVENT1("ServiceWorker", "StartServiceWorkerForNavigationPreconnect",
+               "document_url", document_url.spec());
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!host || !RenderProcessHostImpl::IsSuitableHost(
+                   host, host->GetBrowserContext(), document_url)) {
+    callback.Run(false);
+    return;
+  }
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&ServiceWorkerContextWrapper::
+                     DidCheckRenderProcessForNavigationPreconnect,
+                 this, document_url, host->GetID(), callback));
+}
+
+void ServiceWorkerContextWrapper::DidCheckRenderProcessForNavigationPreconnect(
+    const GURL& document_url,
+    int render_process_id,
+    const ResultCallback& callback) {
+  TRACE_EVENT1("ServiceWorker", "DidCheckRenderProcessForNavigationPreconnect",
+               "document_url", document_url.spec());
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!context_core_) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(callback, false));
+    return;
+  }
+  FindReadyRegistrationForDocument(
+      document_url, base::Bind(&ServiceWorkerContextWrapper::
+                                   DidFindRegistrationForNavigationPreconnect,
+                               this, render_process_id, callback));
+}
+
+void ServiceWorkerContextWrapper::DidFindRegistrationForNavigationPreconnect(
+    int render_process_id,
+    const ResultCallback& callback,
+    ServiceWorkerStatusCode status,
+    scoped_refptr<ServiceWorkerRegistration> registration) {
+  TRACE_EVENT0("ServiceWorker", "DidFindRegistrationForNavigationPreconnect");
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (status != SERVICE_WORKER_OK || !registration->active_version()) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(callback, false));
+    return;
+  }
+
+  if (registration->active_version()->fetch_handler_existence() ==
+      ServiceWorkerVersion::FetchHandlerExistence::DOES_NOT_EXIST) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(callback, false));
+    return;
+  }
+
+  // Add the process reference of |render_process_id| not to launch a new
+  // renderer process for the service worker.
+  context_core_->process_manager()->AddProcessReferenceToPattern(
+      registration->pattern(), render_process_id);

[falken, 2017/06/01 06:54:17]

Have you tested this with PlzNavigate? Is it still needed when PlzNavigate is
on?

The idea was with PlzNavigate and the new SiteInstance changes, we aren't going
to need SWProcessManager to keep track of RenderProcessHosts on its own.

[horo, 2017/06/01 11:15:07]

Added tests for PlzNavigate.

I think we still need this AddProcessReferenceToPattern() even if PlzNavigate is
on.
If we don't call AddProcessReferenceToPattern, StartWorker() may create a new
process.

But PredictorTabHelper::DidStartNavigation() is called before executing the
checks in InterceptNavigationDelegate::ShouldIgnoreNavigation().
So the navigation request may be canceled after here.

To avoid creating a new process for the request which will be canceled, we have
to call AddProcessReferenceToPattern() here.

[falken, 2017/06/01 23:24:14]

To be clear, the plan was to remove
ServiceWorkerProcessManager::AddProcessReferenceToPattern totally. A lot of
design went into allowing service workers to use SiteInstance directly with
PlzNavigate:
https://docs.google.com/document/d/1Zujvf5jcUtm1hyh-xhXYlyfPjdO2oEplz22fOhSj6...

I'm a bit reluctant to add a AddProcessReferenceToPattern here if we can't
remove it later.

How does PlzNavigate avoid creating a new process, while this might create a new
process? It's because we're starting the SW before the PlzNavigate logic begins?

+
+  registration->active_version()->StartWorker(
+      ServiceWorkerMetrics::EventType::PRECONNECT,
+      base::Bind(&ServiceWorkerContextWrapper::
+                     DidStartServiceWorkerForNavigationPreconnect,
+                 this, registration->pattern(), render_process_id, callback));
+}
+
+void ServiceWorkerContextWrapper::DidStartServiceWorkerForNavigationPreconnect(
+    const GURL& pattern,
+    int render_process_id,
+    const ResultCallback& callback,
+    ServiceWorkerStatusCode code) {
+  TRACE_EVENT1("ServiceWorker", "DidStartServiceWorkerForNavigationPreconnect",
+               "url", pattern.spec());
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  // Remove the process reference added in
+  // DidFindRegistrationForNavigationPreconnect.
+  context_core_->process_manager()->RemoveProcessReferenceFromPattern(
+      pattern, render_process_id);
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(callback, code == SERVICE_WORKER_OK));
+}
+
 void ServiceWorkerContextWrapper::BindWorkerFetchContext(
     int render_process_id,
     int service_worker_provider_id,
     mojom::ServiceWorkerWorkerClientAssociatedPtrInfo client_ptr_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   context()->BindWorkerFetchContext(render_process_id,
                                     service_worker_provider_id,
                                     std::move(client_ptr_info));
 }
 
 ServiceWorkerContextCore* ServiceWorkerContextWrapper::context() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return context_core_.get();
 }
 
 }  // namespace content