ServiceWorker: Schedule DeleteAndStartOver when failing to store resource ids

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 "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 518 matching lines @@
   return make_scoped_ptr(
       new ServiceWorkerResponseWriter(response_id, disk_cache()));
 }
 
 scoped_ptr<ServiceWorkerResponseMetadataWriter>
 ServiceWorkerStorage::CreateResponseMetadataWriter(int64 response_id) {
   return make_scoped_ptr(
       new ServiceWorkerResponseMetadataWriter(response_id, disk_cache()));
 }
 
-void ServiceWorkerStorage::StoreUncommittedResponseId(int64 id) {
-  DCHECK_NE(kInvalidServiceWorkerResponseId, id);
+void ServiceWorkerStorage::StoreUncommittedResourceId(int64 resource_id) {
+  DCHECK_NE(kInvalidServiceWorkerResponseId, resource_id);
   DCHECK_EQ(INITIALIZED, state_);
 
   if (!has_checked_for_stale_resources_)
     DeleteStaleResources();
 
-  database_task_manager_->GetTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(
-          &ServiceWorkerDatabase::WriteUncommittedResourceIds),
-          base::Unretained(database_.get()),
-          std::set<int64>(&id, &id + 1)));
+  PostTaskAndReplyWithResult(
+      database_task_manager_->GetTaskRunner(), FROM_HERE,
+      base::Bind(&ServiceWorkerDatabase::WriteUncommittedResourceIds,
+                 base::Unretained(database_.get()),
+                 std::set<int64>(&resource_id, &resource_id + 1)),
+      base::Bind(&ServiceWorkerStorage::DidAccessDatabase,
+                 weak_factory_.GetWeakPtr()));
 }
 
-void ServiceWorkerStorage::DoomUncommittedResponse(int64 id) {
-  DCHECK_NE(kInvalidServiceWorkerResponseId, id);
-  database_task_manager_->GetTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(
-          &ServiceWorkerDatabase::PurgeUncommittedResourceIds),
-          base::Unretained(database_.get()),
-          std::set<int64>(&id, &id + 1)));
-  StartPurgingResources(std::vector<int64>(1, id));

[nhiroki, 2015/10/07 06:10:27]

|id| should not be stored in the diskcache yet, so we don't have to attempt to
purge it.

+void ServiceWorkerStorage::ClearUncommittedResourceId(int64 resource_id) {
+  DCHECK_NE(kInvalidServiceWorkerResponseId, resource_id);
+  PostTaskAndReplyWithResult(
+      database_task_manager_->GetTaskRunner(), FROM_HERE,
+      base::Bind(&ServiceWorkerDatabase::ClearUncommittedResourceIds,
+                 base::Unretained(database_.get()),
+                 std::set<int64>(&resource_id, &resource_id + 1)),
+      base::Bind(&ServiceWorkerStorage::DidAccessDatabase,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerStorage::StoreUserData(
     int64 registration_id,
     const GURL& origin,
     const std::string& key,
     const std::string& data,
     const StatusCallback& callback) {
   DCHECK(state_ == INITIALIZED || state_ == DISABLED) << state_;
   if (IsDisabled()) {
@@ skipping 153 matching lines @@
       ServiceWorkerStatusCode status) {
   installing_registrations_.erase(registration->id());
   if (status != SERVICE_WORKER_OK && version) {
     ResourceList resources;
     version->script_cache_map()->GetResources(&resources);
 
     std::set<int64> ids;
     for (const auto& resource : resources)
       ids.insert(resource.resource_id);
 
-    database_task_manager_->GetTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(base::IgnoreResult(
-            &ServiceWorkerDatabase::PurgeUncommittedResourceIds),
-            base::Unretained(database_.get()),
-            ids));
+    PostTaskAndReplyWithResult(
+        database_task_manager_->GetTaskRunner(), FROM_HERE,
+        base::Bind(
+            &ServiceWorkerDatabase::MoveResourceIdsFromUncommittedToPurgeable,
+            base::Unretained(database_.get()), ids),
+        base::Bind(&ServiceWorkerStorage::DidAccessDatabase,
+                   weak_factory_.GetWeakPtr()));
   }
 }
 
 void ServiceWorkerStorage::NotifyUninstallingRegistration(
     ServiceWorkerRegistration* registration) {
   DCHECK(uninstalling_registrations_.find(registration->id()) ==
          uninstalling_registrations_.end());
   uninstalling_registrations_[registration->id()] = registration;
 }
 
@@ skipping 393 matching lines @@
         -deleted_version.resources_total_size_bytes);
   }
   if (origin_is_deletable)
     registered_origins_.erase(params.origin);
   params.callback.Run(SERVICE_WORKER_OK);
 
   if (!context_->GetLiveVersion(deleted_version.version_id))
     StartPurgingResources(newly_purgeable_resources);
 }
 
+void ServiceWorkerStorage::DidAccessDatabase(
+    ServiceWorkerDatabase::Status status) {
+  if (status != ServiceWorkerDatabase::STATUS_OK)
+    ScheduleDeleteAndStartOver();
+}
+
 void ServiceWorkerStorage::DidStoreUserData(
     const StatusCallback& callback,
     ServiceWorkerDatabase::Status status) {
   // |status| can be NOT_FOUND when the associated registration did not exist in
   // the database. In the case, we don't have to schedule the corruption
   // recovery.
   if (status != ServiceWorkerDatabase::STATUS_OK &&
       status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
     ScheduleDeleteAndStartOver();
   }
@@ skipping 330 matching lines @@
   ServiceWorkerDatabase::Status status =
       database->GetUncommittedResourceIds(&ids);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
         FROM_HERE,
         base::Bind(
             callback, std::vector<int64>(ids.begin(), ids.end()), status));
     return;
   }
 
-  status = database->PurgeUncommittedResourceIds(ids);
+  status = database->MoveResourceIdsFromUncommittedToPurgeable(ids);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
         FROM_HERE,
         base::Bind(
             callback, std::vector<int64>(ids.begin(), ids.end()), status));
     return;
   }
 
   ids.clear();
   status = database->GetPurgeableResourceIds(&ids);
@@ skipping 304 matching lines @@
     callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully.";
   ServiceWorkerMetrics::RecordDeleteAndStartOverResult(
       ServiceWorkerMetrics::DELETE_OK);
   callback.Run(SERVICE_WORKER_OK);
 }
 
 }  // namespace content