ServiceWorker: Returns true for IsMojoForServiceWorkerEnabled

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>
 
@@ skipping 243 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,
       const base::Callback<WebContents*(void)>& wc_getter) override {
     return false;
   }
 };
 
-TEST_P(ServiceWorkerDispatcherHostTestP,
+TEST_F(ServiceWorkerDispatcherHostTest,
        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_P(ServiceWorkerDispatcherHostTestP, Register_HTTPS) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP, Register_NonSecureTransportLocalhost) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP, Register_InvalidScopeShouldFail) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP, Register_InvalidScriptShouldFail) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP, Register_NonSecureOriginShouldFail) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP, Register_CrossOriginShouldFail) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP, Register_BadCharactersShouldFail) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP,
-       Register_FileSystemDocumentShouldFail) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP,
+TEST_F(ServiceWorkerDispatcherHostTest,
        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_P(ServiceWorkerDispatcherHostTestP, EarlyContextDeletion) {
+TEST_F(ServiceWorkerDispatcherHostTest, EarlyContextDeletion) {
   helper_->ShutdownContext();
 
   // Let the shutdown reach the simulated IO thread.
   base::RunLoop().RunUntilIdle();
 
   Register(-1,
            GURL(),
            GURL(),
            ServiceWorkerMsg_ServiceWorkerRegistrationError::ID);
 }
 
-TEST_P(ServiceWorkerDispatcherHostTestP, ProviderCreatedAndDestroyed) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP, GetRegistration_SameOrigin) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP,
-       GetRegistration_CrossOriginShouldFail) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP,
+TEST_F(ServiceWorkerDispatcherHostTest,
        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_P(ServiceWorkerDispatcherHostTestP,
+TEST_F(ServiceWorkerDispatcherHostTest,
        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_P(ServiceWorkerDispatcherHostTestP, GetRegistration_EarlyContextDeletion) {
+TEST_F(ServiceWorkerDispatcherHostTest, GetRegistration_EarlyContextDeletion) {
   helper_->ShutdownContext();
 
   // Let the shutdown reach the simulated IO thread.
   base::RunLoop().RunUntilIdle();
 
   GetRegistration(-1,
                   GURL(),
                   ServiceWorkerMsg_ServiceWorkerGetRegistrationError::ID);
 }
 
-TEST_P(ServiceWorkerDispatcherHostTestP, GetRegistrations_SecureOrigin) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP,
+TEST_F(ServiceWorkerDispatcherHostTest,
        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_P(ServiceWorkerDispatcherHostTestP,
-       GetRegistrations_EarlyContextDeletion) {
+TEST_F(ServiceWorkerDispatcherHostTest, GetRegistrations_EarlyContextDeletion) {
   helper_->ShutdownContext();
 
   // Let the shutdown reach the simulated IO thread.
   base::RunLoop().RunUntilIdle();
 
   GetRegistrations(-1, ServiceWorkerMsg_ServiceWorkerGetRegistrationsError::ID);
 }
 
-TEST_P(ServiceWorkerDispatcherHostTestP, CleanupOnRendererCrash) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP, DispatchExtendableMessageEvent) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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 45 matching lines @@
   // 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());
 
   // Timeout of message event should not have extended life of service worker.
   EXPECT_EQ(remaining_time, version_->remaining_timeout());
 }
 
-TEST_P(ServiceWorkerDispatcherHostTestP, DispatchExtendableMessageEvent_Fail) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_WORKER, pattern);
   SetUpRegistration(pattern, script_url);
 
   // Try to dispatch ExtendableMessageEvent. This should fail to start the
   // worker and to dispatch the event.
   std::vector<int> ports;
   SetUpDummyMessagePort(&ports);
   bool called = false;
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE;
   DispatchExtendableMessageEvent(
       version_, base::string16(), url::Origin(version_->scope().GetOrigin()),
       ports, provider_host_, base::Bind(&SaveStatusCallback, &called, &status));
   for (int port : ports)
     EXPECT_TRUE(MessagePortService::GetInstance()->AreMessagesHeld(port));
   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));
 }
 
-TEST_P(ServiceWorkerDispatcherHostTestP, OnSetHostedVersionId) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP, OnSetHostedVersionId_DetachedWorker) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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_P(ServiceWorkerDispatcherHostTestP, ReceivedTimedOutRequestResponse) {
+TEST_F(ServiceWorkerDispatcherHostTest, 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