Make ServiceWorkerRegisterJob accumulate registration state.

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 "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_job_coordinator.h"
@@ skipping 53 matching lines @@
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   if (status == SERVICE_WORKER_ERROR_NOT_FOUND) {
     // A previous registration does not exist.
     RegisterAndContinue(SERVICE_WORKER_OK);
     return;
   }
 
   if (status != SERVICE_WORKER_OK) {
     // Abort this registration job.
-    Complete(status);
+    Complete(NULL, status);
     return;
   }
 
   if (registration->script_url() != script_url_) {
     // Script URL mismatch: delete the existing registration and register a new
     // one.
     registration->Shutdown();
     context_->storage()->DeleteRegistration(
         pattern_,
         base::Bind(&ServiceWorkerRegisterJob::RegisterAndContinue,
                    weak_factory_.GetWeakPtr()));
     return;
   }
 
   // Reuse the existing registration.
-  registration_ = registration;
-  StartWorkerAndContinue(SERVICE_WORKER_OK);
+  StartWorkerAndContinue(registration, SERVICE_WORKER_OK);
 }
 
 void ServiceWorkerRegisterJob::RegisterAndContinue(
     ServiceWorkerStatusCode status) {
-  DCHECK(!registration_);
   if (status != SERVICE_WORKER_OK) {
     // Abort this registration job.
-    Complete(status);
+    Complete(NULL, status);
     return;
   }
 
-  registration_ = new ServiceWorkerRegistration(
-      pattern_, script_url_, context_->storage()->NewRegistrationId(),
-      context_);
+  scoped_refptr<ServiceWorkerRegistration> registration =
+      new ServiceWorkerRegistration(pattern_,
+                                    script_url_,
+                                    context_->storage()->NewRegistrationId(),
+                                    context_);
   context_->storage()->StoreRegistration(
-      registration_.get(),
+      registration.get(),
       base::Bind(&ServiceWorkerRegisterJob::StartWorkerAndContinue,
-                 weak_factory_.GetWeakPtr()));
+                 weak_factory_.GetWeakPtr(),
+                 registration));
 }
 
 void ServiceWorkerRegisterJob::StartWorkerAndContinue(
+    ServiceWorkerRegistration* registration,
     ServiceWorkerStatusCode status) {
   // TODO(falken): Handle the case where status is an error code.
-  DCHECK(registration_);
-  if (registration_->active_version()) {
+  if (registration->active_version()) {
     // We have an active version, so we can complete immediately, even
     // if the service worker isn't running.
-    Complete(SERVICE_WORKER_OK);
+    Complete(registration, SERVICE_WORKER_OK);
     return;
   }
 
   pending_version_ = new ServiceWorkerVersion(
-      registration_, context_->storage()->NewVersionId(), context_);
+      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);
 
   // The callback to watch "installation" actually fires as soon as
   // the worker is up and running, just before the install event is
   // dispatched. The job will continue to run even though the main
   // callback has executed.
   pending_version_->StartWorker(base::Bind(&ServiceWorkerRegisterJob::Complete,
-                                           weak_factory_.GetWeakPtr()));
+                                           weak_factory_.GetWeakPtr(),
+                                           make_scoped_refptr(registration)));
 
   // TODO(falken): Don't set the active version until just before
   // the activate event is dispatched.
   pending_version_->SetStatus(ServiceWorkerVersion::ACTIVE);
-  registration_->set_active_version(pending_version_);
+  registration->set_active_version(pending_version_);
 }
 
-void ServiceWorkerRegisterJob::Complete(ServiceWorkerStatusCode status) {
+void ServiceWorkerRegisterJob::Complete(ServiceWorkerRegistration* registration,
+                                        ServiceWorkerStatusCode status) {
   for (std::vector<RegistrationCallback>::iterator it = callbacks_.begin();
        it != callbacks_.end();
        ++it) {
-    it->Run(status, status == SERVICE_WORKER_OK ? registration_ : NULL);
+    it->Run(status, status == SERVICE_WORKER_OK ? registration : NULL);
   }
   context_->job_coordinator()->FinishJob(pattern_, this);
 }
 
 }  // namespace content