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

content/browser/service_worker/service_worker_version_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 "base/basictypes.h"
 #include "base/run_loop.h"
 #include "content/browser/message_port_service.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_test_utils.h"
 #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 ---------------------------------------------------
 
 #define IPC_MESSAGE_IMPL
 #include "ipc/ipc_message_macros.h"
 
 #define IPC_MESSAGE_START TestMsgStart
 
 IPC_MESSAGE_CONTROL0(TestMsg_Message);
 IPC_MESSAGE_ROUTED1(TestMsg_MessageFromWorker, int);
 
 // ---------------------------------------------------------------------------
 
 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 {}
 
   bool OnMessageToWorker(int thread_id,
                          int embedded_worker_id,
                          const IPC::Message& message) override {
     if (EmbeddedWorkerTestHelper::OnMessageToWorker(
             thread_id, embedded_worker_id, message)) {
       return true;
     }
@@ skipping 121 matching lines @@
     base::RunLoop().RunUntilIdle();
     ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
     helper_->context()->storage()->StoreRegistration(
         registration_.get(),
         version_.get(),
         CreateReceiverOnCurrentThread(&status));
     base::RunLoop().RunUntilIdle();
     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_));
   }
 
   virtual scoped_ptr<MessageReceiver> GetMessageReceiver() {
     return make_scoped_ptr(new MessageReceiver());
   }
 
   void TearDown() override {
     version_ = 0;
@@ skipping 66 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerWaitForeverInFetchTest);
 };
 
 TEST_F(ServiceWorkerVersionTest, ConcurrentStartAndStop) {
   // Call StartWorker() multiple times.
   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);
   EXPECT_EQ(SERVICE_WORKER_OK, status2);
   EXPECT_EQ(SERVICE_WORKER_OK, status3);
 
   // 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.
   EXPECT_EQ(SERVICE_WORKER_OK, status1);
   EXPECT_EQ(SERVICE_WORKER_OK, status2);
 
   // Start worker again.
   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()
   status2 = SERVICE_WORKER_ERROR_FAILED;
   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.
   EXPECT_EQ(SERVICE_WORKER_OK, status1);
   EXPECT_EQ(SERVICE_WORKER_OK, status2);
   EXPECT_EQ(SERVICE_WORKER_OK, status3);
 }
 
 TEST_F(ServiceWorkerVersionTest, DispatchEventToStoppedWorker) {
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
 
   // 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.
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 
   // 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
   // should have been restarted to dispatch the event.
   EXPECT_EQ(SERVICE_WORKER_OK, status);
 
   // The worker should be now started again.
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 }
 
 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());
 
   MessageReceiverFromWorker receiver(version_->embedded_worker());
 
   // Simulate sending some dummy values from the worker.
   helper_->SimulateSendValueToBrowser(
       version_->embedded_worker()->embedded_worker_id(), 555);
   helper_->SimulateSendValueToBrowser(
       version_->embedded_worker()->embedded_worker_id(), 777);
 
   // Verify the receiver received the values.
   ASSERT_EQ(2U, receiver.received_values().size());
   EXPECT_EQ(555, receiver.received_values()[0]);
   EXPECT_EQ(777, receiver.received_values()[1]);
 }
 
 TEST_F(ServiceWorkerVersionTest, InstallAndWaitCompletion) {
   version_->SetStatus(ServiceWorkerVersion::INSTALLING);
 
   // 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);
   EXPECT_FALSE(status_change_called);
   EXPECT_EQ(ServiceWorkerVersion::INSTALLING, version_->status());
 }
 
 TEST_F(ServiceWorkerVersionTest, ActivateAndWaitCompletion) {
   version_->SetStatus(ServiceWorkerVersion::ACTIVATING);
 
   // 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);
   EXPECT_FALSE(status_change_called);
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATING, version_->status());
 }
 
 TEST_F(ServiceWorkerVersionTest, RepeatedlyObserveStatusChanges) {
   EXPECT_EQ(ServiceWorkerVersion::NEW, version_->status());
 
@@ skipping 21 matching lines @@
   // Used to reliably test when the idle time gets reset regardless of clock
   // granularity.
   const base::TimeDelta kOneSecond = base::TimeDelta::FromSeconds(1);
 
   // Verify the timer is not running when version initializes its status.
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   EXPECT_FALSE(version_->timeout_timer_.IsRunning());
 
   // 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());
 
   // 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_);
 
   // Adding a controllee resets the idle time.
   version_->idle_time_ -= kOneSecond;
   idle_time = version_->idle_time_;
   scoped_ptr<ServiceWorkerProviderHost> host(new ServiceWorkerProviderHost(
       33 /* dummy render process id */, MSG_ROUTING_NONE /* render_frame_id */,
       1 /* dummy provider_id */, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
@@ skipping 24 matching lines @@
                                  CreateReceiverOnCurrentThread(&status));
   base::RunLoop().RunUntilIdle();
   MessagePortService::GetInstance()->Destroy(ports[0].id);
 
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_LT(idle_time, version_->idle_time_);
 }
 
 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());
 
   ASSERT_TRUE(version_->timeout_timer_.IsRunning());
   ASSERT_FALSE(version_->start_time_.is_null());
   ASSERT_FALSE(version_->skip_recording_startup_time_);
 
   // Simulate DevTools is attached. This should deactivate the timer for start
   // timeout, but not stop the timer itself.
   version_->SetDevToolsAttached(true);
   EXPECT_TRUE(version_->timeout_timer_.IsRunning());
   EXPECT_TRUE(version_->start_time_.is_null());
   EXPECT_TRUE(version_->skip_recording_startup_time_);
 
   // Simulate DevTools is detached. This should reactivate the timer for start
   // timeout.
   version_->SetDevToolsAttached(false);
   EXPECT_TRUE(version_->timeout_timer_.IsRunning());
   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());
 }
 
 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);
 
   version_ = nullptr;
   EXPECT_EQ(ServiceWorkerVersion::STOPPING, listener.last_status);
 }
 
 // Test that update isn't triggered for a non-stale worker.
 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());
   EXPECT_FALSE(version_->update_timer_.IsRunning());
 }
 
 // Test that update isn't triggered for a non-active worker.
 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());
   EXPECT_FALSE(version_->update_timer_.IsRunning());
 }
 
 // Test that staleness is detected when starting a worker.
 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());
 }
 
 // Test that staleness is detected on a running worker.
 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());
 
   // Simulate it running for a day. It will be marked stale.
   registration_->set_last_update_check(GetYesterday());
   version_->OnTimeoutTimer();
   EXPECT_FALSE(version_->stale_time_.is_null());
   EXPECT_FALSE(version_->update_timer_.IsRunning());
 
   // Simulate it running for past the wait threshold. The update will be
@@ skipping 111 matching lines @@
       base::TimeTicks::Now() -
       base::TimeDelta::FromMinutes(
           ServiceWorkerVersion::kStartWorkerTimeoutMinutes + 1);
   version_->timeout_timer_.user_task().Run();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status);
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
 }
 
 }  // namespace content