Service Worker: Handle same-scope, new script registration

content/browser/service_worker/service_worker_registration.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_registration.h"
 
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_info.h"
 #include "content/browser/service_worker/service_worker_register_job.h"
 #include "content/browser/service_worker/service_worker_utils.h"
@@ skipping 139 matching lines @@
   DCHECK(context_);
   if (is_uninstalling_)
     return;
   is_uninstalling_ = true;
 
   context_->storage()->NotifyUninstallingRegistration(this);
   context_->storage()->DeleteRegistration(
       id(),
       script_url().GetOrigin(),
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
-
   if (!active_version() || !active_version()->HasControllee())
     Clear();
 }
 
-void ServiceWorkerRegistration::AbortPendingClear() {
+void ServiceWorkerRegistration::AbortPendingClear(
+    const StatusCallback& callback) {
   DCHECK(context_);
-  if (!is_uninstalling())
+  if (!is_uninstalling()) {
+    callback.Run(SERVICE_WORKER_OK);
     return;
+  }
   is_uninstalling_ = false;
   context_->storage()->NotifyDoneUninstallingRegistration(this);
 
   scoped_refptr<ServiceWorkerVersion> most_recent_version =
       waiting_version() ? waiting_version() : active_version();
   DCHECK(most_recent_version);
   context_->storage()->NotifyInstallingRegistration(this);
   context_->storage()->StoreRegistration(
       this,
       most_recent_version,
-      base::Bind(&ServiceWorkerRegistration::OnStoreFinished,
+      base::Bind(&ServiceWorkerRegistration::OnRestoreFinished,
                  this,
+                 callback,
                  most_recent_version));
 }
 
 void ServiceWorkerRegistration::OnNoControllees(ServiceWorkerVersion* version) {
   DCHECK_EQ(active_version(), version);
   if (is_uninstalling_)
     Clear();
   else if (should_activate_when_ready_)
     ActivateWaitingVersion();
   is_uninstalling_ = false;
@@ skipping 75 matching lines @@
   }
 }
 
 void ServiceWorkerRegistration::OnDeleteFinished(
     ServiceWorkerStatusCode status) {
   // Intentionally empty completion callback, used to prevent
   // |this| from being deleted until the storage method completes.
 }
 
 void ServiceWorkerRegistration::Clear() {
-  context_->storage()->NotifyDoneUninstallingRegistration(this);
+  is_uninstalling_ = false;
+  if (context_)
+    context_->storage()->NotifyDoneUninstallingRegistration(this);
 
   ChangedVersionAttributesMask mask;
   if (installing_version_) {
     installing_version_->Doom();
     installing_version_ = NULL;
     mask.add(ChangedVersionAttributesMask::INSTALLING_VERSION);
   }
   if (waiting_version_) {
     waiting_version_->Doom();
     waiting_version_ = NULL;
     mask.add(ChangedVersionAttributesMask::WAITING_VERSION);
   }
   if (active_version_) {
     active_version_->Doom();
     active_version_->RemoveListener(this);
     active_version_ = NULL;
     mask.add(ChangedVersionAttributesMask::ACTIVE_VERSION);
   }
   if (mask.changed()) {
     ServiceWorkerRegistrationInfo info = GetInfo();
     FOR_EACH_OBSERVER(Listener, listeners_,
                       OnVersionAttributesChanged(this, mask, info));
   }
+
+  FOR_EACH_OBSERVER(
+      Listener, listeners_, OnRegistrationFinishedUninstalling(this));
 }
 
-void ServiceWorkerRegistration::OnStoreFinished(
+void ServiceWorkerRegistration::OnRestoreFinished(
+    const StatusCallback& callback,
     scoped_refptr<ServiceWorkerVersion> version,
     ServiceWorkerStatusCode status) {
-  if (!context_)
+  if (!context_) {
+    callback.Run(ServiceWorkerStatusCode::SERVICE_WORKER_ERROR_ABORT);
     return;
+  }
   context_->storage()->NotifyDoneInstallingRegistration(
       this, version.get(), status);
+  callback.Run(status);
 }
 
 }  // namespace content