Service Worker: set active worker to REDUNDANT when unregistered

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 432 matching lines @@
     std::set<int64> ids;
     for (size_t i = 0; i < resources.size(); ++i)
       ids.insert(resources[i].resource_id);
 
     database_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(
             &ServiceWorkerDatabase::PurgeUncommittedResourceIds),
             base::Unretained(database_.get()),
             ids));
-
-    StartPurgingResources(resources);
   }
 }
 
 void ServiceWorkerStorage::Disable() {
   state_ = DISABLED;
   if (disk_cache_)
     disk_cache_->Disable();
 }
 
 bool ServiceWorkerStorage::IsDisabled() const {
   return state_ == DISABLED;
 }
 
+void ServiceWorkerStorage::PurgeResources(const ResourceList& resources) {
+  if (!has_checked_for_stale_resources_)
+    DeleteStaleResources();
+  StartPurgingResources(resources);
+}
+
 ServiceWorkerStorage::ServiceWorkerStorage(
     const base::FilePath& path,
     base::WeakPtr<ServiceWorkerContextCore> context,
     base::SequencedTaskRunner* database_task_runner,
     base::MessageLoopProxy* disk_cache_thread,
     quota::QuotaManagerProxy* quota_manager_proxy)
     : next_registration_id_(kInvalidServiceWorkerRegistrationId),
       next_version_id_(kInvalidServiceWorkerVersionId),
       next_resource_id_(kInvalidServiceWorkerResourceId),
       state_(UNINITIALIZED),
@@ skipping 220 matching lines @@
     const std::vector<int64>& newly_purgeable_resources,
     ServiceWorkerDatabase::Status status) {
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     ScheduleDeleteAndStartOver();
     callback.Run(DatabaseStatusToStatusCode(status));
     return;
   }
   registered_origins_.insert(origin);
   callback.Run(SERVICE_WORKER_OK);
 
-  SchedulePurgeResources(deleted_version_id, newly_purgeable_resources);
+  if (!context_ || !context_->GetLiveVersion(deleted_version_id))
+    StartPurgingResources(newly_purgeable_resources);
 }
 
 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));
 }
 
 void ServiceWorkerStorage::DidDeleteRegistration(
     const GURL& origin,
     const StatusCallback& callback,
     bool origin_is_deletable,
     int64 version_id,
     const std::vector<int64>& newly_purgeable_resources,
     ServiceWorkerDatabase::Status status) {
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     ScheduleDeleteAndStartOver();
     callback.Run(DatabaseStatusToStatusCode(status));
     return;
   }
   if (origin_is_deletable)
     registered_origins_.erase(origin);
   callback.Run(SERVICE_WORKER_OK);
 
-  SchedulePurgeResources(version_id, newly_purgeable_resources);
+  if (!context_ || !context_->GetLiveVersion(version_id))
+    StartPurgingResources(newly_purgeable_resources);
 }
 
 scoped_refptr<ServiceWorkerRegistration>
 ServiceWorkerStorage::GetOrCreateRegistration(
     const ServiceWorkerDatabase::RegistrationData& data,
     const ResourceList& resources) {
   scoped_refptr<ServiceWorkerRegistration> registration =
       context_->GetLiveRegistration(data.registration_id);
   if (registration)
     return registration;
@@ skipping 89 matching lines @@
 
 void ServiceWorkerStorage::OnDiskCacheInitialized(int rv) {
   if (rv != net::OK) {
     LOG(ERROR) << "Failed to open the serviceworker diskcache: "
                << net::ErrorToString(rv);
     ScheduleDeleteAndStartOver();
   }
   ServiceWorkerMetrics::CountInitDiskCacheResult(rv == net::OK);
 }
 
-void ServiceWorkerStorage::OnNoControllees(ServiceWorkerVersion* version) {
-  std::map<int64, std::vector<int64> >::iterator it =
-      deleted_version_resource_ids_.find(version->version_id());
-  DCHECK(it != deleted_version_resource_ids_.end());
-  StartPurgingResources(it->second);
-  deleted_version_resource_ids_.erase(it);
-  version->RemoveListener(this);
-}
-
-void ServiceWorkerStorage::SchedulePurgeResources(
-    int64 version_id,
-    const std::vector<int64>& resources) {
-  DCHECK(deleted_version_resource_ids_.find(version_id) ==
-         deleted_version_resource_ids_.end());
-  if (resources.empty())
-    return;
-  scoped_refptr<ServiceWorkerVersion> version =
-      context_ ? context_->GetLiveVersion(version_id) : NULL;
-  if (version && version->HasControllee()) {
-    deleted_version_resource_ids_[version_id] = resources;
-    version->AddListener(this);
-  } else {
-    StartPurgingResources(resources);
-  }
-}
-
 void ServiceWorkerStorage::StartPurgingResources(
     const std::vector<int64>& ids) {
   DCHECK(has_checked_for_stale_resources_);
   for (size_t i = 0; i < ids.size(); ++i)
     purgeable_resource_ids_.push_back(ids[i]);
   ContinuePurgingResources();
 }
 
 void ServiceWorkerStorage::StartPurgingResources(
     const ResourceList& resources) {
@@ skipping 313 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