Add ServiceWorkerStorageControl::ApplyPolicyUpdates()

This is a wrapper of ServiceWorkerStorage::ApplyPolicyUpdates().

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

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

@@ -4,6 +4,7 @@
 
 module storage.mojom;
 
+import "components/services/storage/public/mojom/local_storage_control.mojom";
 import "components/services/storage/public/mojom/service_worker_database.mojom";
 import "mojo/public/mojom/base/big_buffer.mojom";
 import "mojo/public/mojom/base/time.mojom";
@@ -187,4 +188,8 @@ interface ServiceWorkerStorageControl {
   // of keys.
   ClearUserDataForAllRegistrationsByKeyPrefix(string key_prefix) =>
       (ServiceWorkerDatabaseStatus status);
+
+  // Applies changes to data retention policy which are relevant at shutdown.
+  // This is analogous to LocalStorageControl::ApplyPolicyUpdates.
+  ApplyPolicyUpdates(array<LocalStoragePolicyUpdate> policy_updates);
 };

content/browser/service_worker/service_worker_storage.cc

@@ -56,8 +56,7 @@ void MaybeNotifyWriteFailed(
   }
 }
 
-const base::FilePath::CharType kDatabaseName[] =
-    FILE_PATH_LITERAL("Database");
+const base::FilePath::CharType kDatabaseName[] = FILE_PATH_LITERAL("Database");
 const base::FilePath::CharType kDiskCacheName[] =
     FILE_PATH_LITERAL("ScriptCache");
 
@@ -68,8 +67,7 @@ ServiceWorkerStorage::InitialData::InitialData()
       next_version_id(blink::mojom::kInvalidServiceWorkerVersionId),
       next_resource_id(blink::mojom::kInvalidServiceWorkerResourceId) {}
 
-ServiceWorkerStorage::InitialData::~InitialData() {
-}
+ServiceWorkerStorage::InitialData::~InitialData() = default;
 
 ServiceWorkerStorage::DidDeleteRegistrationParams::DidDeleteRegistrationParams(
     int64_t registration_id,
@@ -896,7 +894,8 @@ void ServiceWorkerStorage::PurgeResources(
 }
 
 void ServiceWorkerStorage::ApplyPolicyUpdates(
-    std::vector<storage::mojom::LocalStoragePolicyUpdatePtr> policy_updates) {
+    const std::vector<storage::mojom::LocalStoragePolicyUpdatePtr>&
+        policy_updates) {
   for (const auto& update : policy_updates) {
     GURL url = update->origin.GetURL();
     if (!update->purge_on_shutdown)
@@ -1303,10 +1302,9 @@ void ServiceWorkerStorage::ReadInitialDataFromDB(
   std::unique_ptr<ServiceWorkerStorage::InitialData> data(
       new ServiceWorkerStorage::InitialData());
 
-  ServiceWorkerDatabase::Status status =
-      database->GetNextAvailableIds(&data->next_registration_id,
-                                    &data->next_version_id,
-                                    &data->next_resource_id);
+  ServiceWorkerDatabase::Status status = database->GetNextAvailableIds(
+      &data->next_registration_id, &data->next_version_id,
+      &data->next_resource_id);
   if (status != ServiceWorkerDatabase::Status::kOk) {
     original_task_runner->PostTask(
         FROM_HERE,

content/browser/service_worker/service_worker_storage.h

@@ -295,7 +295,8 @@ class CONTENT_EXPORT ServiceWorkerStorage {
 
   // Applies |policy_updates|.
   void ApplyPolicyUpdates(
-      std::vector<storage::mojom::LocalStoragePolicyUpdatePtr> policy_updates);
+      const std::vector<storage::mojom::LocalStoragePolicyUpdatePtr>&
+          policy_updates);
 
   void LazyInitializeForTest();
 
@@ -500,9 +501,8 @@ class CONTENT_EXPORT ServiceWorkerStorage {
       scoped_refptr<base::SequencedTaskRunner> original_task_runner,
       const std::string& key_prefix,
       GetUserDataForAllRegistrationsInDBCallback callback);
-  static void DeleteAllDataForOriginsFromDB(
-      ServiceWorkerDatabase* database,
-      const std::set<GURL>& origins);
+  static void DeleteAllDataForOriginsFromDB(ServiceWorkerDatabase* database,
+                                            const std::set<GURL>& origins);
   static void PerformStorageCleanupInDB(ServiceWorkerDatabase* database);
 
   // Posted by the underlying cache implementation after it finishes making

content/browser/service_worker/service_worker_storage_control_impl.cc

@@ -310,4 +310,10 @@ void ServiceWorkerStorageControlImpl::
                                                         std::move(callback));
 }
 
+void ServiceWorkerStorageControlImpl::ApplyPolicyUpdates(
+    const std::vector<storage::mojom::LocalStoragePolicyUpdatePtr>
+        policy_updates) {
+  storage_->ApplyPolicyUpdates(std::move(policy_updates));
+}
+
 }  // namespace content

content/browser/service_worker/service_worker_storage_control_impl.h

@@ -109,6 +109,9 @@ class CONTENT_EXPORT ServiceWorkerStorageControlImpl
   void ClearUserDataForAllRegistrationsByKeyPrefix(
       const std::string& key_prefix,
       ClearUserDataForAllRegistrationsByKeyPrefixCallback callback) override;
+  void ApplyPolicyUpdates(
+      const std::vector<storage::mojom::LocalStoragePolicyUpdatePtr>
+          policy_updates) override;
 
   const std::unique_ptr<ServiceWorkerStorage> storage_;
 };

content/browser/service_worker/service_worker_storage_control_impl_unittest.cc

@@ -152,7 +152,12 @@ class ServiceWorkerStorageControlImplTest : public testing::Test {
 
   void SetUp() override {
     ASSERT_TRUE(user_data_directory_.CreateUniqueTempDir());
+    SetUpStorage();
+  }
+
+  void TearDown() override { DestroyStorage(); }
 
+  void SetUpStorage() {
     auto storage = ServiceWorkerStorage::Create(
         user_data_directory_.GetPath(),
         /*database_task_runner=*/base::ThreadTaskRunnerHandle::Get(),
@@ -161,12 +166,18 @@ class ServiceWorkerStorageControlImplTest : public testing::Test {
         std::make_unique<ServiceWorkerStorageControlImpl>(std::move(storage));
   }
 
-  void TearDown() override {
+  void DestroyStorage() {
     storage_impl_.reset();
     disk_cache::FlushCacheThreadForTesting();
     content::RunAllTasksUntilIdle();
   }
 
+  void RestartStorage() {
+    DestroyStorage();
+    SetUpStorage();
+    LazyInitializeForTest();
+  }
+
   storage::mojom::ServiceWorkerStorageControl* storage() {
     return storage_impl_.get();
   }
@@ -1099,4 +1110,46 @@ TEST_F(ServiceWorkerStorageControlImplTest,
   EXPECT_EQ(result.values.size(), 0UL);
 }
 
+// Tests that apply policy updates work.
+TEST_F(ServiceWorkerStorageControlImplTest, ApplyPolicyUpdates) {
+  const GURL kScope1("https://foo.example.com/");
+  const GURL kScriptUrl1("https://foo.example.com/sw.js");
+  const GURL kScope2("https://bar.example.com/");
+  const GURL kScriptUrl2("https://bar.example.com/sw.js");
+  const int64_t kScriptSize = 10;
+
+  LazyInitializeForTest();
+
+  // Preparation: Create and store two registrations.
+  DatabaseStatus status;
+  const int64_t registration_id1 = GetNewRegistrationId();
+  const int64_t version_id1 = GetNewVersionId();
+  status = CreateAndStoreRegistration(registration_id1, version_id1, kScope1,
+                                      kScriptUrl1, kScriptSize);
+  ASSERT_EQ(status, DatabaseStatus::kOk);
+  const int64_t registration_id2 = GetNewRegistrationId();
+  const int64_t version_id2 = GetNewVersionId();
+  status = CreateAndStoreRegistration(registration_id2, version_id2, kScope2,
+                                      kScriptUrl2, kScriptSize);
+  ASSERT_EQ(status, DatabaseStatus::kOk);
+
+  // Update policies to purge the registration for |kScope2| on shutdown.
+  std::vector<storage::mojom::LocalStoragePolicyUpdatePtr> updates;
+  updates.push_back(storage::mojom::LocalStoragePolicyUpdate::New(
+      url::Origin::Create(kScope2.GetOrigin()), /*purge_on_shutdown=*/true));
+  storage()->ApplyPolicyUpdates(std::move(updates));
+
+  // Restart the storage and check the registration for |kScope1| exists
+  // but not for |kScope2|.
+  RestartStorage();
+  {
+    FindRegistrationResult result = FindRegistrationForScope(kScope1);
+    ASSERT_EQ(result->status, DatabaseStatus::kOk);
+  }
+  {
+    FindRegistrationResult result = FindRegistrationForScope(kScope2);
+    ASSERT_EQ(result->status, DatabaseStatus::kErrorNotFound);
+  }
+}
+
 }  // namespace content