ServiceWorker: Returns true for IsMojoForServiceWorkerEnabled

content/browser/service_worker/service_worker_process_manager_unittest.cc

 // Copyright 2014 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_process_manager.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 52 matching lines @@
   std::unique_ptr<TestBrowserContext> browser_context_;
   std::unique_ptr<ServiceWorkerProcessManager> process_manager_;
   GURL pattern_;
   GURL script_url_;
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerProcessManagerTest);
 };
 
-class ServiceWorkerProcessManagerTestP
-    : public MojoServiceWorkerTestP<ServiceWorkerProcessManagerTest> {};
-
-TEST_P(ServiceWorkerProcessManagerTestP, SortProcess) {
+TEST_F(ServiceWorkerProcessManagerTest, SortProcess) {
   // Process 1 has 2 refs, 2 has 3 refs and 3 has 1 ref.
   process_manager_->AddProcessReferenceToPattern(pattern_, 1);
   process_manager_->AddProcessReferenceToPattern(pattern_, 1);
   process_manager_->AddProcessReferenceToPattern(pattern_, 2);
   process_manager_->AddProcessReferenceToPattern(pattern_, 2);
   process_manager_->AddProcessReferenceToPattern(pattern_, 2);
   process_manager_->AddProcessReferenceToPattern(pattern_, 3);
 
   // Process 2 has the biggest # of references and it should be chosen.
   EXPECT_THAT(process_manager_->SortProcessesForPattern(pattern_),
               testing::ElementsAre(2, 1, 3));
 
   process_manager_->RemoveProcessReferenceFromPattern(pattern_, 1);
   process_manager_->RemoveProcessReferenceFromPattern(pattern_, 1);
   // Scores for each process: 2 : 3, 3 : 1, process 1 is removed.
   EXPECT_THAT(process_manager_->SortProcessesForPattern(pattern_),
               testing::ElementsAre(2, 3));
 }
 
-TEST_P(ServiceWorkerProcessManagerTestP, FindAvailableProcess) {
+TEST_F(ServiceWorkerProcessManagerTest, FindAvailableProcess) {
   std::unique_ptr<MockRenderProcessHost> host1(CreateRenderProcessHost());
   std::unique_ptr<MockRenderProcessHost> host2(CreateRenderProcessHost());
   std::unique_ptr<MockRenderProcessHost> host3(CreateRenderProcessHost());
 
   // Process 1 has 2 refs, 2 has 3 refs and 3 has 1 ref.
   process_manager_->AddProcessReferenceToPattern(pattern_, host1->GetID());
   process_manager_->AddProcessReferenceToPattern(pattern_, host1->GetID());
   process_manager_->AddProcessReferenceToPattern(pattern_, host2->GetID());
   process_manager_->AddProcessReferenceToPattern(pattern_, host2->GetID());
   process_manager_->AddProcessReferenceToPattern(pattern_, host2->GetID());
@@ skipping 11 matching lines @@
   // refcount should be chosen.
   host1->set_is_process_backgrounded(true);
   host3->set_is_process_backgrounded(true);
   EXPECT_EQ(host2->GetID(), process_manager_->FindAvailableProcess(pattern_));
 
   // Process 3 should be chosen because it is the only foreground process.
   host3->set_is_process_backgrounded(false);
   EXPECT_EQ(host3->GetID(), process_manager_->FindAvailableProcess(pattern_));
 }
 
-TEST_P(ServiceWorkerProcessManagerTestP,
+TEST_F(ServiceWorkerProcessManagerTest,
        AllocateWorkerProcess_FindAvailableProcess) {
   const int kEmbeddedWorkerId1 = 100;
   const int kEmbeddedWorkerId2 = 200;
   const int kEmbeddedWorkerId3 = 300;
   GURL scope1("http://example.com/scope1");
   GURL scope2("http://example.com/scope2");
 
   // Set up mock renderer process hosts.
   std::unique_ptr<MockRenderProcessHost> host1(CreateRenderProcessHost());
   std::unique_ptr<MockRenderProcessHost> host2(CreateRenderProcessHost());
@@ skipping 90 matching lines @@
   EXPECT_EQ(0u, host2->GetWorkerRefCount());
   EXPECT_EQ(1u, instance_info.size());
   EXPECT_TRUE(base::ContainsKey(instance_info, kEmbeddedWorkerId2));
 
   process_manager_->ReleaseWorkerProcess(kEmbeddedWorkerId2);
   EXPECT_EQ(0u, host1->GetWorkerRefCount());
   EXPECT_EQ(0u, host2->GetWorkerRefCount());
   EXPECT_TRUE(instance_info.empty());
 }
 
-TEST_P(ServiceWorkerProcessManagerTestP, AllocateWorkerProcess_InShutdown) {
+TEST_F(ServiceWorkerProcessManagerTest, AllocateWorkerProcess_InShutdown) {
   process_manager_->Shutdown();
   ASSERT_TRUE(process_manager_->IsShutdown());
 
   base::RunLoop run_loop;
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE;
   int process_id = -10;
   bool is_new_process = true;
   process_manager_->AllocateWorkerProcess(
       1, pattern_, script_url_, true /* can_use_existing_process */,
       base::Bind(&DidAllocateWorkerProcess, run_loop.QuitClosure(), &status,
                  &process_id, &is_new_process));
   run_loop.Run();
 
   // Allocating a process in shutdown should abort.
   EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT, status);
   EXPECT_EQ(ChildProcessHost::kInvalidUniqueID, process_id);
   EXPECT_FALSE(is_new_process);
   EXPECT_TRUE(process_manager_->instance_info_.empty());
 }
 
-INSTANTIATE_TEST_CASE_P(ServiceWorkerProcessManagerTest,
-                        ServiceWorkerProcessManagerTestP,
-                        testing::Bool());
-
 }  // namespace content