Don't prematurely delete script resources when registration is deleted

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 98 matching lines @@
     base::WeakPtr<ServiceWorkerContextCore> context,
     ServiceWorkerStorage* old_storage) {
   return make_scoped_ptr(
       new ServiceWorkerStorage(old_storage->path_,
                                context,
                                old_storage->database_task_runner_,
                                old_storage->disk_cache_thread_,
                                old_storage->quota_manager_proxy_));
 }
 
-
 void ServiceWorkerStorage::FindRegistrationForDocument(
     const GURL& document_url,
     const FindRegistrationCallback& callback) {
   DCHECK(!document_url.has_ref());
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::FindRegistrationForDocument,
           weak_factory_.GetWeakPtr(), document_url, callback))) {
     if (state_ != INITIALIZING || !context_) {
       CompleteFindNow(scoped_refptr<ServiceWorkerRegistration>(),
                       SERVICE_WORKER_ERROR_FAILED, callback);
@@ skipping 212 matching lines @@
                  registration_id, origin,
                  base::Bind(&ServiceWorkerStorage::DidDeleteRegistration,
                             weak_factory_.GetWeakPtr(), origin, callback)));
 
   // TODO(michaeln): Either its instance should also be
   // removed from liveregistrations map or the live object
   // should marked as deleted in some way and not 'findable'
   // thereafter.
 }
 
+void ServiceWorkerStorage::DeleteVersionResources(
+    int64 version_id,
+    const StatusCallback& callback) {
+  DCHECK(state_ == INITIALIZED || state_ == DISABLED);
+  if (state_ != INITIALIZED || !context_) {
+    RunSoon(FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
+    return;
+  }
+
+  database_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&DeleteVersionResourcesFromDB,
+                 database_.get(),
+                 base::MessageLoopProxy::current(),
+                 version_id,
+                 base::Bind(&ServiceWorkerStorage::DidDeleteVersionResources,
+                            weak_factory_.GetWeakPtr(),
+                            callback)));
+}
+
 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) {
   return make_scoped_ptr(
       new ServiceWorkerResponseWriter(response_id, disk_cache()));
@@ skipping 323 matching lines @@
     const GURL& origin,
     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);
   StartPurgingResources(newly_purgeable_resources);

[michaeln, 2014/06/28 02:29:31]

ditto defer this call...

 }
 
 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,
-    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);
+}
+
+void ServiceWorkerStorage::DidDeleteVersionResources(
+    const StatusCallback& callback,
+    const std::vector<int64>& newly_purgeable_resources,
+    ServiceWorkerDatabase::Status status) {
+  if (status != ServiceWorkerDatabase::STATUS_OK) {
+    ScheduleDeleteAndStartOver();
+    callback.Run(DatabaseStatusToStatusCode(status));
+    return;
+  }
+  callback.Run(SERVICE_WORKER_OK);
   StartPurgingResources(newly_purgeable_resources);

[michaeln, 2014/06/28 02:29:31]

Just the startpurging should be deferred till nomo controlleee time.

 }
 
 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 92 matching lines @@
     LOG(ERROR) << "Failed to open the serviceworker diskcache: "
                << net::ErrorToString(rv);
     ScheduleDeleteAndStartOver();
   }
   ServiceWorkerHistograms::CountInitDiskCacheResult(rv == net::OK);
 }
 
 void ServiceWorkerStorage::StartPurgingResources(
     const std::vector<int64>& ids) {
   for (size_t i = 0; i < ids.size(); ++i)
-    purgeable_reource_ids_.push_back(ids[i]);
+    purgeable_resource_ids_.push_back(ids[i]);
   ContinuePurgingResources();
 }
 
 void ServiceWorkerStorage::StartPurgingResources(
     const ResourceList& resources) {
   for (size_t i = 0; i < resources.size(); ++i)
-    purgeable_reource_ids_.push_back(resources[i].resource_id);
+    purgeable_resource_ids_.push_back(resources[i].resource_id);
   ContinuePurgingResources();
 }
 
 void ServiceWorkerStorage::ContinuePurgingResources() {
-  if (purgeable_reource_ids_.empty() || is_purge_pending_)
+  if (purgeable_resource_ids_.empty() || is_purge_pending_)
     return;
 
   // Do one at a time until we're done, use RunSoon to avoid recursion when
   // DoomEntry returns immediately.
   is_purge_pending_ = true;
-  int64 id = purgeable_reource_ids_.front();
-  purgeable_reource_ids_.pop_front();
+  int64 id = purgeable_resource_ids_.front();
+  purgeable_resource_ids_.pop_front();
   RunSoon(FROM_HERE,
           base::Bind(&ServiceWorkerStorage::PurgeResource,
                      weak_factory_.GetWeakPtr(), id));
 }
 
 void ServiceWorkerStorage::PurgeResource(int64 id) {
   DCHECK(is_purge_pending_);
   int rv = disk_cache()->DoomEntry(
       id, base::Bind(&ServiceWorkerStorage::OnResourcePurged,
                      weak_factory_.GetWeakPtr(), id));
@@ skipping 41 matching lines @@
 void ServiceWorkerStorage::DeleteRegistrationFromDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     int64 registration_id,
     const GURL& origin,
     const DeleteRegistrationCallback& callback) {
   DCHECK(database);
 
   std::vector<int64> newly_purgeable_resources;
   ServiceWorkerDatabase::Status status =
-      database->DeleteRegistration(registration_id, origin,
-                                   &newly_purgeable_resources);
+      database->DeleteRegistration(registration_id, origin);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
-    original_task_runner->PostTask(
-        FROM_HERE, base::Bind(callback, false, std::vector<int64>(), status));
+    original_task_runner->PostTask(FROM_HERE,
+                                   base::Bind(callback, false, status));
     return;
   }
 
   // TODO(nhiroki): Add convenient method to ServiceWorkerDatabase to check the
   // unique origin list.
   std::vector<ServiceWorkerDatabase::RegistrationData> registrations;
   status = database->GetRegistrationsForOrigin(origin, &registrations);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
-    original_task_runner->PostTask(
-        FROM_HERE, base::Bind(callback, false, std::vector<int64>(), status));
+    original_task_runner->PostTask(FROM_HERE,
+                                   base::Bind(callback, false, status));
     return;
   }
 
   bool deletable = registrations.empty();
+  original_task_runner->PostTask(FROM_HERE,
+                                 base::Bind(callback, deletable, status));
+}
+
+void ServiceWorkerStorage::DeleteVersionResourcesFromDB(
+    ServiceWorkerDatabase* database,
+    scoped_refptr<base::SequencedTaskRunner> original_task_runner,
+    int64 version_id,
+    const DeleteVersionResourcesCallback& callback) {
+  DCHECK(database);
+
+  std::vector<int64> newly_purgeable_resources;
+  ServiceWorkerDatabase::Status status =
+      database->DeleteVersionResources(version_id, &newly_purgeable_resources);
+  if (status != ServiceWorkerDatabase::STATUS_OK) {
+    original_task_runner->PostTask(
+        FROM_HERE, base::Bind(callback, std::vector<int64>(), status));
+    return;
+  }
+
   original_task_runner->PostTask(
-      FROM_HERE, base::Bind(callback, deletable,
-                            newly_purgeable_resources, status));
+      FROM_HERE, base::Bind(callback, newly_purgeable_resources, status));
 }
 
 void ServiceWorkerStorage::WriteRegistrationInDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     const ServiceWorkerDatabase::RegistrationData& data,
     const ResourceList& resources,
     const WriteRegistrationCallback& callback) {
   DCHECK(database);
   std::vector<int64> newly_purgeable_resources;
@@ skipping 141 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