Replace remaining shell references with service manager

chrome/test/base/mojo_test_connector.cc

 // Copyright 2016 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 "chrome/test/base/mojo_test_connector.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
@@ skipping 20 matching lines @@
 
 using service_manager::mojom::Service;
 using service_manager::mojom::ServicePtr;
 
 namespace {
 
 const char kTestRunnerName[] = "exe:mash_browser_tests";
 const char kTestName[] = "service:content_browser";
 
 // BackgroundTestState maintains all the state necessary to bind the test to
-// mojo. This class is only used on the thread created by BackgroundShell.
+// mojo. This class is only used on the thread created by
+// BackgroundServiceManager.
 class BackgroundTestState {
  public:
   BackgroundTestState() : child_token_(mojo::edk::GenerateRandomToken()) {}
   ~BackgroundTestState() {}
 
   // Prepares the command line and other setup for connecting the test to mojo.
   // Must be paired with a call to ChildProcessLaunched().
   void Connect(base::CommandLine* command_line,
                service_manager::ServiceManager* service_manager,
                base::TestLauncher::LaunchOptions* test_launch_options) {
@@ skipping 62 matching lines @@
 
 // Called used destroy BackgroundTestState on the background thread.
 void DestroyBackgroundStateOnBackgroundThread(
     std::unique_ptr<BackgroundTestState> state,
     service_manager::ServiceManager* service_manager) {}
 
 // State created per test. Manages creation of the corresponding
 // BackgroundTestState and making sure processing runs on the right threads.
 class MojoTestState : public content::TestState {
  public:
-  explicit MojoTestState(service_manager::BackgroundShell* background_shell)
-      : background_shell_(background_shell) {}
+  explicit MojoTestState(
+      service_manager::BackgroundServiceManager* background_service_manager)
+      : background_service_manager_(background_service_manager) {}
 
   ~MojoTestState() override {
     DCHECK(background_state_);
     // BackgroundState needs to be destroyed on the background thread. We're
-    // guaranteed |background_shell_| has been created by the time we
+    // guaranteed |background_service_manager_| has been created by the time we
     // reach
-    // here as Init() blocks until |background_shell_| has been
+    // here as Init() blocks until |background_service_manager_| has been
     // created.
-    background_shell_->ExecuteOnServiceManagerThread(
+    background_service_manager_->ExecuteOnServiceManagerThread(
         base::Bind(&DestroyBackgroundStateOnBackgroundThread,
                    base::Passed(&background_state_)));
   }
 
   void Init(base::CommandLine* command_line,
             base::TestLauncher::LaunchOptions* test_launch_options) {
     base::WaitableEvent signal(base::WaitableEvent::ResetPolicy::MANUAL,
                                base::WaitableEvent::InitialState::NOT_SIGNALED);
-    background_shell_->ExecuteOnServiceManagerThread(base::Bind(
+    background_service_manager_->ExecuteOnServiceManagerThread(base::Bind(
         &MojoTestState::BindOnBackgroundThread, base::Unretained(this), &signal,
         command_line, test_launch_options));
     signal.Wait();
   }
 
  private:
   // content::TestState:
   void ChildProcessLaunched(base::ProcessHandle handle,
                             base::ProcessId pid) override {
     // This is called on a random thread. We need to ensure BackgroundTestState
     // is only called on the background thread, and we wait for
     // ChildProcessLaunchedOnBackgroundThread() to be run before continuing so
     // that |handle| is still valid.
     base::WaitableEvent signal(base::WaitableEvent::ResetPolicy::MANUAL,
                                base::WaitableEvent::InitialState::NOT_SIGNALED);
-    background_shell_->ExecuteOnServiceManagerThread(
+    background_service_manager_->ExecuteOnServiceManagerThread(
         base::Bind(&MojoTestState::ChildProcessLaunchedOnBackgroundThread,
                    base::Unretained(this), handle, pid, &signal));
     signal.Wait();
   }
 
   void ChildProcessLaunchedOnBackgroundThread(
       base::ProcessHandle handle,
       base::ProcessId pid,
       base::WaitableEvent* signal,
       service_manager::ServiceManager* service_manager) {
     background_state_->ChildProcessLaunched(handle, pid);
     signal->Signal();
   }
 
   void BindOnBackgroundThread(
       base::WaitableEvent* signal,
       base::CommandLine* command_line,
       base::TestLauncher::LaunchOptions* test_launch_options,
       service_manager::ServiceManager* service_manager) {
     background_state_.reset(new BackgroundTestState);
     background_state_->Connect(command_line, service_manager,
                                test_launch_options);
     signal->Signal();
   }
 
-  service_manager::BackgroundShell* background_shell_;
+  service_manager::BackgroundServiceManager* background_service_manager_;
   std::unique_ptr<BackgroundTestState> background_state_;
 
   DISALLOW_COPY_AND_ASSIGN(MojoTestState);
 };
 
 // The name in the manifest results in getting exe:mash_browser_tests used,
 // remap that to browser_tests.
 void RemoveMashFromBrowserTests(base::CommandLine* command_line) {
   base::FilePath exe_path(command_line->GetProgram());
 #if defined(OS_WIN)
@@ skipping 40 matching lines @@
 // static
 const char MojoTestConnector::kTestSwitch[] = "is_test";
 // static
 const char MojoTestConnector::kMashApp[] = "mash-app";
 
 MojoTestConnector::MojoTestConnector() {}
 
 service_manager::mojom::ServiceRequest MojoTestConnector::Init() {
   native_runner_delegate_ = base::MakeUnique<NativeRunnerDelegateImpl>();
 
-  std::unique_ptr<service_manager::BackgroundShell::InitParams> init_params(
-      new service_manager::BackgroundShell::InitParams);
+  std::unique_ptr<service_manager::BackgroundServiceManager::InitParams>
+      init_params(new service_manager::BackgroundServiceManager::InitParams);
   // When running in single_process mode chrome initializes the edk.
   init_params->init_edk = !base::CommandLine::ForCurrentProcess()->HasSwitch(
       content::kSingleProcessTestsFlag);
   init_params->native_runner_delegate = native_runner_delegate_.get();
-  background_shell_.Init(std::move(init_params));
-  return background_shell_.CreateServiceRequest(kTestRunnerName);
+  background_service_manager_.Init(std::move(init_params));
+  return background_service_manager_.CreateServiceRequest(kTestRunnerName);
 }
 
 MojoTestConnector::~MojoTestConnector() {}
 
 std::unique_ptr<content::TestState> MojoTestConnector::PrepareForTest(
     base::CommandLine* command_line,
     base::TestLauncher::LaunchOptions* test_launch_options) {
   std::unique_ptr<MojoTestState> test_state(
-      new MojoTestState(&background_shell_));
+      new MojoTestState(&background_service_manager_));
   test_state->Init(command_line, test_launch_options);
   return std::move(test_state);
 }