Add GetRegistrationsForOrigin to ServiceWorkerStorageControl

The method is a wrapper of
ServiceWorkerStorage::GetRegistrationsForOrigin().

This CL also adds a wrapper for GetNewRegistrationId() to test
the wrapper methods.

Bug: 1055677
Change-Id: Ibe04b228ca8334fff1781828720053c1bdc2fcf6
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2137102
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@{#756873}

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

@@ -9,6 +9,12 @@ import "mojo/public/mojom/base/big_buffer.mojom";
 import "services/network/public/mojom/url_response_head.mojom";
 import "url/mojom/url.mojom";
 
+// This struct represents a serialized service worker registration.
+struct SerializedServiceWorkerRegistration {
+  ServiceWorkerRegistrationData registration_data;
+  array<ServiceWorkerResourceRecord> resources;
+};
+
 // Conveys a result of finding a registration. If a registration is found,
 // |status| will be kOk. |registration| and |resources| are null and empty
 // if there is no matching registration.
@@ -67,6 +73,11 @@ interface ServiceWorkerStorageControl {
   FindRegistrationForId(int64 registration_id, url.mojom.Url origin) =>
       (ServiceWorkerFindRegistrationResult result);
 
+  // Returns all stored registrations for a given origin.
+  GetRegistrationsForOrigin(url.mojom.Url origin) =>
+      (ServiceWorkerDatabaseStatus status,
+       array<SerializedServiceWorkerRegistration> registrations);
+
   // Stores |registration_data| and |resources| on persistent storage.
   StoreRegistration(ServiceWorkerRegistrationData registration,
                     array<ServiceWorkerResourceRecord> resources) =>
@@ -78,6 +89,10 @@ interface ServiceWorkerStorageControl {
       (ServiceWorkerDatabaseStatus status,
        ServiceWorkerStorageOriginState origin_state);
 
+  // Returns a new registration id which is guaranteed to be unique in the
+  // storage. Returns blink::mojom::kInvalidServiceWorkerRegistrationId if the
+  // storage is disabled.
+  GetNewRegistrationId() => (int64 registration_id);
   // Returns a new resource id which is guaranteed to be unique in the storage.
   // Returns blink::mojom::kInvalidServiceWorkerResourceId if the storage
   // is disabled.

content/browser/service_worker/service_worker_storage_control_impl.cc

@@ -47,6 +47,27 @@ void DidDeleteRegistration(
   std::move(callback).Run(status, origin_state);
 }
 
+void DidGetRegistrationsForOrigin(
+    ServiceWorkerStorageControlImpl::GetRegistrationsForOriginCallback callback,
+    storage::mojom::ServiceWorkerDatabaseStatus status,
+    std::unique_ptr<ServiceWorkerStorage::RegistrationList>
+        registration_data_list,
+    std::unique_ptr<std::vector<ServiceWorkerStorage::ResourceList>>
+        resources_list) {
+  DCHECK_EQ(registration_data_list->size(), resources_list->size());
+
+  std::vector<storage::mojom::SerializedServiceWorkerRegistrationPtr>
+      registrations;
+  for (size_t i = 0; i < registration_data_list->size(); ++i) {
+    registrations.push_back(
+        storage::mojom::SerializedServiceWorkerRegistration::New(
+            std::move((*registration_data_list)[i]),
+            std::move((*resources_list)[i])));
+  }
+
+  std::move(callback).Run(status, std::move(registrations));
+}
+
 }  // namespace
 
 ServiceWorkerStorageControlImpl::ServiceWorkerStorageControlImpl(
@@ -84,6 +105,14 @@ void ServiceWorkerStorageControlImpl::FindRegistrationForId(
       base::BindOnce(&DidFindRegistration, std::move(callback)));
 }
 
+void ServiceWorkerStorageControlImpl::GetRegistrationsForOrigin(
+    const GURL& origin,
+    GetRegistrationsForOriginCallback callback) {
+  storage_->GetRegistrationsForOrigin(
+      origin,
+      base::BindOnce(&DidGetRegistrationsForOrigin, std::move(callback)));
+}
+
 void ServiceWorkerStorageControlImpl::StoreRegistration(
     storage::mojom::ServiceWorkerRegistrationDataPtr registration,
     std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> resources,
@@ -106,6 +135,11 @@ void ServiceWorkerStorageControlImpl::DeleteRegistration(
       base::BindOnce(&DidDeleteRegistration, std::move(callback)));
 }
 
+void ServiceWorkerStorageControlImpl::GetNewRegistrationId(
+    GetNewRegistrationIdCallback callback) {
+  storage_->GetNewRegistrationId(std::move(callback));
+}
+
 void ServiceWorkerStorageControlImpl::GetNewResourceId(
     GetNewResourceIdCallback callback) {
   storage_->GetNewResourceId(std::move(callback));

content/browser/service_worker/service_worker_storage_control_impl.h

@@ -45,6 +45,9 @@ class CONTENT_EXPORT ServiceWorkerStorageControlImpl
   void FindRegistrationForId(int64_t registration_id,
                              const GURL& origin,
                              FindRegistrationForIdCallback callback) override;
+  void GetRegistrationsForOrigin(
+      const GURL& origin,
+      GetRegistrationsForOriginCallback callback) override;
   void StoreRegistration(
       storage::mojom::ServiceWorkerRegistrationDataPtr registration,
       std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> resources,
@@ -52,6 +55,7 @@ class CONTENT_EXPORT ServiceWorkerStorageControlImpl
   void DeleteRegistration(int64_t registration_id,
                           const GURL& origin,
                           DeleteRegistrationCallback callback) override;
+  void GetNewRegistrationId(GetNewRegistrationIdCallback callback) override;
   void GetNewResourceId(GetNewResourceIdCallback callback) override;
   void CreateResourceReader(
       int64_t resource_id,

content/browser/service_worker/service_worker_storage_control_impl_unittest.cc

@@ -135,6 +135,26 @@ class ServiceWorkerStorageControlImplTest : public testing::Test {
     return return_value;
   }
 
+  void GetRegistrationsForOrigin(
+      const GURL& origin,
+      DatabaseStatus& out_status,
+      std::vector<storage::mojom::SerializedServiceWorkerRegistrationPtr>&
+          out_registrations) {
+    base::RunLoop loop;
+    storage()->GetRegistrationsForOrigin(
+        origin,
+        base::BindLambdaForTesting(
+            [&](DatabaseStatus status,
+                std::vector<
+                    storage::mojom::SerializedServiceWorkerRegistrationPtr>
+                    registrations) {
+              out_status = status;
+              out_registrations = std::move(registrations);
+              loop.Quit();
+            }));
+    loop.Run();
+  }
+
   void StoreRegistration(
       storage::mojom::ServiceWorkerRegistrationDataPtr registration,
       std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> resources,
@@ -167,6 +187,18 @@ class ServiceWorkerStorageControlImplTest : public testing::Test {
     loop.Run();
   }
 
+  int64_t GetNewRegistrationId() {
+    int64_t return_value;
+    base::RunLoop loop;
+    storage()->GetNewRegistrationId(
+        base::BindLambdaForTesting([&](int64_t registration_id) {
+          return_value = registration_id;
+          loop.Quit();
+        }));
+    loop.Run();
+    return return_value;
+  }
+
   int64_t GetNewResourceId() {
     int64_t return_value;
     base::RunLoop loop;
@@ -179,6 +211,33 @@ class ServiceWorkerStorageControlImplTest : public testing::Test {
     return return_value;
   }
 
+  // Create a registration with a single resource and stores the registration.
+  DatabaseStatus CreateAndStoreRegistration(int64_t registration_id,
+                                            const GURL& scope,
+                                            const GURL& script_url,
+                                            int64_t script_size) {
+    std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> resources;
+    resources.push_back(storage::mojom::ServiceWorkerResourceRecord::New(
+        registration_id, script_url, script_size));
+
+    auto data = storage::mojom::ServiceWorkerRegistrationData::New();
+    data->registration_id = registration_id;
+    data->scope = scope;
+    data->script = script_url;
+    data->navigation_preload_state =
+        blink::mojom::NavigationPreloadState::New();
+
+    int64_t resources_total_size_bytes = 0;
+    for (auto& resource : resources) {
+      resources_total_size_bytes += resource->size_bytes;
+    }
+    data->resources_total_size_bytes = resources_total_size_bytes;
+
+    DatabaseStatus status;
+    StoreRegistration(std::move(data), std::move(resources), status);
+    return status;
+  }
+
   mojo::Remote<storage::mojom::ServiceWorkerResourceReader>
   CreateResourceReader(int64_t resource_id) {
     mojo::Remote<storage::mojom::ServiceWorkerResourceReader> reader;
@@ -301,6 +360,57 @@ TEST_F(ServiceWorkerStorageControlImplTest, StoreAndDeleteRegistration) {
   }
 }
 
+// Tests that getting registrations works.
+TEST_F(ServiceWorkerStorageControlImplTest, GetRegistrationsForOrigin) {
+  const GURL kScope1("https://www.example.com/foo/");
+  const GURL kScriptUrl1("https://www.example.com/foo/sw.js");
+  const GURL kScope2("https://www.example.com/bar/");
+  const GURL kScriptUrl2("https://www.example.com/bar/sw.js");
+  const int64_t kScriptSize = 10;
+
+  LazyInitializeForTest();
+
+  // Store two registrations which have the same origin.
+  DatabaseStatus status;
+  const int64_t registration_id1 = GetNewRegistrationId();
+  status = CreateAndStoreRegistration(registration_id1, kScope1, kScriptUrl1,
+                                      kScriptSize);
+  ASSERT_EQ(status, DatabaseStatus::kOk);
+  const int64_t registration_id2 = GetNewRegistrationId();
+  status = CreateAndStoreRegistration(registration_id2, kScope2, kScriptUrl2,
+                                      kScriptSize);
+  ASSERT_EQ(status, DatabaseStatus::kOk);
+
+  // Get registrations for the origin.
+  {
+    const GURL& origin = kScope1.GetOrigin();
+    std::vector<storage::mojom::SerializedServiceWorkerRegistrationPtr>
+        registrations;
+
+    GetRegistrationsForOrigin(origin, status, registrations);
+    ASSERT_EQ(status, DatabaseStatus::kOk);
+    EXPECT_EQ(registrations.size(), 2UL);
+
+    for (auto& registration : registrations) {
+      EXPECT_EQ(registration->registration_data->scope.GetOrigin(), origin);
+      EXPECT_EQ(registration->registration_data->resources_total_size_bytes,
+                kScriptSize);
+    }
+  }
+
+  // Getting registrations for another origin should succeed but shouldn't find
+  // anything.
+  {
+    const GURL& origin = GURL("https://www.example.test/");
+    std::vector<storage::mojom::SerializedServiceWorkerRegistrationPtr>
+        registrations;
+
+    GetRegistrationsForOrigin(origin, status, registrations);
+    ASSERT_EQ(status, DatabaseStatus::kOk);
+    EXPECT_EQ(registrations.size(), 0UL);
+  }
+}
+
 // Tests that writing/reading a service worker script succeed.
 TEST_F(ServiceWorkerStorageControlImplTest, WriteAndReadResource) {
   LazyInitializeForTest();