Mojofy unittests related to service workers

content/browser/service_worker/service_worker_storage_unittest.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 <stdint.h>
 #include <string>
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_disk_cache.h"
 #include "content/browser/service_worker/service_worker_registration.h"
+#include "content/browser/service_worker/service_worker_test_utils.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/service_worker_status_code.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/origin_trial_policy.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "ipc/ipc_message.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 489 matching lines @@
     return result;
   }
 
   // user_data_directory_ must be declared first to preserve destructor order.
   base::ScopedTempDir user_data_directory_;
   base::FilePath user_data_directory_path_;
   std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
   TestBrowserThreadBundle browser_thread_bundle_;
 };
 
-TEST_F(ServiceWorkerStorageTest, DisabledStorage) {
+class ServiceWorkerStorageTestP
+    : public MojoServiceWorkerTestP<ServiceWorkerStorageTest> {};
+
+TEST_P(ServiceWorkerStorageTestP, DisabledStorage) {
   const GURL kScope("http://www.example.com/scope/");
   const GURL kScript("http://www.example.com/script.js");
   const GURL kDocumentUrl("http://www.example.com/scope/document.html");
   const int64_t kRegistrationId = 0;
   const int64_t kVersionId = 0;
   const int64_t kResourceId = 0;
 
   LazyInitialize();
   storage()->Disable();
 
@@ skipping 57 matching lines @@
   EXPECT_FALSE(
       storage()->OriginHasForeignFetchRegistrations(kScope.GetOrigin()));
 
   // Next available ids should be invalid.
   EXPECT_EQ(kInvalidServiceWorkerRegistrationId,
             storage()->NewRegistrationId());
   EXPECT_EQ(kInvalidServiceWorkerVersionId, storage()->NewVersionId());
   EXPECT_EQ(kInvalidServiceWorkerResourceId, storage()->NewRegistrationId());
 }
 
-TEST_F(ServiceWorkerStorageTest, StoreFindUpdateDeleteRegistration) {
+TEST_P(ServiceWorkerStorageTestP, StoreFindUpdateDeleteRegistration) {
   const GURL kScope("http://www.test.not/scope/");
   const GURL kDocumentUrl("http://www.test.not/scope/document.html");
   const GURL kResource1("http://www.test.not/scope/resource1.js");
   const int64_t kResource1Size = 1591234;
   const GURL kResource2("http://www.test.not/scope/resource2.js");
   const int64_t kResource2Size = 51;
   const int64_t kRegistrationId = 0;
   const int64_t kVersionId = 0;
   const GURL kForeignFetchScope("http://www.test.not/scope/ff/");
   const url::Origin kForeignFetchOrigin(GURL("https://example.com/"));
@@ skipping 181 matching lines @@
   EXPECT_FALSE(found_registration.get());
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForIdOnly(kRegistrationId, &found_registration));
   EXPECT_FALSE(found_registration.get());
 
   // Deleting an unstored registration should succeed.
   EXPECT_EQ(SERVICE_WORKER_OK,
             DeleteRegistration(kRegistrationId + 1, kScope.GetOrigin()));
 }
 
-TEST_F(ServiceWorkerStorageTest, InstallingRegistrationsAreFindable) {
+TEST_P(ServiceWorkerStorageTestP, InstallingRegistrationsAreFindable) {
   const GURL kScope("http://www.test.not/scope/");
   const GURL kScript("http://www.test.not/script.js");
   const GURL kDocumentUrl("http://www.test.not/scope/document.html");
   const int64_t kRegistrationId = 0;
   const int64_t kVersionId = 0;
 
   scoped_refptr<ServiceWorkerRegistration> found_registration;
 
   // Create an unstored registration.
   scoped_refptr<ServiceWorkerRegistration> live_registration =
@@ skipping 108 matching lines @@
       SERVICE_WORKER_OK,
       GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_for_origin));
   EXPECT_TRUE(registrations_for_origin.empty());
 
   EXPECT_EQ(SERVICE_WORKER_OK,
             GetRegistrationsForOrigin(GURL("http://example.com/").GetOrigin(),
                                       &registrations_for_origin));
   EXPECT_TRUE(registrations_for_origin.empty());
 }
 
-TEST_F(ServiceWorkerStorageTest, StoreUserData) {
+TEST_P(ServiceWorkerStorageTestP, StoreUserData) {
   const GURL kScope("http://www.test.not/scope/");
   const GURL kScript("http://www.test.not/script.js");
   const int64_t kRegistrationId = 0;
   const int64_t kVersionId = 0;
 
   LazyInitialize();
 
   // Store a registration.
   scoped_refptr<ServiceWorkerRegistration> live_registration =
       new ServiceWorkerRegistration(kScope, kRegistrationId,
@@ skipping 118 matching lines @@
             ClearUserData(kRegistrationId, std::vector<std::string>()));
   EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
             ClearUserData(kRegistrationId, {std::string()}));
   EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
             ClearUserData(kRegistrationId, {std::string(), "key"}));
   data_list_out.clear();
   EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED,
             GetUserDataForAllRegistrations(std::string(), &data_list_out));
 }
 
-class ServiceWorkerResourceStorageTest : public ServiceWorkerStorageTest {
+class ServiceWorkerResourceStorageTest : public ServiceWorkerStorageTestP {
  public:
   void SetUp() override {
-    ServiceWorkerStorageTest::SetUp();
+    ServiceWorkerStorageTestP::SetUp();
     LazyInitialize();
 
     scope_ = GURL("http://www.test.not/scope/");
     script_ = GURL("http://www.test.not/script.js");
     import_ = GURL("http://www.test.not/import.js");
     document_url_ = GURL("http://www.test.not/scope/document.html");
     registration_id_ = storage()->NewRegistrationId();
     version_id_ = storage()->NewVersionId();
     resource_id1_ = storage()->NewResourceId();
     resource_id2_ = storage()->NewResourceId();
@@ skipping 58 matching lines @@
 class ServiceWorkerResourceStorageDiskTest
     : public ServiceWorkerResourceStorageTest {
  public:
   void SetUp() override {
     ASSERT_TRUE(InitUserDataDirectory());
     ServiceWorkerResourceStorageTest::SetUp();
   }
 
 };
 
-TEST_F(ServiceWorkerResourceStorageTest,
+TEST_P(ServiceWorkerResourceStorageTest,
        WriteMetadataWithServiceWorkerResponseMetadataWriter) {
   const char kMetadata1[] = "Test metadata";
   const char kMetadata2[] = "small";
   int64_t new_resource_id_ = storage()->NewResourceId();
   // Writing metadata to nonexistent resoirce ID must fail.
   EXPECT_GE(0, WriteResponseMetadata(storage(), new_resource_id_, kMetadata1));
 
   // Check metadata is written.
   EXPECT_EQ(static_cast<int>(strlen(kMetadata1)),
             WriteResponseMetadata(storage(), resource_id1_, kMetadata1));
   EXPECT_TRUE(VerifyResponseMetadata(storage(), resource_id1_, kMetadata1));
   EXPECT_TRUE(VerifyBasicResponse(storage(), resource_id1_, true));
 
   // Check metadata is written and truncated.
   EXPECT_EQ(static_cast<int>(strlen(kMetadata2)),
             WriteResponseMetadata(storage(), resource_id1_, kMetadata2));
   EXPECT_TRUE(VerifyResponseMetadata(storage(), resource_id1_, kMetadata2));
   EXPECT_TRUE(VerifyBasicResponse(storage(), resource_id1_, true));
 
   // Check metadata is deleted.
   EXPECT_EQ(0, WriteResponseMetadata(storage(), resource_id1_, ""));
   EXPECT_FALSE(VerifyResponseMetadata(storage(), resource_id1_, ""));
   EXPECT_TRUE(VerifyBasicResponse(storage(), resource_id1_, true));
 }
 
-TEST_F(ServiceWorkerResourceStorageTest,
+TEST_P(ServiceWorkerResourceStorageTest,
        WriteMetadataWithServiceWorkerScriptCacheMap) {
   const char kMetadata1[] = "Test metadata";
   const char kMetadata2[] = "small";
   ServiceWorkerVersion* version = registration_->waiting_version();
   EXPECT_TRUE(version);
 
   // Writing metadata to nonexistent URL must fail.
   EXPECT_GE(0,
             WriteMetadata(version, GURL("http://www.test.not/nonexistent.js"),
                           kMetadata1));
@@ skipping 12 matching lines @@
             WriteMetadata(version, script_, kMetadata2));
   EXPECT_TRUE(VerifyResponseMetadata(storage(), resource_id1_, kMetadata2));
   EXPECT_TRUE(VerifyBasicResponse(storage(), resource_id1_, true));
 
   // Check metadata is deleted.
   EXPECT_EQ(0, ClearMetadata(version, script_));
   EXPECT_FALSE(VerifyResponseMetadata(storage(), resource_id1_, ""));
   EXPECT_TRUE(VerifyBasicResponse(storage(), resource_id1_, true));
 }
 
-TEST_F(ServiceWorkerResourceStorageTest, DeleteRegistration_NoLiveVersion) {
+TEST_P(ServiceWorkerResourceStorageTest, DeleteRegistration_NoLiveVersion) {
   bool was_called = false;
   ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
   std::set<int64_t> verify_ids;
 
   registration_->SetWaitingVersion(NULL);
   registration_ = NULL;
 
   // Deleting the registration should result in the resources being added to the
   // purgeable list and then doomed in the disk cache and removed from that
   // list.
@@ skipping 11 matching lines @@
   EXPECT_EQ(2u, verify_ids.size());
   verify_ids.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             storage()->database_->GetPurgeableResourceIds(&verify_ids));
   EXPECT_TRUE(verify_ids.empty());
 
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id1_, false));
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id2_, false));
 }
 
-TEST_F(ServiceWorkerResourceStorageTest, DeleteRegistration_WaitingVersion) {
+TEST_P(ServiceWorkerResourceStorageTest, DeleteRegistration_WaitingVersion) {
   bool was_called = false;
   ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
   std::set<int64_t> verify_ids;
 
   // Deleting the registration should result in the resources being added to the
   // purgeable list and then doomed in the disk cache and removed from that
   // list.
   storage()->DeleteRegistration(
       registration_->id(),
       scope_.GetOrigin(),
@@ skipping 21 matching lines @@
   EXPECT_EQ(2u, verify_ids.size());
   verify_ids.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             storage()->database_->GetPurgeableResourceIds(&verify_ids));
   EXPECT_TRUE(verify_ids.empty());
 
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id1_, false));
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id2_, false));
 }
 
-TEST_F(ServiceWorkerResourceStorageTest, DeleteRegistration_ActiveVersion) {
+TEST_P(ServiceWorkerResourceStorageTest, DeleteRegistration_ActiveVersion) {
   // Promote the worker to active and add a controllee.
   registration_->SetActiveVersion(registration_->waiting_version());
   storage()->UpdateToActiveState(
       registration_.get(), base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   std::unique_ptr<ServiceWorkerProviderHost> host(new ServiceWorkerProviderHost(
       33 /* dummy render process id */, MSG_ROUTING_NONE,
       1 /* dummy provider_id */, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
       ServiceWorkerProviderHost::FrameSecurityLevel::SECURE,
       context()->AsWeakPtr(), NULL));
   registration_->active_version()->AddControllee(host.get());
@@ skipping 30 matching lines @@
   base::RunLoop().RunUntilIdle();
   verify_ids.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             storage()->database_->GetPurgeableResourceIds(&verify_ids));
   EXPECT_TRUE(verify_ids.empty());
 
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id1_, false));
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id2_, false));
 }
 
-TEST_F(ServiceWorkerResourceStorageDiskTest, CleanupOnRestart) {
+TEST_P(ServiceWorkerResourceStorageDiskTest, CleanupOnRestart) {
   // Promote the worker to active and add a controllee.
   registration_->SetActiveVersion(registration_->waiting_version());
   registration_->SetWaitingVersion(NULL);
   storage()->UpdateToActiveState(
       registration_.get(), base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   std::unique_ptr<ServiceWorkerProviderHost> host(new ServiceWorkerProviderHost(
       33 /* dummy render process id */, MSG_ROUTING_NONE,
       1 /* dummy provider_id */, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
       ServiceWorkerProviderHost::FrameSecurityLevel::SECURE,
       context()->AsWeakPtr(), NULL));
@@ skipping 64 matching lines @@
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             storage()->database_->GetPurgeableResourceIds(&verify_ids));
   EXPECT_TRUE(verify_ids.empty());
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id1_, false));
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id2_, false));
   EXPECT_FALSE(
       VerifyBasicResponse(storage(), kStaleUncommittedResourceId, false));
   EXPECT_TRUE(VerifyBasicResponse(storage(), kNewResourceId, true));
 }
 
-TEST_F(ServiceWorkerResourceStorageDiskTest, DeleteAndStartOver) {
+TEST_P(ServiceWorkerResourceStorageDiskTest, DeleteAndStartOver) {
   EXPECT_FALSE(storage()->IsDisabled());
   ASSERT_TRUE(base::DirectoryExists(storage()->GetDiskCachePath()));
   ASSERT_TRUE(base::DirectoryExists(storage()->GetDatabasePath()));
 
   base::RunLoop run_loop;
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE;
   storage()->DeleteAndStartOver(
       base::Bind(&StatusAndQuitCallback, &status, run_loop.QuitClosure()));
   run_loop.Run();
 
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_TRUE(storage()->IsDisabled());
   EXPECT_FALSE(base::DirectoryExists(storage()->GetDiskCachePath()));
   EXPECT_FALSE(base::DirectoryExists(storage()->GetDatabasePath()));
 }
 
-TEST_F(ServiceWorkerResourceStorageDiskTest,
+TEST_P(ServiceWorkerResourceStorageDiskTest,
        DeleteAndStartOver_UnrelatedFileExists) {
   EXPECT_FALSE(storage()->IsDisabled());
   ASSERT_TRUE(base::DirectoryExists(storage()->GetDiskCachePath()));
   ASSERT_TRUE(base::DirectoryExists(storage()->GetDatabasePath()));
 
   // Create an unrelated file in the database directory to make sure such a file
   // does not prevent DeleteAndStartOver.
   base::FilePath file_path;
   ASSERT_TRUE(
       base::CreateTemporaryFileInDir(storage()->GetDatabasePath(), &file_path));
   ASSERT_TRUE(base::PathExists(file_path));
 
   base::RunLoop run_loop;
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE;
   storage()->DeleteAndStartOver(
       base::Bind(&StatusAndQuitCallback, &status, run_loop.QuitClosure()));
   run_loop.Run();
 
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_TRUE(storage()->IsDisabled());
   EXPECT_FALSE(base::DirectoryExists(storage()->GetDiskCachePath()));
   EXPECT_FALSE(base::DirectoryExists(storage()->GetDatabasePath()));
 }
 
-TEST_F(ServiceWorkerResourceStorageDiskTest,
+TEST_P(ServiceWorkerResourceStorageDiskTest,
        DeleteAndStartOver_OpenedFileExists) {
   EXPECT_FALSE(storage()->IsDisabled());
   ASSERT_TRUE(base::DirectoryExists(storage()->GetDiskCachePath()));
   ASSERT_TRUE(base::DirectoryExists(storage()->GetDatabasePath()));
 
   // Create an unrelated opened file in the database directory to make sure such
   // a file does not prevent DeleteAndStartOver on non-Windows platforms.
   base::FilePath file_path;
   base::ScopedFILE file(base::CreateAndOpenTemporaryFileInDir(
       storage()->GetDatabasePath(), &file_path));
@@ skipping 13 matching lines @@
   EXPECT_TRUE(base::DirectoryExists(storage()->GetDiskCachePath()));
   EXPECT_TRUE(base::DirectoryExists(storage()->GetDatabasePath()));
 #else
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_TRUE(storage()->IsDisabled());
   EXPECT_FALSE(base::DirectoryExists(storage()->GetDiskCachePath()));
   EXPECT_FALSE(base::DirectoryExists(storage()->GetDatabasePath()));
 #endif
 }
 
-TEST_F(ServiceWorkerResourceStorageTest, UpdateRegistration) {
+TEST_P(ServiceWorkerResourceStorageTest, UpdateRegistration) {
   // Promote the worker to active worker and add a controllee.
   registration_->SetActiveVersion(registration_->waiting_version());
   storage()->UpdateToActiveState(
       registration_.get(), base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   std::unique_ptr<ServiceWorkerProviderHost> host(new ServiceWorkerProviderHost(
       33 /* dummy render process id */, MSG_ROUTING_NONE,
       1 /* dummy provider_id */, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
       ServiceWorkerProviderHost::FrameSecurityLevel::SECURE,
       context()->AsWeakPtr(), NULL));
   registration_->active_version()->AddControllee(host.get());
@@ skipping 44 matching lines @@
   base::RunLoop().RunUntilIdle();
   verify_ids.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             storage()->database_->GetPurgeableResourceIds(&verify_ids));
   EXPECT_TRUE(verify_ids.empty());
 
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id1_, false));
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id2_, false));
 }
 
-TEST_F(ServiceWorkerStorageTest, FindRegistration_LongestScopeMatch) {
+TEST_P(ServiceWorkerStorageTestP, FindRegistration_LongestScopeMatch) {
   const GURL kDocumentUrl("http://www.example.com/scope/foo");
   scoped_refptr<ServiceWorkerRegistration> found_registration;
 
   // Registration for "/scope/".
   const GURL kScope1("http://www.example.com/scope/");
   const GURL kScript1("http://www.example.com/script1.js");
   const int64_t kRegistrationId1 = 1;
   const int64_t kVersionId1 = 1;
   scoped_refptr<ServiceWorkerRegistration> live_registration1 =
       new ServiceWorkerRegistration(kScope1, kRegistrationId1,
@@ skipping 73 matching lines @@
       live_registration2.get(), NULL, SERVICE_WORKER_OK);
   storage()->NotifyDoneInstallingRegistration(
       live_registration3.get(), NULL, SERVICE_WORKER_OK);
 
   // Find a registration among installed ones.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   EXPECT_EQ(live_registration2, found_registration);
 }
 
-class ServiceWorkerStorageDiskTest : public ServiceWorkerStorageTest {
+class ServiceWorkerStorageDiskTest : public ServiceWorkerStorageTestP {
  public:
   void SetUp() override {
     ASSERT_TRUE(InitUserDataDirectory());
-    ServiceWorkerStorageTest::SetUp();
+    ServiceWorkerStorageTestP::SetUp();
   }
 };
 
-TEST_F(ServiceWorkerStorageDiskTest, OriginHasForeignFetchRegistrations) {
+TEST_P(ServiceWorkerStorageDiskTest, OriginHasForeignFetchRegistrations) {
   LazyInitialize();
 
   // Registration 1 for http://www.example.com
   const GURL kScope1("http://www.example.com/scope/");
   const GURL kScript1("http://www.example.com/script1.js");
   const int64_t kRegistrationId1 = 1;
   const int64_t kVersionId1 = 1;
   scoped_refptr<ServiceWorkerRegistration> live_registration1 =
       new ServiceWorkerRegistration(kScope1, kRegistrationId1,
                                     context()->AsWeakPtr());
@@ skipping 90 matching lines @@
 
   // Remove other registration at first origin.
   EXPECT_EQ(SERVICE_WORKER_OK,
             DeleteRegistration(kRegistrationId2, kScope2.GetOrigin()));
 
   // No foreign fetch registrations remain.
   EXPECT_FALSE(storage()->OriginHasForeignFetchRegistrations(kOrigin1));
   EXPECT_FALSE(storage()->OriginHasForeignFetchRegistrations(kOrigin2));
 }
 
-class ServiceWorkerStorageOriginTrialsTest : public ServiceWorkerStorageTest {
+class ServiceWorkerStorageOriginTrialsTest : public ServiceWorkerStorageTestP {
  public:
   ServiceWorkerStorageOriginTrialsTest() {}
   ~ServiceWorkerStorageOriginTrialsTest() override {}
 
  protected:
   void WriteRegistration(const RegistrationData& registration,
                          const std::vector<ResourceRecord>& resources) {
     ServiceWorkerDatabase::RegistrationData deleted_version;
     std::vector<int64_t> newly_purgeable_resources;
 
     ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
               storage()->database_->WriteRegistration(
                   registration, resources, &deleted_version,
                   &newly_purgeable_resources));
   }
 };
 
-TEST_F(ServiceWorkerStorageOriginTrialsTest, AbsentEntryAndEmptyEntry) {
+TEST_P(ServiceWorkerStorageOriginTrialsTest, AbsentEntryAndEmptyEntry) {
   const GURL origin1("http://www1.example.com");
   const GURL scope1("http://www1.example.com/foo/");
   RegistrationData data1;
   data1.registration_id = 100;
   data1.scope = scope1;
   data1.script = GURL(origin1.spec() + "/script.js");
   data1.version_id = 1000;
   data1.is_active = true;
   data1.resources_total_size_bytes = 100;
   // Don't set origin_trial_tokens to simulate old database entry.
@@ skipping 29 matching lines @@
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForDocument(scope2, &found_registration));
   ASSERT_TRUE(found_registration->active_version());
   // Empty origin_trial_tokens must exist.
   ASSERT_TRUE(found_registration->active_version()->origin_trial_tokens());
   EXPECT_TRUE(
       found_registration->active_version()->origin_trial_tokens()->empty());
 }
 
 class ServiceWorkerStorageOriginTrialsDiskTest
-    : public ServiceWorkerStorageTest {
+    : public ServiceWorkerStorageTestP {
  public:
   ServiceWorkerStorageOriginTrialsDiskTest() {
     SetContentClient(&test_content_client_);
   }
   ~ServiceWorkerStorageOriginTrialsDiskTest() override {
     SetContentClient(nullptr);
   }
   void SetUp() override {
     ASSERT_TRUE(InitUserDataDirectory());
-    ServiceWorkerStorageTest::SetUp();
+    ServiceWorkerStorageTestP::SetUp();
   }
 
  private:
   class TestOriginTrialPolicy : public OriginTrialPolicy {
    public:
     base::StringPiece GetPublicKey() const override {
       return base::StringPiece(reinterpret_cast<const char*>(kTestPublicKey),
                                arraysize(kTestPublicKey));
     }
     bool IsFeatureDisabled(base::StringPiece feature) const override {
       return false;
     }
   };
   class TestContentClient : public ContentClient {
    public:
     // ContentRendererClient methods
     OriginTrialPolicy* GetOriginTrialPolicy() override {
       return &origin_trial_policy_;
     }
 
    private:
     TestOriginTrialPolicy origin_trial_policy_;
   };
   TestContentClient test_content_client_;
 };
 
-TEST_F(ServiceWorkerStorageOriginTrialsDiskTest, FromMainScript) {
+TEST_P(ServiceWorkerStorageOriginTrialsDiskTest, FromMainScript) {
   LazyInitialize();
   const GURL kScope("https://valid.example.com/scope");
   const GURL kScript("https://valid.example.com/script.js");
   const int64_t kRegistrationId = 1;
   const int64_t kVersionId = 1;
   scoped_refptr<ServiceWorkerRegistration> registration =
       new ServiceWorkerRegistration(kScope, kRegistrationId,
                                     context()->AsWeakPtr());
   scoped_refptr<ServiceWorkerVersion> version = new ServiceWorkerVersion(
       registration.get(), kScript, kVersionId, context()->AsWeakPtr());
@@ skipping 74 matching lines @@
   const TrialTokenValidator::FeatureToTokensMap& found_tokens =
       *found_registration->active_version()->origin_trial_tokens();
   ASSERT_EQ(2UL, found_tokens.size());
   ASSERT_EQ(1UL, found_tokens.at("Feature1").size());
   EXPECT_EQ(kFeature1Token, found_tokens.at("Feature1")[0]);
   ASSERT_EQ(2UL, found_tokens.at("Feature2").size());
   EXPECT_EQ(kFeature2Token1, found_tokens.at("Feature2")[0]);
   EXPECT_EQ(kFeature2Token2, found_tokens.at("Feature2")[1]);
 }
 
+INSTANTIATE_TEST_CASE_P(ServiceWorkerResourceStorageDiskTest,
+                        ServiceWorkerResourceStorageDiskTest,
+                        testing::Bool());
+INSTANTIATE_TEST_CASE_P(ServiceWorkerResourceStorageTest,
+                        ServiceWorkerResourceStorageTest,
+                        testing::Bool());
+INSTANTIATE_TEST_CASE_P(ServiceWorkerStorageDiskTest,
+                        ServiceWorkerStorageDiskTest,
+                        testing::Bool());
+INSTANTIATE_TEST_CASE_P(ServiceWorkerStorageOriginTrialsDiskTest,
+                        ServiceWorkerStorageOriginTrialsDiskTest,
+                        testing::Bool());
+INSTANTIATE_TEST_CASE_P(ServiceWorkerStorageOriginTrialsTest,
+                        ServiceWorkerStorageOriginTrialsTest,
+                        testing::Bool());
+INSTANTIATE_TEST_CASE_P(ServiceWorkerStorageTestP,
+                        ServiceWorkerStorageTestP,
+                        testing::Bool());
+
 }  // namespace content