Mojofy unittests related to service workers

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"
+#include "content/browser/service_worker/service_worker_test_utils.h"
 #include "content/common/service_worker/embedded_worker_settings.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace content {
@@ skipping 41 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);
 };
 
-TEST_F(ServiceWorkerProcessManagerTest, SortProcess) {
+class ServiceWorkerProcessManagerTestP
+    : public MojoServiceWorkerTestP<ServiceWorkerProcessManagerTest> {};
+
+TEST_P(ServiceWorkerProcessManagerTestP, 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_F(ServiceWorkerProcessManagerTest, FindAvailableProcess) {
+TEST_P(ServiceWorkerProcessManagerTestP, 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_F(ServiceWorkerProcessManagerTest,
+TEST_P(ServiceWorkerProcessManagerTestP,
        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(0, host2->worker_ref_count());
   EXPECT_EQ(1u, instance_info.size());
   EXPECT_TRUE(base::ContainsKey(instance_info, kEmbeddedWorkerId2));
 
   process_manager_->ReleaseWorkerProcess(kEmbeddedWorkerId2);
   EXPECT_EQ(0, host1->worker_ref_count());
   EXPECT_EQ(0, host2->worker_ref_count());
   EXPECT_TRUE(instance_info.empty());
 }
 
-TEST_F(ServiceWorkerProcessManagerTest, AllocateWorkerProcess_InShutdown) {
+TEST_P(ServiceWorkerProcessManagerTestP, 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