Teach EmbeddedWorkerInstance to create a process when it needs one.

content/browser/service_worker/service_worker_version.cc

Index: content/browser/service_worker/service_worker_version.cc
diff --git a/content/browser/service_worker/service_worker_version.cc b/content/browser/service_worker/service_worker_version.cc
index 8cb4d125cc2dc52de7b09bf31ae3c14fe8173ce1..82f6a4b49720139bc016a17f9840ade59b63807f 100644
--- a/content/browser/service_worker/service_worker_version.cc
+++ b/content/browser/service_worker/service_worker_version.cc
@@ -138,25 +138,31 @@ ServiceWorkerVersionInfo ServiceWorkerVersion::GetInfo() {
                                   embedded_worker()->thread_id());
 }
 
-void ServiceWorkerVersion::StartWorker(const StatusCallback& callback) {
+void ServiceWorkerVersion::StartWorker(
+    const StatusCallback& callback,
+    const std::vector<int>& possible_process_ids) {
   DCHECK(embedded_worker_);
-  if (running_status() == RUNNING) {
-    RunSoon(base::Bind(callback, SERVICE_WORKER_OK));
-    return;
-  }
-  if (running_status() == STOPPING) {
-    RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_START_WORKER_FAILED));
-    return;
-  }
-  if (start_callbacks_.empty()) {
-    ServiceWorkerStatusCode status = embedded_worker_->Start(
-        version_id_, scope_, script_url_);
-    if (status != SERVICE_WORKER_OK) {
-      RunSoon(base::Bind(callback, status));
+  switch (running_status()) {

[kinuko, 2014/04/25 13:46:35]

This looks nicer, thanks.

+    case RUNNING:
+      RunSoon(base::Bind(callback, SERVICE_WORKER_OK));
+      return;
+    case STOPPING:
+      RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_START_WORKER_FAILED));
+      return;
+    case STOPPED:
+    case STARTING:
+      start_callbacks_.push_back(callback);
+      if (running_status() == STOPPED) {
+        embedded_worker_->Start(
+            version_id_,
+            scope_,
+            script_url_,
+            possible_process_ids,
+            base::Bind(&ServiceWorkerVersion::RunStartWorkerCallbacksOnError,
+                       weak_factory_.GetWeakPtr()));
+      }
       return;
-    }
   }
-  start_callbacks_.push_back(callback);
 }
 
 void ServiceWorkerVersion::StopWorker(const StatusCallback& callback) {
@@ -181,10 +187,13 @@ void ServiceWorkerVersion::SendMessage(
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
-                           weak_factory_.GetWeakPtr(), callback,
+                           weak_factory_.GetWeakPtr(),
+                           callback,
                            base::Bind(&self::SendMessage,
                                       weak_factory_.GetWeakPtr(),
-                                      message, callback)));
+                                      message,
+                                      callback)),
+                std::vector<int>());
     return;
   }
 
@@ -192,22 +201,27 @@ void ServiceWorkerVersion::SendMessage(
   RunSoon(base::Bind(callback, status));
 }
 
-void ServiceWorkerVersion::DispatchInstallEvent(
-    int active_version_id,
-    const StatusCallback& callback) {
-  DCHECK_EQ(NEW, status()) << status();
+void ServiceWorkerVersion::DispatchInstallEvent(int active_version_id,
+                                                const StatusCallback& callback,
+                                                bool second_call) {
+  if (!second_call)
+    DCHECK_EQ(NEW, status()) << status();
+  SetStatus(INSTALLING);
 
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
-                           weak_factory_.GetWeakPtr(), callback,
+                           weak_factory_.GetWeakPtr(),
+                           callback,
                            base::Bind(&self::DispatchInstallEvent,
                                       weak_factory_.GetWeakPtr(),
-                                      active_version_id, callback)));
+                                      active_version_id,
+                                      callback,
+                                      true)),
+                std::vector<int>());
     return;
   }
 
-  SetStatus(INSTALLING);
   int request_id = install_callbacks_.Add(new StatusCallback(callback));
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_InstallEvent(request_id, active_version_id));
@@ -217,21 +231,25 @@ void ServiceWorkerVersion::DispatchInstallEvent(
   }
 }
 
-void ServiceWorkerVersion::DispatchActivateEvent(
-    const StatusCallback& callback) {
-  DCHECK_EQ(INSTALLED, status()) << status();
+void ServiceWorkerVersion::DispatchActivateEvent(const StatusCallback& callback,
+                                                 bool second_call) {
+  if (!second_call)
+    DCHECK_EQ(INSTALLED, status()) << status();
+  SetStatus(ACTIVATING);

[Jeffrey Yasskin, 2014/04/25 04:40:33]

This fixes the url_request_job_unittest, which was hitting the DCHECK in
ServiceWorkerFetchDispatcher::Run once StartWorker became less synchronous.

[kinuko, 2014/04/25 13:46:35]

Uh oh I see. Thanks for noticing, this was sketchy.
Is it possible not to expose the 'second_call' param on the public method
signature?  I don't have a great solution, but say, could we have another member
field like pending_operation_ and set it to ACTIVATING while we're starting a
worker, and check if 'status() == INSTALLED || (status() == ACTIVATING &&
pending_operation_ == ACTIVATING)'?

[Jeffrey Yasskin, 2014/04/26 03:52:19]

Using a new field for this will allow the user to call DispatchActivateEvent()
twice in a row, which the existing checks would forbid.
I think the right way to hide the new argument is to use a private function for
the "AfterStartWorker" part. I'll switch to that.

 
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
-                           weak_factory_.GetWeakPtr(), callback,
+                           weak_factory_.GetWeakPtr(),
+                           callback,
                            base::Bind(&self::DispatchActivateEvent,
                                       weak_factory_.GetWeakPtr(),
-                                      callback)));
+                                      callback,
+                                      true)),
+                std::vector<int>());
     return;
   }
 
-  SetStatus(ACTIVATING);
   int request_id = activate_callbacks_.Add(new StatusCallback(callback));
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_ActivateEvent(request_id));
@@ -253,7 +271,9 @@ void ServiceWorkerVersion::DispatchFetchEvent(
                            base::Bind(&RunErrorFetchCallback, callback),
                            base::Bind(&self::DispatchFetchEvent,
                                       weak_factory_.GetWeakPtr(),
-                                      request, callback)));
+                                      request,
+                                      callback)),
+                std::vector<int>());
     return;
   }
 
@@ -280,10 +300,12 @@ void ServiceWorkerVersion::DispatchSyncEvent(const StatusCallback& callback) {
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
-                           weak_factory_.GetWeakPtr(), callback,
+                           weak_factory_.GetWeakPtr(),
+                           callback,
                            base::Bind(&self::DispatchSyncEvent,
                                       weak_factory_.GetWeakPtr(),
-                                      callback)));
+                                      callback)),
+                std::vector<int>());
     return;
   }
 
@@ -433,6 +455,12 @@ bool ServiceWorkerVersion::OnMessageReceived(const IPC::Message& message) {
   return handled;
 }
 
+void ServiceWorkerVersion::RunStartWorkerCallbacksOnError(
+    ServiceWorkerStatusCode status) {
+  if (status != SERVICE_WORKER_OK)
+    RunCallbacks(this, &start_callbacks_, status);
+}
+
 void ServiceWorkerVersion::OnGetClientDocuments(int request_id) {
   std::vector<int> client_ids;
   ControlleeByIDMap::iterator it(&controllee_by_id_);