WIP attempt to replace StartWorker/StopWorker IPCs with a new mojo EmbeddedWorker service.

content/browser/service_worker/service_worker_version_unittest.cc

Index: content/browser/service_worker/service_worker_version_unittest.cc
diff --git a/content/browser/service_worker/service_worker_version_unittest.cc b/content/browser/service_worker/service_worker_version_unittest.cc
index e52f698de13e452329dfe5a3c21e25ad34c57ec4..d124999bb5efbc725599cbf242dfd69affa054ad 100644
--- a/content/browser/service_worker/service_worker_version_unittest.cc
+++ b/content/browser/service_worker/service_worker_version_unittest.cc
@@ -13,6 +13,7 @@
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // IPC messages for testing ---------------------------------------------------
@@ -31,12 +32,10 @@ namespace content {
 
 namespace {
 
-static const int kRenderProcessId = 1;
-
 class MessageReceiver : public EmbeddedWorkerTestHelper {
  public:
   MessageReceiver()
-      : EmbeddedWorkerTestHelper(base::FilePath(), kRenderProcessId),
+      : EmbeddedWorkerTestHelper(base::FilePath()),
         current_embedded_worker_id_(0) {}
   ~MessageReceiver() override {}
 
@@ -178,7 +177,8 @@ class ServiceWorkerVersionTest : public testing::Test {
     ASSERT_EQ(SERVICE_WORKER_OK, status);
 
     // Simulate adding one process to the pattern.
-    helper_->SimulateAddProcessToPattern(pattern_, kRenderProcessId);
+    helper_->SimulateAddProcessToPattern(pattern_,
+                                         helper_->mock_render_process_id());
     ASSERT_TRUE(helper_->context()->process_manager()
         ->PatternHasProcessToRun(pattern_));
   }
@@ -265,16 +265,23 @@ TEST_F(ServiceWorkerVersionTest, ConcurrentStartAndStop) {
   ServiceWorkerStatusCode status1 = SERVICE_WORKER_ERROR_FAILED;
   ServiceWorkerStatusCode status2 = SERVICE_WORKER_ERROR_FAILED;
   ServiceWorkerStatusCode status3 = SERVICE_WORKER_ERROR_FAILED;
-  version_->StartWorker(CreateReceiverOnCurrentThread(&status1));
-  version_->StartWorker(CreateReceiverOnCurrentThread(&status2));
+  scoped_refptr<MessageLoopRunner> runner1(new MessageLoopRunner);
+  scoped_refptr<MessageLoopRunner> runner2(new MessageLoopRunner);
+  version_->StartWorker(
+      CreateReceiverOnCurrentThread(&status1, runner1->QuitClosure()));
+  version_->StartWorker(
+      CreateReceiverOnCurrentThread(&status2, runner2->QuitClosure()));
 
   EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
-  base::RunLoop().RunUntilIdle();
+  runner1->Run();
+  runner2->Run();
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 
   // Call StartWorker() after it's started.
-  version_->StartWorker(CreateReceiverOnCurrentThread(&status3));
-  base::RunLoop().RunUntilIdle();
+  runner1 = new MessageLoopRunner();
+  version_->StartWorker(
+      CreateReceiverOnCurrentThread(&status3, runner1->QuitClosure()));
+  runner1->Run();
 
   // All should just succeed.
   EXPECT_EQ(SERVICE_WORKER_OK, status1);
@@ -284,11 +291,16 @@ TEST_F(ServiceWorkerVersionTest, ConcurrentStartAndStop) {
   // Call StopWorker() multiple times.
   status1 = SERVICE_WORKER_ERROR_FAILED;
   status2 = SERVICE_WORKER_ERROR_FAILED;
-  version_->StopWorker(CreateReceiverOnCurrentThread(&status1));
-  version_->StopWorker(CreateReceiverOnCurrentThread(&status2));
+  runner1 = new MessageLoopRunner;
+  runner2 = new MessageLoopRunner;
+  version_->StopWorker(
+      CreateReceiverOnCurrentThread(&status1, runner1->QuitClosure()));
+  version_->StopWorker(
+      CreateReceiverOnCurrentThread(&status2, runner2->QuitClosure()));
 
   EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status());
-  base::RunLoop().RunUntilIdle();
+  runner1->Run();
+  runner2->Run();
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
 
   // All StopWorker should just succeed.
@@ -299,11 +311,14 @@ TEST_F(ServiceWorkerVersionTest, ConcurrentStartAndStop) {
   status1 = SERVICE_WORKER_ERROR_FAILED;
   status2 = SERVICE_WORKER_ERROR_FAILED;
   status3 = SERVICE_WORKER_ERROR_FAILED;
+  runner1 = new MessageLoopRunner();
+  scoped_refptr<MessageLoopRunner> runner3(new MessageLoopRunner());
 
-  version_->StartWorker(CreateReceiverOnCurrentThread(&status1));
+  version_->StartWorker(
+      CreateReceiverOnCurrentThread(&status1, runner1->QuitClosure()));
 
   EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
-  base::RunLoop().RunUntilIdle();
+  runner1->Run();
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 
   // Call StopWorker()
@@ -311,10 +326,11 @@ TEST_F(ServiceWorkerVersionTest, ConcurrentStartAndStop) {
   version_->StopWorker(CreateReceiverOnCurrentThread(&status2));
 
   // And try calling StartWorker while StopWorker is in queue.
-  version_->StartWorker(CreateReceiverOnCurrentThread(&status3));
+  version_->StartWorker(
+      CreateReceiverOnCurrentThread(&status3, runner3->QuitClosure()));
 
   EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status());
-  base::RunLoop().RunUntilIdle();
+  runner3->Run();
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 
   // All should just succeed.
@@ -328,9 +344,11 @@ TEST_F(ServiceWorkerVersionTest, DispatchEventToStoppedWorker) {
 
   // Dispatch an event without starting the worker.
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
   version_->SetStatus(ServiceWorkerVersion::INSTALLING);
-  version_->DispatchInstallEvent(CreateReceiverOnCurrentThread(&status));
-  base::RunLoop().RunUntilIdle();
+  version_->DispatchInstallEvent(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
+  runner->Run();
   EXPECT_EQ(SERVICE_WORKER_OK, status);
 
   // The worker should be now started.
@@ -338,10 +356,12 @@ TEST_F(ServiceWorkerVersionTest, DispatchEventToStoppedWorker) {
 
   // Stop the worker, and then dispatch an event immediately after that.
   status = SERVICE_WORKER_ERROR_FAILED;
+  runner = new MessageLoopRunner;
   ServiceWorkerStatusCode stop_status = SERVICE_WORKER_ERROR_FAILED;
   version_->StopWorker(CreateReceiverOnCurrentThread(&stop_status));
-  version_->DispatchInstallEvent(CreateReceiverOnCurrentThread(&status));
-  base::RunLoop().RunUntilIdle();
+  version_->DispatchInstallEvent(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
+  runner->Run();
   EXPECT_EQ(SERVICE_WORKER_OK, stop_status);
 
   // Dispatch an event should return SERVICE_WORKER_OK since the worker
@@ -355,9 +375,11 @@ TEST_F(ServiceWorkerVersionTest, DispatchEventToStoppedWorker) {
 TEST_F(ServiceWorkerVersionTest, ReceiveMessageFromWorker) {
   // Start worker.
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
-  version_->StartWorker(CreateReceiverOnCurrentThread(&status));
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
+  version_->StartWorker(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
   EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
-  base::RunLoop().RunUntilIdle();
+  runner->Run();
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 
@@ -380,14 +402,16 @@ TEST_F(ServiceWorkerVersionTest, InstallAndWaitCompletion) {
 
   // Dispatch an install event.
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
-  version_->DispatchInstallEvent(CreateReceiverOnCurrentThread(&status));
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
+  version_->DispatchInstallEvent(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
 
   // Wait for the completion.
   bool status_change_called = false;
   version_->RegisterStatusChangeCallback(
       base::Bind(&VerifyCalled, &status_change_called));
 
-  base::RunLoop().RunUntilIdle();
+  runner->Run();
 
   // Version's status must not have changed during installation.
   EXPECT_EQ(SERVICE_WORKER_OK, status);
@@ -400,14 +424,16 @@ TEST_F(ServiceWorkerVersionTest, ActivateAndWaitCompletion) {
 
   // Dispatch an activate event.
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
-  version_->DispatchActivateEvent(CreateReceiverOnCurrentThread(&status));
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
+  version_->DispatchActivateEvent(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
 
   // Wait for the completion.
   bool status_change_called = false;
   version_->RegisterStatusChangeCallback(
       base::Bind(&VerifyCalled, &status_change_called));
 
-  base::RunLoop().RunUntilIdle();
+  runner->Run();
 
   // Version's status must not have changed during activation.
   EXPECT_EQ(SERVICE_WORKER_OK, status);
@@ -449,8 +475,10 @@ TEST_F(ServiceWorkerVersionTest, IdleTimeout) {
 
   // Verify the timer is running after the worker is started.
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
-  version_->StartWorker(CreateReceiverOnCurrentThread(&status));
-  base::RunLoop().RunUntilIdle();
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
+  version_->StartWorker(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
+  runner->Run();
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_TRUE(version_->timeout_timer_.IsRunning());
   EXPECT_FALSE(version_->idle_time_.is_null());
@@ -458,14 +486,18 @@ TEST_F(ServiceWorkerVersionTest, IdleTimeout) {
   // The idle time should be reset if the worker is restarted without
   // controllee.
   status = SERVICE_WORKER_ERROR_FAILED;
+  runner = new MessageLoopRunner;
   version_->idle_time_ -= kOneSecond;
   base::TimeTicks idle_time = version_->idle_time_;
-  version_->StopWorker(CreateReceiverOnCurrentThread(&status));
-  base::RunLoop().RunUntilIdle();
+  version_->StopWorker(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
+  runner->Run();
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   status = SERVICE_WORKER_ERROR_FAILED;
-  version_->StartWorker(CreateReceiverOnCurrentThread(&status));
-  base::RunLoop().RunUntilIdle();
+  runner = new MessageLoopRunner;
+  version_->StartWorker(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
+  runner->Run();
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_TRUE(version_->timeout_timer_.IsRunning());
   EXPECT_LT(idle_time, version_->idle_time_);
@@ -510,7 +542,9 @@ TEST_F(ServiceWorkerVersionTest, IdleTimeout) {
 
 TEST_F(ServiceWorkerVersionTest, SetDevToolsAttached) {
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
-  version_->StartWorker(CreateReceiverOnCurrentThread(&status));
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
+  version_->StartWorker(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
 
   ASSERT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
 
@@ -532,7 +566,7 @@ TEST_F(ServiceWorkerVersionTest, SetDevToolsAttached) {
   EXPECT_FALSE(version_->start_time_.is_null());
   EXPECT_TRUE(version_->skip_recording_startup_time_);
 
-  base::RunLoop().RunUntilIdle();
+  runner->Run();
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 }
@@ -541,9 +575,11 @@ TEST_F(ServiceWorkerVersionTest, StoppingBeforeDestruct) {
   RunningStateListener listener;
   version_->AddListener(&listener);
 
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
-  version_->StartWorker(CreateReceiverOnCurrentThread(&status));
-  base::RunLoop().RunUntilIdle();
+  version_->StartWorker(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
+  runner->Run();
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, listener.last_status);
@@ -556,12 +592,14 @@ TEST_F(ServiceWorkerVersionTest, StoppingBeforeDestruct) {
 TEST_F(ServiceWorkerVersionTest, StaleUpdate_FreshWorker) {
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
 
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   registration_->SetActiveVersion(version_);
   registration_->set_last_update_check(base::Time::Now());
-  version_->DispatchPushEvent(CreateReceiverOnCurrentThread(&status),
-                              std::string());
-  base::RunLoop().RunUntilIdle();
+  version_->DispatchPushEvent(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()),
+      std::string());
+  runner->Run();
 
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_TRUE(version_->stale_time_.is_null());
@@ -572,11 +610,13 @@ TEST_F(ServiceWorkerVersionTest, StaleUpdate_FreshWorker) {
 TEST_F(ServiceWorkerVersionTest, StaleUpdate_NonActiveWorker) {
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
 
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
   version_->SetStatus(ServiceWorkerVersion::INSTALLING);
   registration_->SetInstallingVersion(version_);
   registration_->set_last_update_check(GetYesterday());
-  version_->DispatchInstallEvent(CreateReceiverOnCurrentThread(&status));
-  base::RunLoop().RunUntilIdle();
+  version_->DispatchInstallEvent(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
+  runner->Run();
 
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_TRUE(version_->stale_time_.is_null());
@@ -588,19 +628,23 @@ TEST_F(ServiceWorkerVersionTest, StaleUpdate_StartWorker) {
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
 
   // Starting the worker marks it as stale.
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   registration_->SetActiveVersion(version_);
   registration_->set_last_update_check(GetYesterday());
-  version_->DispatchPushEvent(CreateReceiverOnCurrentThread(&status),
-                              std::string());
-  base::RunLoop().RunUntilIdle();
+  version_->DispatchPushEvent(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()),
+      std::string());
+  runner->Run();
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_FALSE(version_->stale_time_.is_null());
   EXPECT_FALSE(version_->update_timer_.IsRunning());
 
   // Update is actually scheduled after the worker stops.
-  version_->StopWorker(CreateReceiverOnCurrentThread(&status));
-  base::RunLoop().RunUntilIdle();
+  runner = new MessageLoopRunner;
+  version_->StopWorker(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()));
+  runner->Run();
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_TRUE(version_->stale_time_.is_null());
   EXPECT_TRUE(version_->update_timer_.IsRunning());
@@ -611,12 +655,14 @@ TEST_F(ServiceWorkerVersionTest, StaleUpdate_RunningWorker) {
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
 
   // Start a fresh worker.
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   registration_->SetActiveVersion(version_);
   registration_->set_last_update_check(base::Time::Now());
-  version_->DispatchPushEvent(CreateReceiverOnCurrentThread(&status),
-                              std::string());
-  base::RunLoop().RunUntilIdle();
+  version_->DispatchPushEvent(
+      CreateReceiverOnCurrentThread(&status, runner->QuitClosure()),
+      std::string());
+  runner->Run();
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_TRUE(version_->stale_time_.is_null());