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

content/browser/background_sync/background_sync_manager_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_manager.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_monitor_source.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/browser_thread_impl.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_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "net/base/network_change_notifier.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
 const char kPattern1[] = "https://example.com/a";
 const char kPattern2[] = "https://example.com/b";
 const char kScript1[] = "https://example.com/a/script.js";
 const char kScript2[] = "https://example.com/b/script.js";
-const int kRenderProcessId = 99;
 
-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 161 matching lines @@
     sync_options_1_.network_state = NETWORK_STATE_ONLINE;
     sync_options_1_.power_state = POWER_STATE_AUTO;
 
     sync_options_2_.tag = "bar";
     sync_options_2_.periodicity = SYNC_ONE_SHOT;
     sync_options_2_.network_state = NETWORK_STATE_ONLINE;
     sync_options_2_.power_state = POWER_STATE_AUTO;
   }
 
   void SetUp() override {
-    helper_.reset(
-        new EmbeddedWorkerTestHelper(base::FilePath(), kRenderProcessId));
+    helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath()));
 
     power_monitor_source_ = new TestPowerSource();
     // power_monitor_ takes ownership of power_monitor_source.
     power_monitor_.reset(new base::PowerMonitor(
         scoped_ptr<base::PowerMonitorSource>(power_monitor_source_)));
 
     SetOnBatteryPower(false);
 
     SetupBackgroundSyncManager();
 
     // Wait for storage to finish initializing before registering service
     // workers.
     base::RunLoop().RunUntilIdle();
     RegisterServiceWorkers();
   }
 
   void RegisterServiceWorkers() {
-    bool called_1 = false;
-    bool called_2 = false;
+    scoped_refptr<MessageLoopRunner> runner_1(new MessageLoopRunner);
+    scoped_refptr<MessageLoopRunner> runner_2(new MessageLoopRunner);
     helper_->context()->RegisterServiceWorker(
         GURL(kPattern1), GURL(kScript1), NULL,
-        base::Bind(&RegisterServiceWorkerCallback, &called_1,
+        base::Bind(&RegisterServiceWorkerCallback, runner_1,
                    &sw_registration_id_1_));
 
     helper_->context()->RegisterServiceWorker(
         GURL(kPattern2), GURL(kScript2), NULL,
-        base::Bind(&RegisterServiceWorkerCallback, &called_2,
+        base::Bind(&RegisterServiceWorkerCallback, runner_2,
                    &sw_registration_id_2_));
-    base::RunLoop().RunUntilIdle();
-    EXPECT_TRUE(called_1);
-    EXPECT_TRUE(called_2);
+
+    runner_1->Run();
+    runner_2->Run();
 
     // Hang onto the registrations as they need to be "live" when
     // calling BackgroundSyncManager::Register.
     helper_->context_wrapper()->FindRegistrationForId(
         sw_registration_id_1_, GURL(kPattern1).GetOrigin(),
         base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_1_));
 
     helper_->context_wrapper()->FindRegistrationForId(
         sw_registration_id_2_, GURL(kPattern1).GetOrigin(),
         base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_2_));
@@ skipping 945 matching lines @@
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
 
   // Create a new manager which should fire the sync again on init.
   SetupBackgroundSyncManager();
   InitSyncEventTest();
   EXPECT_FALSE(GetRegistration(sync_options_1_));
   EXPECT_EQ(2, sync_events_called_);
 }
 
 }  // namespace content