ServiceWorker: Returns true for IsMojoForServiceWorkerEnabled

content/browser/service_worker/service_worker_context_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/public/browser/service_worker_context.h"
 
 #include <stdint.h>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
@@ skipping 144 matching lines @@
   }
 
   ServiceWorkerContextCore* context() { return helper_->context(); }
 
  protected:
   TestBrowserThreadBundle browser_thread_bundle_;
   std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
   std::vector<NotificationLog> notifications_;
 };
 
-class ServiceWorkerContextTestP
-    : public MojoServiceWorkerTestP<ServiceWorkerContextTest> {};
-
 class RecordableEmbeddedWorkerInstanceClient
     : public EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient {
  public:
   enum class Message { StartWorker, StopWorker };
 
   explicit RecordableEmbeddedWorkerInstanceClient(
       base::WeakPtr<EmbeddedWorkerTestHelper> helper)
       : EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient(helper) {}
 
   const std::vector<Message>& events() const { return events_; }
@@ skipping 13 matching lines @@
         std::move(callback));
   }
 
   std::vector<Message> events_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RecordableEmbeddedWorkerInstanceClient);
 };
 
 // Make sure basic registration is working.
-TEST_P(ServiceWorkerContextTestP, Register) {
+TEST_F(ServiceWorkerContextTest, Register) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
   RecordableEmbeddedWorkerInstanceClient* client = nullptr;
-  if (is_mojo_enabled()) {
-    client = helper_->CreateAndRegisterMockInstanceClient<
-        RecordableEmbeddedWorkerInstanceClient>(helper_->AsWeakPtr());
-  }
+  client = helper_->CreateAndRegisterMockInstanceClient<
+      RecordableEmbeddedWorkerInstanceClient>(helper_->AsWeakPtr());
 
   int64_t registration_id = kInvalidServiceWorkerRegistrationId;
   bool called = false;
   context()->RegisterServiceWorker(
       pattern,
       script_url,
       NULL,
       MakeRegisteredCallback(&called, &registration_id));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
 
-  if (is_mojo_enabled()) {
-    EXPECT_EQ(2UL, helper_->ipc_sink()->message_count());
-    ASSERT_EQ(2UL, client->events().size());
-    EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StartWorker,
-              client->events()[0]);
-    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-        ServiceWorkerMsg_InstallEvent::ID));
-    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-        ServiceWorkerMsg_ActivateEvent::ID));
-    EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StopWorker,
-              client->events()[1]);
-  } else {
-    EXPECT_EQ(4UL, helper_->ipc_sink()->message_count());
-    EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
-        EmbeddedWorkerMsg_StartWorker::ID));
-    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-        ServiceWorkerMsg_InstallEvent::ID));
-    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-        ServiceWorkerMsg_ActivateEvent::ID));
-    EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
-        EmbeddedWorkerMsg_StopWorker::ID));
-  }
+  EXPECT_EQ(2UL, helper_->ipc_sink()->message_count());
+  ASSERT_EQ(2UL, client->events().size());
+  EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StartWorker,
+            client->events()[0]);
+  EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+      ServiceWorkerMsg_InstallEvent::ID));
+  EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+      ServiceWorkerMsg_ActivateEvent::ID));
+  EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StopWorker,
+            client->events()[1]);
+
   EXPECT_NE(kInvalidServiceWorkerRegistrationId, registration_id);
 
   ASSERT_EQ(1u, notifications_.size());
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(registration_id, notifications_[0].registration_id);
 
   context()->storage()->FindRegistrationForId(
       registration_id,
       pattern.GetOrigin(),
       base::Bind(&ExpectRegisteredWorkers,
                  SERVICE_WORKER_OK,
                  false /* expect_waiting */,
                  true /* expect_active */));
   base::RunLoop().RunUntilIdle();
 }
 
 // Test registration when the service worker rejects the install event. The
 // registration callback should indicate success, but there should be no waiting
 // or active worker in the registration.
-TEST_P(ServiceWorkerContextTestP, Register_RejectInstall) {
+TEST_F(ServiceWorkerContextTest, Register_RejectInstall) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
   helper_.reset();  // Make sure the process lookups stay overridden.
   helper_.reset(new RejectInstallTestHelper);
   helper_->context_wrapper()->AddObserver(this);
 
   RecordableEmbeddedWorkerInstanceClient* client = nullptr;
-  if (is_mojo_enabled()) {
-    client = helper_->CreateAndRegisterMockInstanceClient<
-        RecordableEmbeddedWorkerInstanceClient>(helper_->AsWeakPtr());
-  }
+  client = helper_->CreateAndRegisterMockInstanceClient<
+      RecordableEmbeddedWorkerInstanceClient>(helper_->AsWeakPtr());
 
   int64_t registration_id = kInvalidServiceWorkerRegistrationId;
   bool called = false;
   context()->RegisterServiceWorker(
       pattern,
       script_url,
       NULL,
       MakeRegisteredCallback(&called, &registration_id));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
 
-  if (is_mojo_enabled()) {
-    EXPECT_EQ(1UL, helper_->ipc_sink()->message_count());
-    ASSERT_EQ(2UL, client->events().size());
-    EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StartWorker,
-              client->events()[0]);
-    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-        ServiceWorkerMsg_InstallEvent::ID));
-    EXPECT_FALSE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-        ServiceWorkerMsg_ActivateEvent::ID));
-    EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StopWorker,
-              client->events()[1]);
-  } else {
-    EXPECT_EQ(3UL, helper_->ipc_sink()->message_count());
-    EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
-        EmbeddedWorkerMsg_StartWorker::ID));
-    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-        ServiceWorkerMsg_InstallEvent::ID));
-    EXPECT_FALSE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-        ServiceWorkerMsg_ActivateEvent::ID));
-    EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
-        EmbeddedWorkerMsg_StopWorker::ID));
-  }
+  EXPECT_EQ(1UL, helper_->ipc_sink()->message_count());
+  ASSERT_EQ(2UL, client->events().size());
+  EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StartWorker,
+            client->events()[0]);
+  EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+      ServiceWorkerMsg_InstallEvent::ID));
+  EXPECT_FALSE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+      ServiceWorkerMsg_ActivateEvent::ID));
+  EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StopWorker,
+            client->events()[1]);
+
   EXPECT_NE(kInvalidServiceWorkerRegistrationId, registration_id);
 
   ASSERT_EQ(1u, notifications_.size());
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(registration_id, notifications_[0].registration_id);
 
   context()->storage()->FindRegistrationForId(
       registration_id,
       pattern.GetOrigin(),
       base::Bind(&ExpectRegisteredWorkers,
                  SERVICE_WORKER_ERROR_NOT_FOUND,
                  false /* expect_waiting */,
                  false /* expect_active */));
   base::RunLoop().RunUntilIdle();
 }
 
 // Test registration when the service worker rejects the activate event. The
 // worker should be activated anyway.
-TEST_P(ServiceWorkerContextTestP, Register_RejectActivate) {
+TEST_F(ServiceWorkerContextTest, Register_RejectActivate) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
   helper_.reset();
   helper_.reset(new RejectActivateTestHelper);
   helper_->context_wrapper()->AddObserver(this);
 
   RecordableEmbeddedWorkerInstanceClient* client = nullptr;
-  if (is_mojo_enabled()) {
-    client = helper_->CreateAndRegisterMockInstanceClient<
-        RecordableEmbeddedWorkerInstanceClient>(helper_->AsWeakPtr());
-  }
+  client = helper_->CreateAndRegisterMockInstanceClient<
+      RecordableEmbeddedWorkerInstanceClient>(helper_->AsWeakPtr());
 
   int64_t registration_id = kInvalidServiceWorkerRegistrationId;
   bool called = false;
   context()->RegisterServiceWorker(
       pattern, script_url, NULL,
       MakeRegisteredCallback(&called, &registration_id));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
 
-  if (is_mojo_enabled()) {
-    EXPECT_EQ(2UL, helper_->ipc_sink()->message_count());
-    ASSERT_EQ(2UL, client->events().size());
-    EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StartWorker,
-              client->events()[0]);
-    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-        ServiceWorkerMsg_InstallEvent::ID));
-    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-        ServiceWorkerMsg_ActivateEvent::ID));
-    EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StopWorker,
-              client->events()[1]);
-  } else {
-    EXPECT_EQ(4UL, helper_->ipc_sink()->message_count());
-    EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
-        EmbeddedWorkerMsg_StartWorker::ID));
-    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-        ServiceWorkerMsg_InstallEvent::ID));
-    EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
-        ServiceWorkerMsg_ActivateEvent::ID));
-    EXPECT_TRUE(helper_->ipc_sink()->GetUniqueMessageMatching(
-        EmbeddedWorkerMsg_StopWorker::ID));
-  }
+  EXPECT_EQ(2UL, helper_->ipc_sink()->message_count());
+  ASSERT_EQ(2UL, client->events().size());
+  EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StartWorker,
+            client->events()[0]);
+  EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+      ServiceWorkerMsg_InstallEvent::ID));
+  EXPECT_TRUE(helper_->inner_ipc_sink()->GetUniqueMessageMatching(
+      ServiceWorkerMsg_ActivateEvent::ID));
+  EXPECT_EQ(RecordableEmbeddedWorkerInstanceClient::Message::StopWorker,
+            client->events()[1]);
+
   EXPECT_NE(kInvalidServiceWorkerRegistrationId, registration_id);
 
   ASSERT_EQ(1u, notifications_.size());
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(registration_id, notifications_[0].registration_id);
 
   context()->storage()->FindRegistrationForId(
       registration_id, pattern.GetOrigin(),
       base::Bind(&ExpectRegisteredWorkers, SERVICE_WORKER_OK,
                  false /* expect_waiting */, true /* expect_active */));
   base::RunLoop().RunUntilIdle();
 }
 
 // Make sure registrations are cleaned up when they are unregistered.
-TEST_P(ServiceWorkerContextTestP, Unregister) {
+TEST_F(ServiceWorkerContextTest, Unregister) {
   GURL pattern("http://www.example.com/");
 
   bool called = false;
   int64_t registration_id = kInvalidServiceWorkerRegistrationId;
   context()->RegisterServiceWorker(
       pattern,
       GURL("http://www.example.com/service_worker.js"),
       NULL,
       MakeRegisteredCallback(&called, &registration_id));
 
@@ skipping 22 matching lines @@
   ASSERT_EQ(2u, notifications_.size());
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(registration_id, notifications_[0].registration_id);
   EXPECT_EQ(REGISTRATION_DELETED, notifications_[1].type);
   EXPECT_EQ(pattern, notifications_[1].pattern);
   EXPECT_EQ(registration_id, notifications_[1].registration_id);
 }
 
 // Make sure registrations are cleaned up when they are unregistered in bulk.
-TEST_P(ServiceWorkerContextTestP, UnregisterMultiple) {
+TEST_F(ServiceWorkerContextTest, UnregisterMultiple) {
   GURL origin1_p1("http://www.example.com/test");
   GURL origin1_p2("http://www.example.com/hello");
   GURL origin2_p1("http://www.example.com:8080/again");
   GURL origin3_p1("http://www.other.com/");
 
   bool called = false;
   int64_t registration_id1 = kInvalidServiceWorkerRegistrationId;
   int64_t registration_id2 = kInvalidServiceWorkerRegistrationId;
   int64_t registration_id3 = kInvalidServiceWorkerRegistrationId;
   int64_t registration_id4 = kInvalidServiceWorkerRegistrationId;
@@ skipping 82 matching lines @@
   EXPECT_EQ(registration_id4, notifications_[3].registration_id);
   EXPECT_EQ(REGISTRATION_DELETED, notifications_[4].type);
   EXPECT_EQ(origin1_p2, notifications_[4].pattern);
   EXPECT_EQ(registration_id2, notifications_[4].registration_id);
   EXPECT_EQ(REGISTRATION_DELETED, notifications_[5].type);
   EXPECT_EQ(origin1_p1, notifications_[5].pattern);
   EXPECT_EQ(registration_id1, notifications_[5].registration_id);
 }
 
 // Make sure registering a new script shares an existing registration.
-TEST_P(ServiceWorkerContextTestP, RegisterNewScript) {
+TEST_F(ServiceWorkerContextTest, RegisterNewScript) {
   GURL pattern("http://www.example.com/");
 
   bool called = false;
   int64_t old_registration_id = kInvalidServiceWorkerRegistrationId;
   context()->RegisterServiceWorker(
       pattern,
       GURL("http://www.example.com/service_worker.js"),
       NULL,
       MakeRegisteredCallback(&called, &old_registration_id));
 
@@ skipping 21 matching lines @@
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(old_registration_id, notifications_[0].registration_id);
   EXPECT_EQ(REGISTRATION_STORED, notifications_[1].type);
   EXPECT_EQ(pattern, notifications_[1].pattern);
   EXPECT_EQ(new_registration_id, notifications_[1].registration_id);
 }
 
 // Make sure that when registering a duplicate pattern+script_url
 // combination, that the same registration is used.
-TEST_P(ServiceWorkerContextTestP, RegisterDuplicateScript) {
+TEST_F(ServiceWorkerContextTest, RegisterDuplicateScript) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
   bool called = false;
   int64_t old_registration_id = kInvalidServiceWorkerRegistrationId;
   context()->RegisterServiceWorker(
       pattern,
       script_url,
       NULL,
       MakeRegisteredCallback(&called, &old_registration_id));
@@ skipping 18 matching lines @@
 
   ASSERT_EQ(2u, notifications_.size());
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(old_registration_id, notifications_[0].registration_id);
   EXPECT_EQ(REGISTRATION_STORED, notifications_[1].type);
   EXPECT_EQ(pattern, notifications_[1].pattern);
   EXPECT_EQ(old_registration_id, notifications_[1].registration_id);
 }
 
-TEST_P(ServiceWorkerContextTestP, ProviderHostIterator) {
+TEST_F(ServiceWorkerContextTest, ProviderHostIterator) {
   const int kRenderProcessId1 = 1;
   const int kRenderProcessId2 = 2;
   const GURL kOrigin1 = GURL("http://www.example.com/");
   const GURL kOrigin2 = GURL("https://www.example.com/");
   int provider_id = 1;
 
   // Host1 (provider_id=1): process_id=1, origin1.
   ServiceWorkerProviderHost* host1(new ServiceWorkerProviderHost(
       kRenderProcessId1, MSG_ROUTING_NONE, provider_id++,
       SERVICE_WORKER_PROVIDER_FOR_WINDOW,
@@ skipping 63 matching lines @@
   EXPECT_TRUE(ContainsKey(results, host2));
 
   context()->RemoveProviderHost(kRenderProcessId1, 1);
   context()->RemoveProviderHost(kRenderProcessId2, 2);
   context()->RemoveProviderHost(kRenderProcessId2, 3);
   context()->RemoveProviderHost(kRenderProcessId2, 4);
 }
 
 class ServiceWorkerContextRecoveryTest
     : public ServiceWorkerContextTest,
-      public testing::WithParamInterface<testing::tuple<bool, bool>> {
+      public testing::WithParamInterface<bool> {
  public:
   ServiceWorkerContextRecoveryTest() {}
   virtual ~ServiceWorkerContextRecoveryTest() {}
 
  protected:
-  void SetUp() override {
-    if (!is_mojo_enabled()) {
-      base::CommandLine::ForCurrentProcess()->AppendSwitch(
-          switches::kDisableMojoServiceWorker);
-    }
-    ServiceWorkerContextTest::SetUp();
-  }
-
-  bool is_mojo_enabled() const { return testing::get<0>(GetParam()); }
-  bool is_storage_on_disk() const { return testing::get<1>(GetParam()); }
+  bool is_storage_on_disk() const { return GetParam(); }
 };
 
 TEST_P(ServiceWorkerContextRecoveryTest, DeleteAndStartOver) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
   if (is_storage_on_disk()) {
     // Reinitialize the helper to test on-disk storage.
     base::ScopedTempDir user_data_directory;
     ASSERT_TRUE(user_data_directory.CreateUniqueTempDir());
@@ skipping 74 matching lines @@
   ASSERT_EQ(3u, notifications_.size());
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(registration_id, notifications_[0].registration_id);
   EXPECT_EQ(STORAGE_RECOVERED, notifications_[1].type);
   EXPECT_EQ(REGISTRATION_STORED, notifications_[2].type);
   EXPECT_EQ(pattern, notifications_[2].pattern);
   EXPECT_EQ(registration_id, notifications_[2].registration_id);
 }
 
-INSTANTIATE_TEST_CASE_P(ServiceWorkerContextTest,
-                        ServiceWorkerContextTestP,
+INSTANTIATE_TEST_CASE_P(ServiceWorkerContextRecoveryTest,
+                        ServiceWorkerContextRecoveryTest,
                         testing::Bool());
 
-INSTANTIATE_TEST_CASE_P(ServiceWorkerContextRecoveryTest,
-                        ServiceWorkerContextRecoveryTest,
-                        testing::Combine(testing::Bool(), testing::Bool()));
-
 }  // namespace content