Teach EmbeddedWorkerInstance to create a process when it needs one.

content/browser/service_worker/service_worker_register_job.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_register_job.h"
 
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
@@ skipping 25 matching lines @@
       is_promise_resolved_(false),
       promise_resolved_status_(SERVICE_WORKER_OK),
       weak_factory_(this) {}
 
 ServiceWorkerRegisterJob::~ServiceWorkerRegisterJob() {
   DCHECK(phase_ == INITIAL || phase_ == COMPLETE);
 }
 
 void ServiceWorkerRegisterJob::AddCallback(const RegistrationCallback& callback,
                                            int process_id) {
-  DCHECK_NE(-1, process_id);
-  if (phase_ >= UPDATE && pending_version())
-    pending_version()->AddProcessToWorker(process_id);
-  else
-    pending_process_ids_.push_back(process_id);
-
   if (!is_promise_resolved_) {
     callbacks_.push_back(callback);
+    if (process_id != -1 && (phase_ < UPDATE || !pending_version()))
+      pending_process_ids_.push_back(process_id);
     return;
   }
   RunSoon(base::Bind(
       callback, promise_resolved_status_,
       promise_resolved_registration_, promise_resolved_version_));
 }
 
 void ServiceWorkerRegisterJob::Start() {
   SetPhase(START);
   context_->storage()->FindRegistrationForPattern(
@@ skipping 157 matching lines @@
   // TODO(falken): "If serviceWorkerRegistration.pendingWorker is not null..."
   // then terminate the pending worker. It doesn't make sense to implement yet
   // since we always activate the worker if install completed, so there can be
   // no pending worker at this point.
   DCHECK(!registration()->pending_version());
 
   // "Let serviceWorker be a newly-created ServiceWorker object..." and start
   // the worker.
   set_pending_version(new ServiceWorkerVersion(
       registration(), context_->storage()->NewVersionId(), context_));
-  for (std::vector<int>::const_iterator it = pending_process_ids_.begin();
-       it != pending_process_ids_.end();
-       ++it) {
-    pending_version()->AddProcessToWorker(*it);
-  }
 
   // TODO(michaeln): Start the worker into a paused state where the
   // script resource is downloaded but not yet evaluated.
   pending_version()->StartWorker(
       base::Bind(&ServiceWorkerRegisterJob::OnStartWorkerFinished,
-                 weak_factory_.GetWeakPtr()));
+                 weak_factory_.GetWeakPtr()),
+      pending_process_ids_);
 }
 
 void ServiceWorkerRegisterJob::OnStartWorkerFinished(
     ServiceWorkerStatusCode status) {
   // "If serviceWorker fails to start up..." then reject the promise with an
   // error and abort.
   if (status != SERVICE_WORKER_OK) {
     Complete(status);
     return;
   }
@@ skipping 160 matching lines @@
        !it->IsAtEnd();
        it->Advance()) {
     ServiceWorkerProviderHost* provider_host = it->GetProviderHost();
     if (ServiceWorkerUtils::ScopeMatches(pattern_,
                                          provider_host->document_url()))
       provider_host->SetPendingVersion(version);
   }
 }
 
 }  // namespace content