Service Worker: in Unregister, wait until after the active worker no longer controls a document

content/browser/service_worker/service_worker_storage.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_storage.h"
 
 #include <string>
 
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
@@ skipping 311 matching lines @@
       FROM_HERE,
       base::Bind(
           &FindForPatternInDB,
           database_.get(),
           base::MessageLoopProxy::current(),
           scope,
           base::Bind(&ServiceWorkerStorage::DidFindRegistrationForPattern,
                      weak_factory_.GetWeakPtr(), scope, callback)));
 }
 
+scoped_refptr<ServiceWorkerRegistration>
+ServiceWorkerStorage::GetUninstallingRegistration(const GURL& scope) {
+  if (state_ != INITIALIZED || !context_)
+    return NULL;
+  for (RegistrationRefsById::const_iterator it =
+           uninstalling_registrations_.begin();
+       it != uninstalling_registrations_.end();
+       ++it) {
+    if (it->second->pattern() == scope) {
+      DCHECK(it->second->is_uninstalling());
+      return it->second;
+    }
+  }
+  return NULL;
+}
+
 void ServiceWorkerStorage::FindRegistrationForId(
     int64 registration_id,
     const GURL& origin,
     const FindRegistrationCallback& callback) {
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::FindRegistrationForId,
           weak_factory_.GetWeakPtr(), registration_id, origin, callback))) {
     if (state_ != INITIALIZING || !context_) {
       CompleteFindNow(scoped_refptr<ServiceWorkerRegistration>(),
                       SERVICE_WORKER_ERROR_FAILED, callback);
@@ skipping 71 matching lines @@
     return;
   }
 
   ServiceWorkerDatabase::RegistrationData data;
   data.registration_id = registration->id();
   data.scope = registration->pattern();
   data.script = registration->script_url();
   data.has_fetch_handler = true;
   data.version_id = version->version_id();
   data.last_update_check = base::Time::Now();
-  data.is_active = false;  // initially stored in the waiting state
+  data.is_active = (version == registration->active_version());
 
   ResourceList resources;
   version->script_cache_map()->GetResources(&resources);
 
   if (!has_checked_for_stale_resources_)
     DeleteStaleResources();
 
   database_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WriteRegistrationInDB,
                  database_.get(),
                  base::MessageLoopProxy::current(),
                  data, resources,
                  base::Bind(&ServiceWorkerStorage::DidStoreRegistration,
                             weak_factory_.GetWeakPtr(),
                             callback)));
+
+  registration->set_is_deleted(false);
 }
 
 void ServiceWorkerStorage::UpdateToActiveState(
     ServiceWorkerRegistration* registration,
     const StatusCallback& callback) {
   DCHECK(registration);
 
   DCHECK(state_ == INITIALIZED || state_ == DISABLED) << state_;
   if (IsDisabled() || !context_) {
     RunSoon(FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
@@ skipping 37 matching lines @@
                  base::MessageLoopProxy::current(),
                  registration_id, origin,
                  base::Bind(&ServiceWorkerStorage::DidDeleteRegistration,
                             weak_factory_.GetWeakPtr(), params)));
 
   // The registration should no longer be findable.
   pending_deletions_.insert(registration_id);
   ServiceWorkerRegistration* registration =
       context_->GetLiveRegistration(registration_id);
   if (registration)
-    registration->set_is_deleted();
+    registration->set_is_deleted(true);
 }
 
 scoped_ptr<ServiceWorkerResponseReader>
 ServiceWorkerStorage::CreateResponseReader(int64 response_id) {
   return make_scoped_ptr(
       new ServiceWorkerResponseReader(response_id, disk_cache()));
 }
 
 scoped_ptr<ServiceWorkerResponseWriter>
 ServiceWorkerStorage::CreateResponseWriter(int64 response_id) {
@@ skipping 93 matching lines @@
 
     database_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(
             &ServiceWorkerDatabase::PurgeUncommittedResourceIds),
             base::Unretained(database_.get()),
             ids));
   }
 }
 
+void ServiceWorkerStorage::NotifyUninstallingRegistration(
+    ServiceWorkerRegistration* registration) {
+  uninstalling_registrations_[registration->id()] = registration;
+
+  DeleteRegistration(registration->id(),
+                     registration->script_url().GetOrigin(),
+                     base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
+}
+
+void ServiceWorkerStorage::NotifyAbortedUninstallingRegistration(
+    ServiceWorkerRegistration* registration) {
+  uninstalling_registrations_.erase(registration->id());
+  installing_registrations_[registration->id()] = registration;
+
+  if (registration->waiting_version()) {
+    StoreRegistration(registration,
+                      registration->waiting_version(),
+                      base::Bind(&ServiceWorkerStorage::DidRestoreRegistration,
+                                 weak_factory_.GetWeakPtr(),
+                                 registration->id()));
+  } else if (registration->active_version()) {
+    StoreRegistration(registration,
+                      registration->active_version(),
+                      base::Bind(&ServiceWorkerStorage::DidRestoreRegistration,
+                                 weak_factory_.GetWeakPtr(),
+                                 registration->id()));
+  }
+  registration->set_is_deleted(false);
+}
+
+void ServiceWorkerStorage::NotifyUninstalledRegistration(
+    ServiceWorkerRegistration* registration) {
+  uninstalling_registrations_.erase(registration->id());
+}
+
 void ServiceWorkerStorage::Disable() {
   state_ = DISABLED;
   if (disk_cache_)
     disk_cache_->Disable();
 }
 
 bool ServiceWorkerStorage::IsDisabled() const {
   return state_ == DISABLED;
 }
 
@@ skipping 253 matching lines @@
     callback.Run(DatabaseStatusToStatusCode(status));
     return;
   }
   registered_origins_.insert(origin);
   callback.Run(SERVICE_WORKER_OK);
 
   if (!context_ || !context_->GetLiveVersion(deleted_version_id))
     StartPurgingResources(newly_purgeable_resources);
 }
 
+void ServiceWorkerStorage::DidRestoreRegistration(
+    int64 registration_id,
+    ServiceWorkerStatusCode status) {
+  if (status == SERVICE_WORKER_OK)
+    installing_registrations_.erase(registration_id);
+}
+
 void ServiceWorkerStorage::DidUpdateToActiveState(
     const StatusCallback& callback,
     ServiceWorkerDatabase::Status status) {
   if (status != ServiceWorkerDatabase::STATUS_OK &&
       status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
     ScheduleDeleteAndStartOver();
   }
   callback.Run(DatabaseStatusToStatusCode(status));
 }
 
@@ skipping 23 matching lines @@
     const ResourceList& resources) {
   scoped_refptr<ServiceWorkerRegistration> registration =
       context_->GetLiveRegistration(data.registration_id);
   if (registration)
     return registration;
 
   registration = new ServiceWorkerRegistration(
       data.scope, data.script, data.registration_id, context_);
   if (pending_deletions_.find(data.registration_id) !=
       pending_deletions_.end()) {
-    registration->set_is_deleted();
+    registration->set_is_deleted(true);
   }
   scoped_refptr<ServiceWorkerVersion> version =
       context_->GetLiveVersion(data.version_id);
   if (!version) {
     version = new ServiceWorkerVersion(registration, data.version_id, context_);
     version->SetStatus(data.is_active ?
         ServiceWorkerVersion::ACTIVATED : ServiceWorkerVersion::INSTALLED);
     version->script_cache_map()->SetResources(resources);
   }
 
@@ skipping 408 matching lines @@
     // Give up the corruption recovery until the browser restarts.
     LOG(ERROR) << "Failed to delete the diskcache.";
     callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully.";
   callback.Run(SERVICE_WORKER_OK);
 }
 
 }  // namespace content