service worker: Add wrapper of StoreUncommittedResourceId()

This CL moves ScheduleDeleteAndStartOver() call from
ServiceWorkerStorage::DidWriteUncommittedResourceId() to
ServiceWorkerRegistry so that we can reduce ServiceWorkerContextCore
dependency from ServiceWorkerStorage.

Bug: 1039200
Change-Id: If6ca49d6489fbe34a777a3b005ff1a6792e4e257
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2026336
Commit-Queue: Kenichi Ishibashi <bashi@chromium.org>
Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#737176}

content/browser/service_worker/service_worker_registry.cc

@@ -348,6 +348,13 @@ void ServiceWorkerRegistry::UpdateToActiveState(int64_t registration_id,
                      weak_factory_.GetWeakPtr(), std::move(callback)));
 }
 
+void ServiceWorkerRegistry::StoreUncommittedResourceId(int64_t resource_id) {
+  storage()->StoreUncommittedResourceId(
+      resource_id,
+      base::BindOnce(&ServiceWorkerRegistry::DidWriteUncommittedResourceIds,
+                     weak_factory_.GetWeakPtr()));
+}
+
 void ServiceWorkerRegistry::GetUserData(int64_t registration_id,
                                         const std::vector<std::string>& keys,
                                         GetUserDataCallback callback) {
@@ -923,6 +930,12 @@ void ServiceWorkerRegistry::DidUpdateToActiveState(
       ServiceWorkerStorage::DatabaseStatusToStatusCode(status));
 }
 
+void ServiceWorkerRegistry::DidWriteUncommittedResourceIds(
+    ServiceWorkerDatabase::Status status) {
+  if (status != ServiceWorkerDatabase::STATUS_OK)
+    ScheduleDeleteAndStartOver();
+}
+
 void ServiceWorkerRegistry::DidGetUserData(
     GetUserDataCallback callback,
     const std::vector<std::string>& data,

content/browser/service_worker/service_worker_registry.h

@@ -167,6 +167,7 @@ class CONTENT_EXPORT ServiceWorkerRegistry {
   void UpdateToActiveState(int64_t registration_id,
                            const GURL& origin,
                            StatusCallback callback);
+  void StoreUncommittedResourceId(int64_t resource_id);
   void GetUserData(int64_t registration_id,
                    const std::vector<std::string>& keys,
                    GetUserDataCallback callback);
@@ -263,6 +264,7 @@ class CONTENT_EXPORT ServiceWorkerRegistry {
 
   void DidUpdateToActiveState(StatusCallback callback,
                               ServiceWorkerDatabase::Status status);
+  void DidWriteUncommittedResourceIds(ServiceWorkerDatabase::Status status);
   void DidGetUserData(GetUserDataCallback callback,
                       const std::vector<std::string>& data,
                       ServiceWorkerDatabase::Status status);

content/browser/service_worker/service_worker_script_cache_map.cc

@@ -45,7 +45,7 @@ void ServiceWorkerScriptCacheMap::NotifyStartedCaching(const GURL& url,
   resource_map_[url] = ServiceWorkerDatabase::ResourceRecord(
       resource_id, url,
       ServiceWorkerDatabase::ResourceRecord::ErrorState::kStartedCaching);
-  context_->storage()->StoreUncommittedResourceId(resource_id);
+  context_->registry()->StoreUncommittedResourceId(resource_id);
 }
 
 void ServiceWorkerScriptCacheMap::NotifyFinishedCaching(

content/browser/service_worker/service_worker_storage.cc

@@ -499,13 +499,19 @@ ServiceWorkerStorage::CreateResponseMetadataWriter(int64_t resource_id) {
       resource_id, disk_cache()->GetWeakPtr()));
 }
 
-void ServiceWorkerStorage::StoreUncommittedResourceId(int64_t resource_id) {
+void ServiceWorkerStorage::StoreUncommittedResourceId(
+    int64_t resource_id,
+    DatabaseStatusCallback callback) {
   DCHECK_NE(ServiceWorkerConsts::kInvalidServiceWorkerResourceId, resource_id);
   DCHECK(STORAGE_STATE_INITIALIZED == state_ ||
          STORAGE_STATE_DISABLED == state_)
       << state_;
-  if (IsDisabled())
+  if (IsDisabled()) {
+    RunSoon(FROM_HERE,
+            base::BindOnce(std::move(callback),
+                           ServiceWorkerDatabase::STATUS_ERROR_DISABLED));
     return;
+  }
 
   if (!has_checked_for_stale_resources_)
     DeleteStaleResources();
@@ -515,8 +521,7 @@ void ServiceWorkerStorage::StoreUncommittedResourceId(int64_t resource_id) {
       base::BindOnce(&ServiceWorkerDatabase::WriteUncommittedResourceIds,
                      base::Unretained(database_.get()),
                      std::set<int64_t>(&resource_id, &resource_id + 1)),
-      base::BindOnce(&ServiceWorkerStorage::DidWriteUncommittedResourceIds,
-                     weak_factory_.GetWeakPtr()));
+      std::move(callback));
 }
 
 void ServiceWorkerStorage::DoomUncommittedResource(int64_t resource_id) {
@@ -1110,12 +1115,6 @@ void ServiceWorkerStorage::DidDeleteRegistration(
            newly_purgeable_resources);
 }
 
-void ServiceWorkerStorage::DidWriteUncommittedResourceIds(
-    ServiceWorkerDatabase::Status status) {
-  if (status != ServiceWorkerDatabase::STATUS_OK)
-    ScheduleDeleteAndStartOver();
-}
-
 void ServiceWorkerStorage::DidPurgeUncommittedResourceIds(
     const std::set<int64_t>& resource_ids,
     ServiceWorkerDatabase::Status status) {

content/browser/service_worker/service_worker_storage.h

@@ -194,7 +194,8 @@ class CONTENT_EXPORT ServiceWorkerStorage {
 
   // Adds |resource_id| to the set of resources that are in the disk cache
   // but not yet stored with a registration.
-  void StoreUncommittedResourceId(int64_t resource_id);
+  void StoreUncommittedResourceId(int64_t resource_id,
+                                  DatabaseStatusCallback callback);
 
   // Removes resource ids from uncommitted list, adds them to the purgeable list
   // and purges them.
@@ -391,7 +392,6 @@ class CONTENT_EXPORT ServiceWorkerStorage {
       const ServiceWorkerDatabase::RegistrationData& deleted_version,
       const std::vector<int64_t>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status);
-  void DidWriteUncommittedResourceIds(ServiceWorkerDatabase::Status status);
   void DidPurgeUncommittedResourceIds(const std::set<int64_t>& resource_ids,
                                       ServiceWorkerDatabase::Status status);
 

content/browser/service_worker/service_worker_storage_unittest.cc

@@ -1265,8 +1265,8 @@ class ServiceWorkerResourceStorageTest : public ServiceWorkerStorageTest {
     registration_->waiting_version()->SetStatus(ServiceWorkerVersion::NEW);
 
     // Add the resources ids to the uncommitted list.
-    storage()->StoreUncommittedResourceId(resource_id1_);
-    storage()->StoreUncommittedResourceId(resource_id2_);
+    registry()->StoreUncommittedResourceId(resource_id1_);
+    registry()->StoreUncommittedResourceId(resource_id2_);
 
     std::set<int64_t> verify_ids = GetUncommittedResourceIdsFromDB();
     EXPECT_EQ(2u, verify_ids.size());
@@ -1471,7 +1471,7 @@ TEST_F(ServiceWorkerResourceStorageDiskTest, CleanupOnRestart) {
 
   // Also add an uncommitted resource.
   int64_t kStaleUncommittedResourceId = storage()->NewResourceId();
-  storage()->StoreUncommittedResourceId(kStaleUncommittedResourceId);
+  registry()->StoreUncommittedResourceId(kStaleUncommittedResourceId);
   verify_ids = GetUncommittedResourceIdsFromDB();
   EXPECT_EQ(1u, verify_ids.size());
   WriteBasicResponse(storage(), kStaleUncommittedResourceId);
@@ -1488,7 +1488,7 @@ TEST_F(ServiceWorkerResourceStorageDiskTest, CleanupOnRestart) {
   storage()->SetPurgingCompleteCallbackForTest(loop.QuitClosure());
   int64_t kNewResourceId = storage()->NewResourceId();
   WriteBasicResponse(storage(), kNewResourceId);
-  storage()->StoreUncommittedResourceId(kNewResourceId);
+  registry()->StoreUncommittedResourceId(kNewResourceId);
   loop.Run();
 
   // The stale resources should be purged, but the new resource should persist.