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

content/browser/service_worker/service_worker_context_wrapper.cc

Index: content/browser/service_worker/service_worker_context_wrapper.cc
diff --git a/content/browser/service_worker/service_worker_context_wrapper.cc b/content/browser/service_worker/service_worker_context_wrapper.cc
index a27d006e613c511fde81a788287217ff71b9bad5..ff9f587d0fc887424825f7f4d1e17fe3a42c8bed 100644
--- a/content/browser/service_worker/service_worker_context_wrapper.cc
+++ b/content/browser/service_worker/service_worker_context_wrapper.cc
@@ -20,6 +20,7 @@
 #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"
@@ -826,6 +827,93 @@ void ServiceWorkerContextWrapper::DidDeleteAndStartOver(
                          &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,