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

content/browser/service_worker/service_worker_job_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/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "content/browser/browser_thread_impl.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_disk_cache.h"
 #include "content/browser/service_worker/service_worker_job_coordinator.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_registration_status.h"
 #include "content/browser/service_worker/service_worker_test_utils.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "ipc/ipc_test_sink.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::IOBuffer;
 using net::TestCompletionCallback;
 using net::WrappedIOBuffer;
 
 // Unit tests for testing all job registration tasks.
 namespace content {
 
 namespace {
 
-int kMockRenderProcessId = 88;
-
 void SaveRegistrationCallback(
     ServiceWorkerStatusCode expected_status,
+    const scoped_refptr<MessageLoopRunner>& runner,
     bool* called,
     scoped_refptr<ServiceWorkerRegistration>* registration_out,
     ServiceWorkerStatusCode status,
     const std::string& status_message,
     ServiceWorkerRegistration* registration) {
   EXPECT_EQ(expected_status, status);
   *called = true;
   *registration_out = registration;
+  runner->Quit();
 }
 
 void SaveFoundRegistrationCallback(
     ServiceWorkerStatusCode expected_status,
     bool* called,
     scoped_refptr<ServiceWorkerRegistration>* registration,
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& result) {
   EXPECT_EQ(expected_status, status);
   *called = true;
   *registration = result;
 }
 
 // Creates a callback which both keeps track of if it's been called,
 // as well as the resulting registration. Whent the callback is fired,
 // it ensures that the resulting status matches the expectation.
 // 'called' is useful for making sure a sychronous callback is or
 // isn't called.
 ServiceWorkerRegisterJob::RegistrationCallback SaveRegistration(
     ServiceWorkerStatusCode expected_status,
+    const scoped_refptr<MessageLoopRunner>& runner,
     bool* called,
     scoped_refptr<ServiceWorkerRegistration>* registration) {
   *called = false;
-  return base::Bind(
-      &SaveRegistrationCallback, expected_status, called, registration);
+  return base::Bind(&SaveRegistrationCallback, expected_status, runner, called,
+                    registration);
 }
 
 ServiceWorkerStorage::FindRegistrationCallback SaveFoundRegistration(
     ServiceWorkerStatusCode expected_status,
     bool* called,
     scoped_refptr<ServiceWorkerRegistration>* registration) {
   *called = false;
   return base::Bind(&SaveFoundRegistrationCallback,
                     expected_status,
                     called,
@@ skipping 13 matching lines @@
     bool* called) {
   *called = false;
   return base::Bind(&SaveUnregistrationCallback, expected_status, called);
 }
 
 }  // namespace
 
 class ServiceWorkerJobTest : public testing::Test {
  public:
   ServiceWorkerJobTest()
-      : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
-        render_process_id_(kMockRenderProcessId) {}
+      : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
 
   void SetUp() override {
-    helper_.reset(
-        new EmbeddedWorkerTestHelper(base::FilePath(), render_process_id_));
+    helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath()));
   }
 
   void TearDown() override { helper_.reset(); }
 
   ServiceWorkerContextCore* context() const { return helper_->context(); }
 
   ServiceWorkerJobCoordinator* job_coordinator() const {
     return context()->job_coordinator();
   }
   ServiceWorkerStorage* storage() const { return context()->storage(); }
 
  protected:
   scoped_refptr<ServiceWorkerRegistration> RunRegisterJob(
       const GURL& pattern,
       const GURL& script_url,
       ServiceWorkerStatusCode expected_status = SERVICE_WORKER_OK);
   void RunUnregisterJob(
       const GURL& pattern,
       ServiceWorkerStatusCode expected_status = SERVICE_WORKER_OK);
   scoped_refptr<ServiceWorkerRegistration> FindRegistrationForPattern(
       const GURL& pattern,
       ServiceWorkerStatusCode expected_status = SERVICE_WORKER_OK);
   scoped_ptr<ServiceWorkerProviderHost> CreateControllee();
 
   TestBrowserThreadBundle browser_thread_bundle_;
   scoped_ptr<EmbeddedWorkerTestHelper> helper_;
-  int render_process_id_;
 };
 
 scoped_refptr<ServiceWorkerRegistration> ServiceWorkerJobTest::RunRegisterJob(
     const GURL& pattern,
     const GURL& script_url,
     ServiceWorkerStatusCode expected_status) {
   scoped_refptr<ServiceWorkerRegistration> registration;
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
   bool called;
   job_coordinator()->Register(
       pattern, script_url, NULL,
-      SaveRegistration(expected_status, &called, &registration));
+      SaveRegistration(expected_status, runner, &called, &registration));
   EXPECT_FALSE(called);
-  base::RunLoop().RunUntilIdle();
+  runner->Run();
   EXPECT_TRUE(called);
   return registration;
 }
 
 void ServiceWorkerJobTest::RunUnregisterJob(
     const GURL& pattern,
     ServiceWorkerStatusCode expected_status) {
   bool called;
   job_coordinator()->Unregister(pattern,
                                 SaveUnregistration(expected_status, &called));
@@ skipping 64 matching lines @@
   storage()->FindRegistrationForDocument(
       GURL("http://www.example.com/two"),
       SaveFoundRegistration(SERVICE_WORKER_OK, &called, &registration2));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   ASSERT_EQ(registration1, original_registration);
   ASSERT_EQ(registration1, registration2);
 }
 
 TEST_F(ServiceWorkerJobTest, DifferentMatchDifferentRegistration) {
+  scoped_refptr<MessageLoopRunner> runner1(new MessageLoopRunner);
   bool called1;
   scoped_refptr<ServiceWorkerRegistration> original_registration1;
   job_coordinator()->Register(
       GURL("http://www.example.com/one/"),
-      GURL("http://www.example.com/service_worker.js"),
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called1, &original_registration1));
+      GURL("http://www.example.com/service_worker.js"), NULL,
+      SaveRegistration(SERVICE_WORKER_OK, runner1, &called1,
+                       &original_registration1));
 
+  scoped_refptr<MessageLoopRunner> runner2(new MessageLoopRunner);
   bool called2;
   scoped_refptr<ServiceWorkerRegistration> original_registration2;
   job_coordinator()->Register(
       GURL("http://www.example.com/two/"),
-      GURL("http://www.example.com/service_worker.js"),
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &called2, &original_registration2));
+      GURL("http://www.example.com/service_worker.js"), NULL,
+      SaveRegistration(SERVICE_WORKER_OK, runner2, &called2,
+                       &original_registration2));
 
   EXPECT_FALSE(called1);
   EXPECT_FALSE(called2);
-  base::RunLoop().RunUntilIdle();
+  runner1->Run();
+  runner2->Run();
   EXPECT_TRUE(called2);
   EXPECT_TRUE(called1);
 
   scoped_refptr<ServiceWorkerRegistration> registration1;
   storage()->FindRegistrationForDocument(
       GURL("http://www.example.com/one/"),
       SaveFoundRegistration(SERVICE_WORKER_OK, &called1, &registration1));
   scoped_refptr<ServiceWorkerRegistration> registration2;
   storage()->FindRegistrationForDocument(
       GURL("http://www.example.com/two/"),
@@ skipping 85 matching lines @@
   ASSERT_FALSE(old_registration->HasOneRef());
 
   scoped_refptr<ServiceWorkerRegistration> new_registration_by_pattern =
       FindRegistrationForPattern(pattern);
 
   ASSERT_EQ(new_registration, old_registration);
 }
 
 class FailToStartWorkerTestHelper : public EmbeddedWorkerTestHelper {
  public:
-  explicit FailToStartWorkerTestHelper(int mock_render_process_id)
-      : EmbeddedWorkerTestHelper(base::FilePath(), mock_render_process_id) {}
+  explicit FailToStartWorkerTestHelper()
+      : EmbeddedWorkerTestHelper(base::FilePath()) {}
 
   void OnStartWorker(int embedded_worker_id,
                      int64 service_worker_version_id,
                      const GURL& scope,
                      const GURL& script_url) override {
     EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
     registry()->OnWorkerStopped(worker->process_id(), embedded_worker_id);
   }
 };
 
 TEST_F(ServiceWorkerJobTest, Register_FailToStartWorker) {
-  helper_.reset(new FailToStartWorkerTestHelper(render_process_id_));
+  helper_.reset(new FailToStartWorkerTestHelper());
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       RunRegisterJob(GURL("http://www.example.com/"),
                      GURL("http://www.example.com/service_worker.js"),
                      SERVICE_WORKER_ERROR_START_WORKER_FAILED);
 
   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(NULL), registration);
 }
 
 // Register and then unregister the pattern, in parallel. Job coordinator should
 // process jobs until the last job.
 TEST_F(ServiceWorkerJobTest, ParallelRegUnreg) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
   bool registration_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration;
   job_coordinator()->Register(
-      pattern,
-      script_url,
-      NULL,
-      SaveRegistration(SERVICE_WORKER_OK, &registration_called, &registration));
+      pattern, script_url, NULL,
+      SaveRegistration(SERVICE_WORKER_OK, runner, &registration_called,
+                       &registration));
 
   bool unregistration_called = false;
   job_coordinator()->Unregister(
       pattern,
       SaveUnregistration(SERVICE_WORKER_OK, &unregistration_called));
 
   ASSERT_FALSE(registration_called);
   ASSERT_FALSE(unregistration_called);
+  runner->Run();
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(registration_called);
   ASSERT_TRUE(unregistration_called);
 
   registration = FindRegistrationForPattern(pattern,
                                             SERVICE_WORKER_ERROR_NOT_FOUND);
 
   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration);
 }
 
 // Register conflicting scripts for the same pattern. The most recent
 // registration should win, and the old registration should have been
 // shutdown.
 TEST_F(ServiceWorkerJobTest, ParallelRegNewScript) {
   GURL pattern("http://www.example.com/");
 
   GURL script_url1("http://www.example.com/service_worker1.js");
+  scoped_refptr<MessageLoopRunner> runner1(new MessageLoopRunner);
   bool registration1_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration1;
   job_coordinator()->Register(
-      pattern,
-      script_url1,
-      NULL,
-      SaveRegistration(
-          SERVICE_WORKER_OK, &registration1_called, &registration1));
+      pattern, script_url1, NULL,
+      SaveRegistration(SERVICE_WORKER_OK, runner1, &registration1_called,
+                       &registration1));
 
   GURL script_url2("http://www.example.com/service_worker2.js");
+  scoped_refptr<MessageLoopRunner> runner2(new MessageLoopRunner);
   bool registration2_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration2;
   job_coordinator()->Register(
-      pattern,
-      script_url2,
-      NULL,
-      SaveRegistration(
-          SERVICE_WORKER_OK, &registration2_called, &registration2));
+      pattern, script_url2, NULL,
+      SaveRegistration(SERVICE_WORKER_OK, runner2, &registration2_called,
+                       &registration2));
 
   ASSERT_FALSE(registration1_called);
   ASSERT_FALSE(registration2_called);
-  base::RunLoop().RunUntilIdle();
+  runner1->Run();
+  runner2->Run();
   ASSERT_TRUE(registration1_called);
   ASSERT_TRUE(registration2_called);
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       FindRegistrationForPattern(pattern);
 
   ASSERT_EQ(registration2, registration);
 }
 
 // Register the exact same pattern + script. Requests should be
 // coalesced such that both callers get the exact same registration
 // object.
 TEST_F(ServiceWorkerJobTest, ParallelRegSameScript) {
   GURL pattern("http://www.example.com/");
 
   GURL script_url("http://www.example.com/service_worker1.js");
+  scoped_refptr<MessageLoopRunner> runner1(new MessageLoopRunner);
   bool registration1_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration1;
   job_coordinator()->Register(
-      pattern,
-      script_url,
-      NULL,
-      SaveRegistration(
-          SERVICE_WORKER_OK, &registration1_called, &registration1));
+      pattern, script_url, NULL,
+      SaveRegistration(SERVICE_WORKER_OK, runner1, &registration1_called,
+                       &registration1));
 
+  scoped_refptr<MessageLoopRunner> runner2(new MessageLoopRunner);
   bool registration2_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration2;
   job_coordinator()->Register(
-      pattern,
-      script_url,
-      NULL,
-      SaveRegistration(
-          SERVICE_WORKER_OK, &registration2_called, &registration2));
+      pattern, script_url, NULL,
+      SaveRegistration(SERVICE_WORKER_OK, runner2, &registration2_called,
+                       &registration2));
 
   ASSERT_FALSE(registration1_called);
   ASSERT_FALSE(registration2_called);
-  base::RunLoop().RunUntilIdle();
+  runner1->Run();
+  runner2->Run();
   ASSERT_TRUE(registration1_called);
   ASSERT_TRUE(registration2_called);
 
   ASSERT_EQ(registration1, registration2);
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       FindRegistrationForPattern(pattern);
 
   ASSERT_EQ(registration, registration1);
 }
@@ skipping 29 matching lines @@
 
   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration);
 }
 
 TEST_F(ServiceWorkerJobTest, AbortAll_Register) {
   GURL pattern1("http://www1.example.com/");
   GURL pattern2("http://www2.example.com/");
   GURL script_url1("http://www1.example.com/service_worker.js");
   GURL script_url2("http://www2.example.com/service_worker.js");
 
+  scoped_refptr<MessageLoopRunner> runner1(new MessageLoopRunner);
   bool registration_called1 = false;
   scoped_refptr<ServiceWorkerRegistration> registration1;
   job_coordinator()->Register(
-      pattern1,
-      script_url1,
-      NULL,
-      SaveRegistration(SERVICE_WORKER_ERROR_ABORT,
+      pattern1, script_url1, NULL,
+      SaveRegistration(SERVICE_WORKER_ERROR_ABORT, runner1,
                        &registration_called1, &registration1));
 
+  scoped_refptr<MessageLoopRunner> runner2(new MessageLoopRunner);
   bool registration_called2 = false;
   scoped_refptr<ServiceWorkerRegistration> registration2;
   job_coordinator()->Register(
-      pattern2,
-      script_url2,
-      NULL,
-      SaveRegistration(SERVICE_WORKER_ERROR_ABORT,
+      pattern2, script_url2, NULL,
+      SaveRegistration(SERVICE_WORKER_ERROR_ABORT, runner2,
                        &registration_called2, &registration2));
 
   ASSERT_FALSE(registration_called1);
   ASSERT_FALSE(registration_called2);
   job_coordinator()->AbortAll();
 
-  base::RunLoop().RunUntilIdle();
+  runner1->Run();
+  runner2->Run();
   ASSERT_TRUE(registration_called1);
   ASSERT_TRUE(registration_called2);
 
   bool find_called1 = false;
   storage()->FindRegistrationForPattern(
       pattern1,
       SaveFoundRegistration(
           SERVICE_WORKER_ERROR_NOT_FOUND, &find_called1, &registration1));
 
   bool find_called2 = false;
@@ skipping 32 matching lines @@
 
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(unregistration_called1);
   ASSERT_TRUE(unregistration_called2);
 }
 
 TEST_F(ServiceWorkerJobTest, AbortAll_RegUnreg) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
   bool registration_called = false;
   scoped_refptr<ServiceWorkerRegistration> registration;
   job_coordinator()->Register(
-      pattern,
-      script_url,
-      NULL,
-      SaveRegistration(SERVICE_WORKER_ERROR_ABORT,
-                       &registration_called, &registration));
+      pattern, script_url, NULL,
+      SaveRegistration(SERVICE_WORKER_ERROR_ABORT, runner, &registration_called,
+                       &registration));
 
   bool unregistration_called = false;
   job_coordinator()->Unregister(
       pattern,
       SaveUnregistration(SERVICE_WORKER_ERROR_ABORT,
                          &unregistration_called));
 
   ASSERT_FALSE(registration_called);
   ASSERT_FALSE(unregistration_called);
   job_coordinator()->AbortAll();
 
+  runner->Run();
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(registration_called);
   ASSERT_TRUE(unregistration_called);
 
   registration = FindRegistrationForPattern(pattern,
                                             SERVICE_WORKER_ERROR_NOT_FOUND);
 
   EXPECT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration);
 }
 
 // Tests that the waiting worker enters the 'redundant' state upon
 // unregistration.
 TEST_F(ServiceWorkerJobTest, UnregisterWaitingSetsRedundant) {
   GURL script_url("http://www.example.com/service_worker.js");
   scoped_refptr<ServiceWorkerRegistration> registration =
       RunRegisterJob(GURL("http://www.example.com/"), script_url);
   ASSERT_TRUE(registration.get());
 
   // Manually create the waiting worker since there is no way to become a
   // waiting worker until Update is implemented.
   scoped_refptr<ServiceWorkerVersion> version = new ServiceWorkerVersion(
       registration.get(), script_url, 1L, helper_->context()->AsWeakPtr());
   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();
   ASSERT_EQ(SERVICE_WORKER_OK, status);
 
   version->SetStatus(ServiceWorkerVersion::INSTALLED);
   registration->SetWaitingVersion(version);
   EXPECT_EQ(ServiceWorkerVersion::RUNNING,
             version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::INSTALLED, version->status());
 
   RunUnregisterJob(GURL("http://www.example.com/"));
 
@@ skipping 115 matching lines @@
     int64 registration_id;
     ChangedVersionAttributesMask mask;
     ServiceWorkerRegistrationInfo info;
   };
 
   struct StateChangeLogEntry {
     int64 version_id;
     ServiceWorkerVersion::Status status;
   };
 
-  UpdateJobTestHelper(int mock_render_process_id)
-      : EmbeddedWorkerTestHelper(base::FilePath(), mock_render_process_id),
-        update_found_(false) {}
+  UpdateJobTestHelper()
+      : EmbeddedWorkerTestHelper(base::FilePath()), update_found_(false) {}
   ~UpdateJobTestHelper() override {
     if (registration_.get())
       registration_->RemoveListener(this);
   }
 
   ServiceWorkerStorage* storage() { return context()->storage(); }
   ServiceWorkerJobCoordinator* job_coordinator() {
     return context()->job_coordinator();
   }
 
   scoped_refptr<ServiceWorkerRegistration> SetupInitialRegistration(
       const GURL& test_origin) {
     scoped_refptr<ServiceWorkerRegistration> registration;
+    scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
     bool called = false;
     job_coordinator()->Register(
-        test_origin.Resolve(kScope),
-        test_origin.Resolve(kScript),
-        NULL,
-        SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
-    base::RunLoop().RunUntilIdle();
+        test_origin.Resolve(kScope), test_origin.Resolve(kScript), NULL,
+        SaveRegistration(SERVICE_WORKER_OK, runner, &called, &registration));
+    runner->Run();
     EXPECT_TRUE(called);
     EXPECT_TRUE(registration.get());
     EXPECT_TRUE(registration->active_version());
     EXPECT_FALSE(registration->installing_version());
     EXPECT_FALSE(registration->waiting_version());
     registration_ = registration;
     return registration;
   }
 
   // EmbeddedWorkerTestHelper overrides
@@ skipping 49 matching lines @@
     attribute_change_log_.push_back(entry);
   }
 
   void OnRegistrationFailed(ServiceWorkerRegistration* registration) override {
     NOTREACHED();
   }
 
   void OnUpdateFound(ServiceWorkerRegistration* registration) override {
     ASSERT_FALSE(update_found_);
     update_found_ = true;
+    if (wait_for_update_runner_)
+      wait_for_update_runner_->Quit();
   }
 
   // ServiceWorkerVersion::Listener overrides
   void OnVersionStateChanged(ServiceWorkerVersion* version) override {
     StateChangeLogEntry entry;
     entry.version_id = version->version_id();
     entry.status = version->status();
     state_change_log_.push_back(entry);
+    if (wait_for_state_change_runner_)
+      wait_for_state_change_runner_->Quit();
   }
 
   scoped_refptr<ServiceWorkerRegistration> registration_;
 
   std::vector<AttributeChangeLogEntry> attribute_change_log_;
   std::vector<StateChangeLogEntry> state_change_log_;
   bool update_found_;
+  scoped_refptr<MessageLoopRunner> wait_for_update_runner_;
+  scoped_refptr<MessageLoopRunner> wait_for_state_change_runner_;
 };
 
 // Helper class for update tests that evicts the active version when the update
 // worker is about to be started.
 class EvictIncumbentVersionHelper : public UpdateJobTestHelper {
  public:
-  EvictIncumbentVersionHelper(int mock_render_process_id)
-      : UpdateJobTestHelper(mock_render_process_id) {}
+  EvictIncumbentVersionHelper() : UpdateJobTestHelper() {}
   ~EvictIncumbentVersionHelper() override {}
 
   void OnStartWorker(int embedded_worker_id,
                      int64 version_id,
                      const GURL& scope,
                      const GURL& script) override {
     ServiceWorkerVersion* version = context()->GetLiveVersion(version_id);
     ServiceWorkerRegistration* registration =
         context()->GetLiveRegistration(version->registration_id());
     bool is_update = registration->active_version() &&
@@ skipping 11 matching lines @@
   void OnRegistrationFailed(ServiceWorkerRegistration* registration) override {
     registration_failed_ = true;
   }
 
   bool registration_failed_ = false;
 };
 
 }  // namespace
 
 TEST_F(ServiceWorkerJobTest, Update_NoChange) {
-  UpdateJobTestHelper* update_helper =
-      new UpdateJobTestHelper(render_process_id_);
+  UpdateJobTestHelper* update_helper = new UpdateJobTestHelper();
   helper_.reset(update_helper);
   scoped_refptr<ServiceWorkerRegistration> registration =
       update_helper->SetupInitialRegistration(kNoChangeOrigin);
   ASSERT_TRUE(registration.get());
   ASSERT_EQ(4u, update_helper->state_change_log_.size());
   EXPECT_EQ(ServiceWorkerVersion::INSTALLING,
             update_helper->state_change_log_[0].status);
   EXPECT_EQ(ServiceWorkerVersion::INSTALLED,
             update_helper->state_change_log_[1].status);
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATING,
             update_helper->state_change_log_[2].status);
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED,
             update_helper->state_change_log_[3].status);
   update_helper->state_change_log_.clear();
 
   // Run the update job.
+  update_helper->wait_for_state_change_runner_ = new MessageLoopRunner;
   registration->AddListener(update_helper);
   scoped_refptr<ServiceWorkerVersion> first_version =
       registration->active_version();
   first_version->StartUpdate();
+  update_helper->wait_for_state_change_runner_->Run();
   base::RunLoop().RunUntilIdle();
 
   // Verify results.
   ASSERT_TRUE(registration->active_version());
   EXPECT_EQ(first_version.get(), registration->active_version());
   EXPECT_FALSE(registration->installing_version());
   EXPECT_FALSE(registration->waiting_version());
   EXPECT_TRUE(update_helper->attribute_change_log_.empty());
   ASSERT_EQ(1u, update_helper->state_change_log_.size());
   EXPECT_NE(registration->active_version()->version_id(),
             update_helper->state_change_log_[0].version_id);
   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT,
             update_helper->state_change_log_[0].status);
   EXPECT_FALSE(update_helper->update_found_);
 }
 
 TEST_F(ServiceWorkerJobTest, Update_BumpLastUpdateCheckTime) {
   const base::Time kToday = base::Time::Now();
   const base::Time kYesterday =
       kToday - base::TimeDelta::FromDays(1) - base::TimeDelta::FromHours(1);
-  UpdateJobTestHelper* update_helper =
-      new UpdateJobTestHelper(render_process_id_);
+  UpdateJobTestHelper* update_helper = new UpdateJobTestHelper();
   helper_.reset(update_helper);
   scoped_refptr<ServiceWorkerRegistration> registration =
       update_helper->SetupInitialRegistration(kNoChangeOrigin);
 
   // Run an update where the last update check was less than 24 hours ago. The
   // check time shouldn't change, as we didn't bypass cache.
   registration->set_last_update_check(kToday);
   registration->active_version()->StartUpdate();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kToday, registration->last_update_check());
 
   // Run an update where the last update check was over 24 hours ago. The
   // check time should change, as the cache was bypassed.
   registration->set_last_update_check(kYesterday);
   registration->active_version()->StartUpdate();
   base::RunLoop().RunUntilIdle();
   EXPECT_LT(kYesterday, registration->last_update_check());
 }
 
 TEST_F(ServiceWorkerJobTest, Update_NewVersion) {
-  UpdateJobTestHelper* update_helper =
-      new UpdateJobTestHelper(render_process_id_);
+  UpdateJobTestHelper* update_helper = new UpdateJobTestHelper();
   helper_.reset(update_helper);
   scoped_refptr<ServiceWorkerRegistration> registration =
       update_helper->SetupInitialRegistration(kNewVersionOrigin);
   ASSERT_TRUE(registration.get());
   update_helper->state_change_log_.clear();
 
   // Run the update job.
+  update_helper->wait_for_update_runner_ = new MessageLoopRunner;
   registration->AddListener(update_helper);
   scoped_refptr<ServiceWorkerVersion> first_version =
       registration->active_version();
   first_version->StartUpdate();
+  update_helper->wait_for_update_runner_->Run();
   base::RunLoop().RunUntilIdle();
 
   // Verify results.
   ASSERT_TRUE(registration->active_version());
   EXPECT_NE(first_version.get(), registration->active_version());
   EXPECT_FALSE(registration->installing_version());
   EXPECT_FALSE(registration->waiting_version());
   ASSERT_EQ(3u, update_helper->attribute_change_log_.size());
 
   UpdateJobTestHelper::AttributeChangeLogEntry entry;
@@ skipping 87 matching lines @@
   // Verify the registration was not modified by the Update.
   EXPECT_EQ(active_version, registration->active_version());
   EXPECT_EQ(version.get(), registration->waiting_version());
   EXPECT_EQ(NULL, registration->installing_version());
 }
 
 // Test that update succeeds if the incumbent worker was evicted
 // during the update job (this can happen on disk cache failure).
 TEST_F(ServiceWorkerJobTest, Update_EvictedIncumbent) {
   EvictIncumbentVersionHelper* update_helper =
-      new EvictIncumbentVersionHelper(render_process_id_);
+      new EvictIncumbentVersionHelper();
   helper_.reset(update_helper);
   scoped_refptr<ServiceWorkerRegistration> registration =
       update_helper->SetupInitialRegistration(kNewVersionOrigin);
   ASSERT_TRUE(registration.get());
   update_helper->state_change_log_.clear();
 
   // Run the update job.
+  update_helper->wait_for_update_runner_ = new MessageLoopRunner;
   registration->AddListener(update_helper);
   scoped_refptr<ServiceWorkerVersion> first_version =
       registration->active_version();
   first_version->StartUpdate();
+  update_helper->wait_for_update_runner_->Run();
   base::RunLoop().RunUntilIdle();
 
   // Verify results.
   ASSERT_TRUE(registration->active_version());
   EXPECT_NE(first_version.get(), registration->active_version());
   EXPECT_FALSE(registration->installing_version());
   EXPECT_FALSE(registration->waiting_version());
   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, first_version->status());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED,
             registration->active_version()->status());
@@ skipping 210 matching lines @@
   // Verify the new version is activated.
   EXPECT_EQ(NULL, registration->installing_version());
   EXPECT_EQ(NULL, registration->waiting_version());
   EXPECT_EQ(third_version, registration->active_version());
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, third_version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, third_version->status());
 }
 
 class EventCallbackHelper : public EmbeddedWorkerTestHelper {
  public:
-  explicit EventCallbackHelper(int mock_render_process_id)
-      : EmbeddedWorkerTestHelper(base::FilePath(), mock_render_process_id),
+  explicit EventCallbackHelper()
+      : EmbeddedWorkerTestHelper(base::FilePath()),
         install_event_result_(blink::WebServiceWorkerEventResultCompleted),
         activate_event_result_(blink::WebServiceWorkerEventResultCompleted) {}
 
   void OnInstallEvent(int embedded_worker_id,
                       int request_id) override {
     if (!install_callback_.is_null())
       install_callback_.Run();
     SimulateSend(
         new ServiceWorkerHostMsg_InstallEventFinished(
             embedded_worker_id, request_id, install_event_result_));
@@ skipping 13 matching lines @@
   void set_activate_event_result(blink::WebServiceWorkerEventResult result) {
     activate_event_result_ = result;
   }
 private:
   base::Closure install_callback_;
   blink::WebServiceWorkerEventResult install_event_result_;
   blink::WebServiceWorkerEventResult activate_event_result_;
 };
 
 TEST_F(ServiceWorkerJobTest, RemoveControlleeDuringInstall) {
-  EventCallbackHelper* helper = new EventCallbackHelper(render_process_id_);
+  EventCallbackHelper* helper = new EventCallbackHelper();
   helper_.reset(helper);
 
   GURL pattern("http://www.example.com/one/");
   GURL script1("http://www.example.com/service_worker.js");
   GURL script2("http://www.example.com/service_worker.js?new");
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       RunRegisterJob(pattern, script1);
 
   // Add a controllee and queue an unregister to force the uninstalling state.
@@ skipping 19 matching lines @@
   EXPECT_EQ(NULL, registration->installing_version());
   EXPECT_EQ(NULL, registration->waiting_version());
   EXPECT_EQ(new_version, registration->active_version());
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, new_version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, new_version->status());
 
   EXPECT_EQ(registration, FindRegistrationForPattern(pattern));
 }
 
 TEST_F(ServiceWorkerJobTest, RemoveControlleeDuringRejectedInstall) {
-  EventCallbackHelper* helper = new EventCallbackHelper(render_process_id_);
+  EventCallbackHelper* helper = new EventCallbackHelper();
   helper_.reset(helper);
 
   GURL pattern("http://www.example.com/one/");
   GURL script1("http://www.example.com/service_worker.js");
   GURL script2("http://www.example.com/service_worker.js?new");
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       RunRegisterJob(pattern, script1);
 
   // Add a controllee and queue an unregister to force the uninstalling state.
@@ skipping 15 matching lines @@
   EXPECT_FALSE(registration->is_uninstalling());
   EXPECT_TRUE(registration->is_uninstalled());
 
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, old_version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, old_version->status());
 
   FindRegistrationForPattern(pattern, SERVICE_WORKER_ERROR_NOT_FOUND);
 }
 
 TEST_F(ServiceWorkerJobTest, RemoveControlleeDuringInstall_RejectActivate) {
-  EventCallbackHelper* helper = new EventCallbackHelper(render_process_id_);
+  EventCallbackHelper* helper = new EventCallbackHelper();
   helper_.reset(helper);
 
   GURL pattern("http://www.example.com/one/");
   GURL script1("http://www.example.com/service_worker.js");
   GURL script2("http://www.example.com/service_worker.js?new");
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       RunRegisterJob(pattern, script1);
 
   // Add a controllee and queue an unregister to force the uninstalling state.
@@ skipping 15 matching lines @@
   EXPECT_FALSE(registration->is_uninstalling());
   EXPECT_FALSE(registration->is_uninstalled());
 
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, old_version->running_status());
   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, old_version->status());
 
   FindRegistrationForPattern(pattern, SERVICE_WORKER_OK);
 }
 
 }  // namespace content