service worker: Add mojo wrappers of uncommitted resource operations

This CL adds the following mojo wrappers ServiceWorkerStorage
operations:
* StoreUncommittedResourceId()
* DoomUncommittedResources()

Bug: 1055677
Change-Id: I09e8086aa4ebed3930ed41137d578126af266c1f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2220129
Commit-Queue: Kenichi Ishibashi <bashi@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Makoto Shimazu <shimazu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#773104}

components/services/storage/public/mojom/service_worker_storage_control.mojom

@@ -177,6 +177,19 @@ interface ServiceWorkerStorageControl {
       int64 resource_id,
       pending_receiver<ServiceWorkerResourceMetadataWriter> writer);
 
+  // Puts |resource_id| on the uncommitted resource list in storage. Once
+  // |resource_id| is put on the uncommitted resource list, the corresponding
+  // resource is considered to be existing in storage but it's not associated
+  // with any registration yet.
+  // StoreRegistration() or DoomUncommittedResources() needs to be
+  // called later to clear the |resource_id| from the uncommitted resource list.
+  StoreUncommittedResourceId(int64 resource_id, url.mojom.Url origin) =>
+      (ServiceWorkerDatabaseStatus status);
+
+  // Removes |resource_ids| from the uncommitted resource list.
+  DoomUncommittedResources(array<int64> resource_ids) =>
+      (ServiceWorkerDatabaseStatus status);
+
   // Gets user data associated with the given |registration_id|.
   // Succeeds only when all keys are found. On success, the size and the order
   // of |values| are the same as |keys|.

content/browser/service_worker/service_worker_storage.h

@@ -42,6 +42,7 @@ class ServiceWorkerDiskCache;
 class ServiceWorkerResponseMetadataWriter;
 class ServiceWorkerResponseReader;
 class ServiceWorkerResponseWriter;
+class ServiceWorkerStorageControlImplTest;
 
 namespace service_worker_storage_unittest {
 class ServiceWorkerStorageTest;
@@ -300,6 +301,7 @@ class CONTENT_EXPORT ServiceWorkerStorage {
   void SetPurgingCompleteCallbackForTest(base::OnceClosure callback);
 
  private:
+  friend class ServiceWorkerStorageControlImplTest;
   friend class service_worker_storage_unittest::ServiceWorkerStorageTest;
   friend class service_worker_storage_unittest::
       ServiceWorkerResourceStorageTest;

content/browser/service_worker/service_worker_storage_control_impl.cc

@@ -254,6 +254,20 @@ void ServiceWorkerStorageControlImpl::CreateResourceMetadataWriter(
       std::move(writer));
 }
 
+void ServiceWorkerStorageControlImpl::StoreUncommittedResourceId(
+    int64_t resource_id,
+    const GURL& origin,
+    StoreUncommittedResourceIdCallback callback) {
+  storage_->StoreUncommittedResourceId(resource_id, origin,
+                                       std::move(callback));
+}
+
+void ServiceWorkerStorageControlImpl::DoomUncommittedResources(
+    const std::vector<int64_t>& resource_ids,
+    DoomUncommittedResourcesCallback callback) {
+  storage_->DoomUncommittedResources(resource_ids, std::move(callback));
+}
+
 void ServiceWorkerStorageControlImpl::GetUserData(
     int64_t registration_id,
     const std::vector<std::string>& keys,

content/browser/service_worker/service_worker_storage_control_impl.h

@@ -101,6 +101,13 @@ class CONTENT_EXPORT ServiceWorkerStorageControlImpl
       int64_t resource_id,
       mojo::PendingReceiver<storage::mojom::ServiceWorkerResourceMetadataWriter>
           writer) override;
+  void StoreUncommittedResourceId(
+      int64_t resource_id,
+      const GURL& origin,
+      StoreUncommittedResourceIdCallback callback) override;
+  void DoomUncommittedResources(
+      const std::vector<int64_t>& resource_ids,
+      DoomUncommittedResourcesCallback callback) override;
   void GetUserData(int64_t registration_id,
                    const std::vector<std::string>& keys,
                    GetUserDataCallback callback) override;

content/browser/service_worker/service_worker_storage_control_impl_unittest.cc

@@ -371,6 +371,33 @@ class ServiceWorkerStorageControlImplTest : public testing::Test {
     return return_value;
   }
 
+  DatabaseStatus StoreUncommittedResourceId(int64_t resource_id,
+                                            const GURL& origin) {
+    DatabaseStatus return_value;
+    base::RunLoop loop;
+    storage()->StoreUncommittedResourceId(
+        resource_id, origin,
+        base::BindLambdaForTesting([&](DatabaseStatus status) {
+          return_value = status;
+          loop.Quit();
+        }));
+    loop.Run();
+    return return_value;
+  }
+
+  DatabaseStatus DoomUncommittedResources(
+      const std::vector<int64_t> resource_ids) {
+    DatabaseStatus return_value;
+    base::RunLoop loop;
+    storage()->DoomUncommittedResources(
+        resource_ids, base::BindLambdaForTesting([&](DatabaseStatus status) {
+          return_value = status;
+          loop.Quit();
+        }));
+    loop.Run();
+    return return_value;
+  }
+
   GetUserDataResult GetUserData(int64_t registration_id,
                                 const std::vector<std::string>& keys) {
     GetUserDataResult result;
@@ -606,6 +633,22 @@ class ServiceWorkerStorageControlImplTest : public testing::Test {
     return writer;
   }
 
+  // Helper function that reads uncommitted resource ids from database.
+  std::vector<int64_t> GetUncommittedResourceIds() {
+    std::vector<int64_t> ids;
+    base::RunLoop loop;
+    ServiceWorkerStorage* internal_storage = storage_impl_->storage();
+    ServiceWorkerDatabase* database_raw = internal_storage->database_.get();
+    internal_storage->database_task_runner_->PostTask(
+        FROM_HERE, base::BindLambdaForTesting([&]() {
+          EXPECT_EQ(ServiceWorkerDatabase::Status::kOk,
+                    database_raw->GetUncommittedResourceIds(&ids));
+          loop.Quit();
+        }));
+    loop.Run();
+    return ids;
+  }
+
  private:
   base::ScopedTempDir user_data_directory_;
   BrowserTaskEnvironment task_environment_;
@@ -974,6 +1017,83 @@ TEST_F(ServiceWorkerStorageControlImplTest, WriteAndReadResource) {
   }
 }
 
+// Tests that uncommitted resources can be listed on storage and these resources
+// will be committed when a registration is stored with these resources.
+TEST_F(ServiceWorkerStorageControlImplTest, UncommittedResources) {
+  const GURL kScope("https://www.example.com/");
+  const GURL kScriptUrl("https://www.example.com/sw.js");
+  const GURL kImportedScriptUrl("https://www.example.com/imported.js");
+
+  LazyInitializeForTest();
+
+  // Preparation: Create a registration with two resources. These aren't written
+  // to storage yet.
+  std::vector<ResourceRecord> resources;
+  const int64_t resource_id1 = GetNewResourceId();
+  const std::string resource_data1 = "main script data";
+  resources.push_back(storage::mojom::ServiceWorkerResourceRecord::New(
+      resource_id1, kScriptUrl, resource_data1.size()));
+
+  const int64_t resource_id2 = GetNewResourceId();
+  const std::string resource_data2 = "imported script data";
+  resources.push_back(storage::mojom::ServiceWorkerResourceRecord::New(
+      resource_id2, kImportedScriptUrl, resource_data2.size()));
+
+  const int64_t registration_id = GetNewRegistrationId();
+  const int64_t version_id = GetNewVersionId();
+  RegistrationData registration_data = CreateRegistrationData(
+      registration_id, version_id, kScope, kScriptUrl, resources);
+
+  // Put these resources ids on the uncommitted list in storage.
+  DatabaseStatus status;
+  status = StoreUncommittedResourceId(resource_id1, kScope.GetOrigin());
+  ASSERT_EQ(status, DatabaseStatus::kOk);
+  status = StoreUncommittedResourceId(resource_id2, kScope.GetOrigin());
+  ASSERT_EQ(status, DatabaseStatus::kOk);
+
+  std::vector<int64_t> uncommitted_ids = GetUncommittedResourceIds();
+  EXPECT_EQ(uncommitted_ids.size(), 2UL);
+
+  // Write responses and the registration data.
+  int result;
+  result = WriteResource(resource_id1, resource_data1);
+  ASSERT_GT(result, 0);
+  result = WriteResource(resource_id2, resource_data2);
+  ASSERT_GT(result, 0);
+  status =
+      StoreRegistration(std::move(registration_data), std::move(resources));
+  ASSERT_EQ(status, DatabaseStatus::kOk);
+
+  // Storing registration should take the resource ids out of the uncommitted
+  // list.
+  uncommitted_ids = GetUncommittedResourceIds();
+  EXPECT_TRUE(uncommitted_ids.empty());
+}
+
+// Tests that uncommitted resource ids are purged by DoomUncommittedResources.
+TEST_F(ServiceWorkerStorageControlImplTest, DoomUncommittedResources) {
+  const GURL kScope("https://www.example.com/");
+
+  LazyInitializeForTest();
+
+  const int64_t resource_id1 = GetNewResourceId();
+  const int64_t resource_id2 = GetNewResourceId();
+
+  DatabaseStatus status;
+  status = StoreUncommittedResourceId(resource_id1, kScope.GetOrigin());
+  ASSERT_EQ(status, DatabaseStatus::kOk);
+  status = StoreUncommittedResourceId(resource_id2, kScope.GetOrigin());
+  ASSERT_EQ(status, DatabaseStatus::kOk);
+
+  std::vector<int64_t> uncommitted_ids = GetUncommittedResourceIds();
+  EXPECT_EQ(uncommitted_ids.size(), 2UL);
+
+  status = DoomUncommittedResources({resource_id1, resource_id2});
+  ASSERT_EQ(status, DatabaseStatus::kOk);
+  uncommitted_ids = GetUncommittedResourceIds();
+  EXPECT_TRUE(uncommitted_ids.empty());
+}
+
 // Tests that storing/getting user data for a registration work.
 TEST_F(ServiceWorkerStorageControlImplTest, StoreAndGetUserData) {
   const GURL kScope("https://www.example.com/");