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 678 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);
+  DecommissionVersion(deleted_version_id, newly_purgeable_resources);

[michaeln, 2014/07/10 00:55:23]

presuming two things:
* higher level job classes have taken care of Doom'ing versions
* versions take care of making the state transition to redundant and initiating
the purge of its script_cached resources

(ok, maybe that was three)

i think this would only need to concern itself with initiating the purge of
resources when there is no live version. and the awkward block of code to start
purging in NotifyInsallingDone could be removed too.

[falken, 2014/07/10 14:05:12]

I think that block kind of makes sense, it's a special case because it's the
only time you must clean up uncommitted resources. If I remove that block and
try to have a general purpose PurgeResources that Version::Doom calls, I think
PurgeResources would have to try to clean up both uncommitted and purgeable
resources. On the other hand, I'm kind of leaning toward a general
Storage::PurgeVersion(version_id, resources) function now.

 }
 
 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);
+  DecommissionVersion(version_id, 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 90 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) {
+  version->RemoveListener(this);
+  version->SetStatus(ServiceWorkerVersion::REDUNDANT);
+
   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(
+void ServiceWorkerStorage::DecommissionVersion(
     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()) {
+    // Defer decommissioning.
     deleted_version_resource_ids_[version_id] = resources;
     version->AddListener(this);
-  } else {
-    StartPurgingResources(resources);
+    return;
   }
+
+  if (version)
+    version->SetStatus(ServiceWorkerVersion::REDUNDANT);
+  StartPurgingResources(resources);
 }
 
 void ServiceWorkerStorage::StartPurgingResources(
     const std::vector<int64>& ids) {
   for (size_t i = 0; i < ids.size(); ++i)
     purgeable_resource_ids_.push_back(ids[i]);
   ContinuePurgingResources();
 }
 
 void ServiceWorkerStorage::StartPurgingResources(
@@ skipping 269 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