Teach EmbeddedWorkerInstance to create a process when it needs one.

content/browser/service_worker/service_worker_version.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_version.h"
 
 #include "base/command_line.h"
 #include "base/stl_util.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
@@ skipping 120 matching lines @@
 
 ServiceWorkerVersionInfo ServiceWorkerVersion::GetInfo() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return ServiceWorkerVersionInfo(running_status(),
                                   status(),
                                   version_id(),
                                   embedded_worker()->process_id(),
                                   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;
+  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;
   }
-  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));
-      return;
-    }
-  }
-  start_callbacks_.push_back(callback);
 }
 
 void ServiceWorkerVersion::StopWorker(const StatusCallback& callback) {
   DCHECK(embedded_worker_);
   if (running_status() == STOPPED) {
     RunSoon(base::Bind(callback, SERVICE_WORKER_OK));
     return;
   }
   if (stop_callbacks_.empty()) {
     ServiceWorkerStatusCode status = embedded_worker_->Stop();
     if (status != SERVICE_WORKER_OK) {
       RunSoon(base::Bind(callback, status));
       return;
     }
   }
   stop_callbacks_.push_back(callback);
 }
 
 void ServiceWorkerVersion::SendMessage(
     const IPC::Message& message, const StatusCallback& callback) {
   DCHECK(embedded_worker_);
   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;
   }
 
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(message);
   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));
   if (status != SERVICE_WORKER_OK) {
     install_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
 }
 
-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));
   if (status != SERVICE_WORKER_OK) {
     activate_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
 }
 
 void ServiceWorkerVersion::DispatchFetchEvent(
     const ServiceWorkerFetchRequest& request,
     const FetchCallback& callback) {
   DCHECK_EQ(ACTIVE, status()) << status();
 
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
                            weak_factory_.GetWeakPtr(),
                            base::Bind(&RunErrorFetchCallback, callback),
                            base::Bind(&self::DispatchFetchEvent,
                                       weak_factory_.GetWeakPtr(),
-                                      request, callback)));
+                                      request,
+                                      callback)),
+                std::vector<int>());
     return;
   }
 
   int request_id = fetch_callbacks_.Add(new FetchCallback(callback));
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_FetchEvent(request_id, request));
   if (status != SERVICE_WORKER_OK) {
     fetch_callbacks_.Remove(request_id);
     RunSoon(base::Bind(&RunErrorFetchCallback,
                        callback,
                        SERVICE_WORKER_ERROR_FAILED));
   }
 }
 
 void ServiceWorkerVersion::DispatchSyncEvent(const StatusCallback& callback) {
   DCHECK_EQ(ACTIVE, status()) << status();
 
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableServiceWorkerSync)) {
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     return;
   }
 
   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;
   }
 
   int request_id = sync_callbacks_.Add(new StatusCallback(callback));
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_SyncEvent(request_id));
   if (status != SERVICE_WORKER_OK) {
     sync_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
@@ skipping 129 matching lines @@
                         OnInstallEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_FetchEventFinished,
                         OnFetchEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_SyncEventFinished,
                         OnSyncEventFinished)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   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_);
   while (!it.IsAtEnd()) {
     client_ids.push_back(it.GetCurrentKey());
     it.Advance();
   }
   // Don't bother if it's no longer running.
   if (running_status() == RUNNING) {
     embedded_worker_->SendMessage(
@@ skipping 61 matching lines @@
     NOTREACHED() << "Got unexpected message: " << request_id;
     return;
   }
 
   scoped_refptr<ServiceWorkerVersion> protect(this);
   callback->Run(SERVICE_WORKER_OK);
   sync_callbacks_.Remove(request_id);
 }
 
 }  // namespace content