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

content/browser/background_sync/background_sync_service_impl_unittest.cc

 // Copyright 2015 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/background_sync/background_sync_service_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_monitor_source.h"
 #include "base/run_loop.h"
 #include "content/browser/background_sync/background_sync_context_impl.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "net/base/network_change_notifier.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
 const char kServiceWorkerPattern[] = "https://example.com/a";
 const char kServiceWorkerScript[] = "https://example.com/a/script.js";
-const int kRenderProcessId = 99;
 
 // Callbacks from SetUp methods
 
-void RegisterServiceWorkerCallback(bool* called,
-                                   int64* store_registration_id,
-                                   ServiceWorkerStatusCode status,
-                                   const std::string& status_message,
-                                   int64 registration_id) {
+void RegisterServiceWorkerCallback(
+    const scoped_refptr<MessageLoopRunner>& runner,
+    int64* store_registration_id,
+    ServiceWorkerStatusCode status,
+    const std::string& status_message,
+    int64 registration_id) {
   EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
-  *called = true;
   *store_registration_id = registration_id;
+  runner->Quit();
 }
 
 void FindServiceWorkerRegistrationCallback(
     scoped_refptr<ServiceWorkerRegistration>* out_registration,
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
   *out_registration = registration;
 }
 
@@ skipping 55 matching lines @@
   void TearDown() override {
     // This must be explicitly destroyed here to ensure that destruction
     // of both the BackgroundSyncContext and the BackgroundSyncManager occurs on
     // the correct thread.
     background_sync_context_ = nullptr;
   }
 
   // SetUp helper methods
   void CreateTestHelper() {
     embedded_worker_helper_.reset(
-        new EmbeddedWorkerTestHelper(base::FilePath(), kRenderProcessId));
+        new EmbeddedWorkerTestHelper(base::FilePath()));
   }
 
   void CreateBackgroundSyncContext() {
     power_monitor_.reset(
         new base::PowerMonitor(make_scoped_ptr(new MockPowerMonitorSource())));
 
     background_sync_context_ = new BackgroundSyncContextImpl();
     background_sync_context_->Init(embedded_worker_helper_->context_wrapper());
 
     // Tests do not expect the sync event to fire immediately after
     // register (and cleanup up the sync registrations).  Prevent the sync
     // event from firing by setting the network state to have no connection.
     // NOTE: The setup of the network connection must happen after the
     //       BackgroundSyncManager has been setup, including any asynchronous
     //       initialization.
     base::RunLoop().RunUntilIdle();
     net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
         net::NetworkChangeNotifier::CONNECTION_NONE);
     base::RunLoop().RunUntilIdle();
   }
 
   void CreateServiceWorkerRegistration() {
-    bool called = false;
+    scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner);
     embedded_worker_helper_->context()->RegisterServiceWorker(
         GURL(kServiceWorkerPattern), GURL(kServiceWorkerScript), NULL,
-        base::Bind(&RegisterServiceWorkerCallback, &called,
+        base::Bind(&RegisterServiceWorkerCallback, runner,
                    &sw_registration_id_));
-    base::RunLoop().RunUntilIdle();
-    EXPECT_TRUE(called);
+    runner->Run();
     embedded_worker_helper_->context_wrapper()->FindRegistrationForId(
         sw_registration_id_, GURL(kServiceWorkerPattern).GetOrigin(),
         base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(sw_registration_);
   }
 
   void CreateBackgroundSyncServiceImpl() {
     // Create a dummy mojo channel so that the BackgroundSyncServiceImpl can be
     // instantiated
@@ skipping 151 matching lines @@
   GetRegistrationsOneShot(base::Bind(&ErrorAndRegistrationListCallback,
                                      &getregistrations_called,
                                      &getregistrations_error, &array_size));
   EXPECT_TRUE(getregistrations_called);
   EXPECT_EQ(BackgroundSyncError::BACKGROUND_SYNC_ERROR_NONE,
             getregistrations_error);
   EXPECT_EQ(1UL, array_size);
 }
 
 }  // namespace content