Mojofy unittests related to service workers

content/browser/service_worker/service_worker_dispatcher_host_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_dispatcher_host.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/message_port_service.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_status.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_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_handle.h"
+#include "content/browser/service_worker/service_worker_test_utils.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/mock_resource_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/test/test_content_browser_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
@@ skipping 214 matching lines @@
 
   TestBrowserThreadBundle browser_thread_bundle_;
   content::MockResourceContext resource_context_;
   std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
   scoped_refptr<TestingServiceWorkerDispatcherHost> dispatcher_host_;
   scoped_refptr<ServiceWorkerRegistration> registration_;
   scoped_refptr<ServiceWorkerVersion> version_;
   ServiceWorkerProviderHost* provider_host_;
 };
 
+class ServiceWorkerDispatcherHostTestP
+    : public MojoServiceWorkerTestP<ServiceWorkerDispatcherHostTest> {};
+
 class ServiceWorkerTestContentBrowserClient : public TestContentBrowserClient {
  public:
   ServiceWorkerTestContentBrowserClient() {}
   bool AllowServiceWorker(const GURL& scope,
                           const GURL& first_party,
                           content::ResourceContext* context,
                           int render_process_id,
                           int render_frame_id) override {
     return false;
   }
 };
 
-TEST_F(ServiceWorkerDispatcherHostTest,
+TEST_P(ServiceWorkerDispatcherHostTestP,
        Register_ContentSettingsDisallowsServiceWorker) {
   ServiceWorkerTestContentBrowserClient test_browser_client;
   ContentBrowserClient* old_browser_client =
       SetBrowserClientForTesting(&test_browser_client);
 
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/foo"));
   context()->AddProviderHost(std::move(host));
@@ skipping 13 matching lines @@
   const int64_t kRegistrationId = 999;  // Dummy value
   scoped_refptr<ServiceWorkerRegistration> registration(
       new ServiceWorkerRegistration(GURL("https://www.example.com/"),
                                     kRegistrationId, context()->AsWeakPtr()));
   Unregister(kProviderId, kRegistrationId,
              ServiceWorkerMsg_ServiceWorkerUnregistrationError::ID);
 
   SetBrowserClientForTesting(old_browser_client);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, Register_HTTPS) {
+TEST_P(ServiceWorkerDispatcherHostTestP, Register_HTTPS) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/foo"));
   context()->AddProviderHost(std::move(host));
 
   Register(kProviderId,
            GURL("https://www.example.com/"),
            GURL("https://www.example.com/bar"),
            ServiceWorkerMsg_ServiceWorkerRegistered::ID);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, Register_NonSecureTransportLocalhost) {
+TEST_P(ServiceWorkerDispatcherHostTestP, Register_NonSecureTransportLocalhost) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("http://127.0.0.3:81/foo"));
   context()->AddProviderHost(std::move(host));
 
   Register(kProviderId,
            GURL("http://127.0.0.3:81/bar"),
            GURL("http://127.0.0.3:81/baz"),
            ServiceWorkerMsg_ServiceWorkerRegistered::ID);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, Register_InvalidScopeShouldFail) {
+TEST_P(ServiceWorkerDispatcherHostTestP, Register_InvalidScopeShouldFail) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/foo"));
   context()->AddProviderHost(std::move(host));
 
   SendRegister(kProviderId, GURL(""),
                GURL("https://www.example.com/bar/hoge.js"));
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, Register_InvalidScriptShouldFail) {
+TEST_P(ServiceWorkerDispatcherHostTestP, Register_InvalidScriptShouldFail) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/foo"));
   context()->AddProviderHost(std::move(host));
 
   SendRegister(kProviderId, GURL("https://www.example.com/bar/"), GURL(""));
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, Register_NonSecureOriginShouldFail) {
+TEST_P(ServiceWorkerDispatcherHostTestP, Register_NonSecureOriginShouldFail) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("http://www.example.com/foo"));
   context()->AddProviderHost(std::move(host));
 
   SendRegister(kProviderId,
                GURL("http://www.example.com/"),
                GURL("http://www.example.com/bar"));
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, Register_CrossOriginShouldFail) {
+TEST_P(ServiceWorkerDispatcherHostTestP, Register_CrossOriginShouldFail) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/foo"));
   context()->AddProviderHost(std::move(host));
 
   // Script has a different host
   SendRegister(kProviderId,
                GURL("https://www.example.com/"),
                GURL("https://foo.example.com/bar"));
@@ skipping 23 matching lines @@
                GURL("https://foo.example.com/bar"));
   EXPECT_EQ(5, dispatcher_host_->bad_messages_received_count_);
 
   // Script and scope URLs are invalid
   SendRegister(kProviderId,
                GURL(),
                GURL("h@ttps://@"));
   EXPECT_EQ(6, dispatcher_host_->bad_messages_received_count_);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, Register_BadCharactersShouldFail) {
+TEST_P(ServiceWorkerDispatcherHostTestP, Register_BadCharactersShouldFail) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/"));
   context()->AddProviderHost(std::move(host));
 
   SendRegister(kProviderId, GURL("https://www.example.com/%2f"),
                GURL("https://www.example.com/"));
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 
@@ skipping 11 matching lines @@
 
   SendRegister(kProviderId, GURL("https://www.example.com/"),
                GURL("https://www.example.com/%5c"));
   EXPECT_EQ(5, dispatcher_host_->bad_messages_received_count_);
 
   SendRegister(kProviderId, GURL("https://www.example.com/"),
                GURL("https://www.example.com/%5C"));
   EXPECT_EQ(6, dispatcher_host_->bad_messages_received_count_);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest,
+TEST_P(ServiceWorkerDispatcherHostTestP,
        Register_FileSystemDocumentShouldFail) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("filesystem:https://www.example.com/temporary/a"));
   context()->AddProviderHost(std::move(host));
 
   SendRegister(kProviderId,
                GURL("filesystem:https://www.example.com/temporary/"),
                GURL("https://www.example.com/temporary/bar"));
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 
   SendRegister(kProviderId,
                GURL("https://www.example.com/temporary/"),
                GURL("filesystem:https://www.example.com/temporary/bar"));
   EXPECT_EQ(2, dispatcher_host_->bad_messages_received_count_);
 
   SendRegister(kProviderId,
                GURL("filesystem:https://www.example.com/temporary/"),
                GURL("filesystem:https://www.example.com/temporary/bar"));
   EXPECT_EQ(3, dispatcher_host_->bad_messages_received_count_);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest,
+TEST_P(ServiceWorkerDispatcherHostTestP,
        Register_FileSystemScriptOrScopeShouldFail) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/temporary/"));
   context()->AddProviderHost(std::move(host));
 
   SendRegister(kProviderId,
                GURL("filesystem:https://www.example.com/temporary/"),
                GURL("https://www.example.com/temporary/bar"));
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 
   SendRegister(kProviderId,
                GURL("https://www.example.com/temporary/"),
                GURL("filesystem:https://www.example.com/temporary/bar"));
   EXPECT_EQ(2, dispatcher_host_->bad_messages_received_count_);
 
   SendRegister(kProviderId,
                GURL("filesystem:https://www.example.com/temporary/"),
                GURL("filesystem:https://www.example.com/temporary/bar"));
   EXPECT_EQ(3, dispatcher_host_->bad_messages_received_count_);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, EarlyContextDeletion) {
+TEST_P(ServiceWorkerDispatcherHostTestP, EarlyContextDeletion) {
   helper_->ShutdownContext();
 
   // Let the shutdown reach the simulated IO thread.
   base::RunLoop().RunUntilIdle();
 
   Register(-1,
            GURL(),
            GURL(),
            ServiceWorkerMsg_ServiceWorkerRegistrationError::ID);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, ProviderCreatedAndDestroyed) {
+TEST_P(ServiceWorkerDispatcherHostTestP, ProviderCreatedAndDestroyed) {
   const int kProviderId = 1001;
   int process_id = helper_->mock_render_process_id();
 
   dispatcher_host_->OnMessageReceived(ServiceWorkerHostMsg_ProviderCreated(
       kProviderId, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
       true /* is_parent_frame_secure */));
   EXPECT_TRUE(context()->GetProviderHost(process_id, kProviderId));
 
   // Two with the same ID should be seen as a bad message.
   dispatcher_host_->OnMessageReceived(ServiceWorkerHostMsg_ProviderCreated(
@@ skipping 14 matching lines @@
   // process to get deleted as well.
   dispatcher_host_->OnMessageReceived(ServiceWorkerHostMsg_ProviderCreated(
       kProviderId, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
       true /* is_parent_frame_secure */));
   EXPECT_TRUE(context()->GetProviderHost(process_id, kProviderId));
   EXPECT_TRUE(dispatcher_host_->HasOneRef());
   dispatcher_host_ = NULL;
   EXPECT_FALSE(context()->GetProviderHost(process_id, kProviderId));
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, GetRegistration_SameOrigin) {
+TEST_P(ServiceWorkerDispatcherHostTestP, GetRegistration_SameOrigin) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/foo"));
   context()->AddProviderHost(std::move(host));
 
   GetRegistration(kProviderId,
                   GURL("https://www.example.com/"),
                   ServiceWorkerMsg_DidGetRegistration::ID);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, GetRegistration_CrossOriginShouldFail) {
+TEST_P(ServiceWorkerDispatcherHostTestP,
+       GetRegistration_CrossOriginShouldFail) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/foo"));
   context()->AddProviderHost(std::move(host));
 
   SendGetRegistration(kProviderId, GURL("https://foo.example.com/"));
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest,
+TEST_P(ServiceWorkerDispatcherHostTestP,
        GetRegistration_InvalidScopeShouldFail) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/foo"));
   context()->AddProviderHost(std::move(host));
 
   SendGetRegistration(kProviderId, GURL(""));
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest,
+TEST_P(ServiceWorkerDispatcherHostTestP,
        GetRegistration_NonSecureOriginShouldFail) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("http://www.example.com/foo"));
   context()->AddProviderHost(std::move(host));
 
   SendGetRegistration(kProviderId, GURL("http://www.example.com/"));
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, GetRegistration_EarlyContextDeletion) {
+TEST_P(ServiceWorkerDispatcherHostTestP, GetRegistration_EarlyContextDeletion) {
   helper_->ShutdownContext();
 
   // Let the shutdown reach the simulated IO thread.
   base::RunLoop().RunUntilIdle();
 
   GetRegistration(-1,
                   GURL(),
                   ServiceWorkerMsg_ServiceWorkerGetRegistrationError::ID);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, GetRegistrations_SecureOrigin) {
+TEST_P(ServiceWorkerDispatcherHostTestP, GetRegistrations_SecureOrigin) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("https://www.example.com/foo"));
   context()->AddProviderHost(std::move(host));
 
   GetRegistrations(kProviderId, ServiceWorkerMsg_DidGetRegistrations::ID);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest,
+TEST_P(ServiceWorkerDispatcherHostTestP,
        GetRegistrations_NonSecureOriginShouldFail) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
   host->SetDocumentUrl(GURL("http://www.example.com/foo"));
   context()->AddProviderHost(std::move(host));
 
   SendGetRegistrations(kProviderId);
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, GetRegistrations_EarlyContextDeletion) {
+TEST_P(ServiceWorkerDispatcherHostTestP,
+       GetRegistrations_EarlyContextDeletion) {
   helper_->ShutdownContext();
 
   // Let the shutdown reach the simulated IO thread.
   base::RunLoop().RunUntilIdle();
 
   GetRegistrations(-1, ServiceWorkerMsg_ServiceWorkerGetRegistrationsError::ID);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, CleanupOnRendererCrash) {
+TEST_P(ServiceWorkerDispatcherHostTestP, CleanupOnRendererCrash) {
   GURL pattern = GURL("http://www.example.com/");
   GURL script_url = GURL("http://www.example.com/service_worker.js");
   int process_id = helper_->mock_render_process_id();
 
   SendProviderCreated(SERVICE_WORKER_PROVIDER_FOR_WINDOW, pattern);
   SetUpRegistration(pattern, script_url);
   int64_t provider_id = provider_host_->provider_id();
 
   // Start up the worker.
   bool called = false;
@@ skipping 24 matching lines @@
 
   // To show the new dispatcher can operate, simulate provider creation. Since
   // the old dispatcher cleaned up the old provider host, the new one won't
   // complain.
   new_dispatcher_host->OnMessageReceived(ServiceWorkerHostMsg_ProviderCreated(
       provider_id, MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
       true /* is_parent_frame_secure */));
   EXPECT_EQ(0, new_dispatcher_host->bad_messages_received_count_);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, DispatchExtendableMessageEvent) {
+TEST_P(ServiceWorkerDispatcherHostTestP, DispatchExtendableMessageEvent) {
   GURL pattern = GURL("http://www.example.com/");
   GURL script_url = GURL("http://www.example.com/service_worker.js");
 
   SendProviderCreated(SERVICE_WORKER_PROVIDER_FOR_CONTROLLER, pattern);
   SetUpRegistration(pattern, script_url);
 
   // Set the running hosted version so that we can retrieve a valid service
   // worker object information for the source attribute of the message event.
   provider_host_->running_hosted_version_ = version_;
 
@@ skipping 19 matching lines @@
   EXPECT_TRUE(called);
   EXPECT_EQ(SERVICE_WORKER_OK, status);
 
   // Messages should be held until ports are created at the destination.
   for (int port : ports)
     EXPECT_TRUE(MessagePortService::GetInstance()->AreMessagesHeld(port));
 
   EXPECT_EQ(ref_count + 1, sender_worker_handle->ref_count());
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, DispatchExtendableMessageEvent_Fail) {
+TEST_P(ServiceWorkerDispatcherHostTestP, DispatchExtendableMessageEvent_Fail) {
   GURL pattern = GURL("http://www.example.com/");
   GURL script_url = GURL("http://www.example.com/service_worker.js");
 
   Initialize(base::WrapUnique(new FailToStartWorkerTestHelper));
   SendProviderCreated(SERVICE_WORKER_PROVIDER_FOR_CONTROLLER, pattern);
   SetUpRegistration(pattern, script_url);
 
   // Set the running hosted version so that we can retrieve a valid service
   // worker object information for the source attribute of the message event.
   provider_host_->running_hosted_version_ = version_;
@@ skipping 20 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   EXPECT_EQ(SERVICE_WORKER_ERROR_START_WORKER_FAILED, status);
 
   // The error callback should clean up the ports and handle.
   for (int port : ports)
     EXPECT_FALSE(MessagePortService::GetInstance()->AreMessagesHeld(port));
   EXPECT_EQ(ref_count, sender_worker_handle->ref_count());
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, OnSetHostedVersionId) {
+TEST_P(ServiceWorkerDispatcherHostTestP, OnSetHostedVersionId) {
   GURL pattern = GURL("http://www.example.com/");
   GURL script_url = GURL("http://www.example.com/service_worker.js");
 
   Initialize(base::WrapUnique(new FailToStartWorkerTestHelper));
   SendProviderCreated(SERVICE_WORKER_PROVIDER_FOR_CONTROLLER, pattern);
   SetUpRegistration(pattern, script_url);
 
   const int64_t kProviderId = 99;  // Dummy value
   bool called;
   ServiceWorkerStatusCode status;
   // StartWorker puts the worker in STARTING state but it will have no
   // process id yet.
   version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN,
                         base::Bind(&SaveStatusCallback, &called, &status));
   EXPECT_NE(version_->embedded_worker()->process_id(),
             provider_host_->process_id());
   // SendSetHostedVersionId should reject because the provider host process id
   // is different. It should call BadMessageReceived because it's not an
   // expected error state.
   SendSetHostedVersionId(kProviderId, version_->version_id(),
                          version_->embedded_worker()->embedded_worker_id());
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(dispatcher_host_->ipc_sink()->GetUniqueMessageMatching(
       ServiceWorkerMsg_AssociateRegistration::ID));
   EXPECT_EQ(1, dispatcher_host_->bad_messages_received_count_);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, OnSetHostedVersionId_DetachedWorker) {
+TEST_P(ServiceWorkerDispatcherHostTestP, OnSetHostedVersionId_DetachedWorker) {
   GURL pattern = GURL("http://www.example.com/");
   GURL script_url = GURL("http://www.example.com/service_worker.js");
 
   Initialize(base::WrapUnique(new FailToStartWorkerTestHelper));
   SendProviderCreated(SERVICE_WORKER_PROVIDER_FOR_CONTROLLER, pattern);
   SetUpRegistration(pattern, script_url);
 
   const int64_t kProviderId = 99;  // Dummy value
   bool called;
   ServiceWorkerStatusCode status;
   // StartWorker puts the worker in STARTING state.
   version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN,
                         base::Bind(&SaveStatusCallback, &called, &status));
 
   // SendSetHostedVersionId should bail because the embedded worker is
   // different. It shouldn't call BadMessageReceived because receiving a message
   // for a detached worker is a legitimite possibility.
   int bad_embedded_worker_id =
       version_->embedded_worker()->embedded_worker_id() + 1;
   SendSetHostedVersionId(kProviderId, version_->version_id(),
                          bad_embedded_worker_id);
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(dispatcher_host_->ipc_sink()->GetUniqueMessageMatching(
       ServiceWorkerMsg_AssociateRegistration::ID));
   EXPECT_EQ(0, dispatcher_host_->bad_messages_received_count_);
 }
 
-TEST_F(ServiceWorkerDispatcherHostTest, ReceivedTimedOutRequestResponse) {
+TEST_P(ServiceWorkerDispatcherHostTestP, ReceivedTimedOutRequestResponse) {
   GURL pattern = GURL("https://www.example.com/");
   GURL script_url = GURL("https://www.example.com/service_worker.js");
 
   SendProviderCreated(SERVICE_WORKER_PROVIDER_FOR_WINDOW, pattern);
   SetUpRegistration(pattern, script_url);
 
   version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN,
                         base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   base::RunLoop().RunUntilIdle();
 
   // Set the worker status to STOPPING.
   version_->embedded_worker()->Stop();
   EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, version_->running_status());
 
   // Receive a response for a timed out request. The bad message count should
   // not increase.
   const int kFetchEventId = 91;  // Dummy value
   dispatcher_host_->OnMessageReceived(ServiceWorkerHostMsg_FetchEventResponse(
       version_->embedded_worker()->embedded_worker_id(), kFetchEventId,
       SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK, ServiceWorkerResponse(),
       base::Time::Now()));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, dispatcher_host_->bad_messages_received_count_);
 }
 
+INSTANTIATE_TEST_CASE_P(ServiceWorkerDispatcherHostTest,
+                        ServiceWorkerDispatcherHostTestP,
+                        testing::Bool());
+
 }  // namespace content