One BackgroundServerManager per MojoTestState

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 29 matching lines @@
 const char kMashTestRunnerName[] = "mash_browser_tests";
 const char kMusTestRunnerName[] = "mus_browser_tests";
 
 // State created per test to register a client process with the background
 // service manager.
 class MojoTestState : public content::TestState {
  public:
   MojoTestState(MojoTestConnector* connector,
                 base::CommandLine* command_line,
                 base::TestLauncher::LaunchOptions* test_launch_options,
-                const std::string& mus_config_switch,
-                base::OnceClosure on_process_launched)
+                const std::string& mus_config_switch)
       : connector_(connector),
+        background_service_manager_(nullptr),
         platform_channel_(base::MakeUnique<mojo::edk::PlatformChannelPair>()),
         main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-        on_process_launched_(std::move(on_process_launched)),
         weak_factory_(this) {
     command_line->AppendSwitch(MojoTestConnector::kTestSwitch);
     command_line->AppendSwitchASCII(switches::kMusConfig, mus_config_switch);
 
     platform_channel_->PrepareToPassClientHandleToChildProcess(
         command_line, &handle_passing_info_);
 #if defined(OS_WIN)
     test_launch_options->inherit_handles = true;
     test_launch_options->handles_to_inherit = &handle_passing_info_;
 #if defined(OFFICIAL_BUILD)
@@ skipping 26 matching lines @@
     main_task_runner_->PostTask(FROM_HERE,
                                 base::Bind(&MojoTestState::SetupService,
                                            weak_factory_.GetWeakPtr(), pid));
   }
 
   // Called on the main thread only.
   // This registers the services needed for the test. This is not done until
   // after ChildProcessLaunched as previous test runs will tear down existing
   // connections.
   void SetupService(base::ProcessId pid) {
-    connector_->InitBackgroundServiceManager();
-    service_manager::BackgroundServiceManager* background_service_manager =
-        connector_->background_service_manager();
-    background_service_manager->RegisterService(
+    service_manager::mojom::ServicePtr service;
+    auto request = mojo::MakeRequest(&service);
+
+    // BackgroundServiceManager must be created after mojo::edk::Init() as it
+    // attempts to create mojo pipes for the provided catalog on a separate
+    // thread.
+    background_service_manager_ =
+        connector_->CreateBackgroundServiceManager(std::move(service));
+    background_service_manager_->RegisterService(
         service_manager::Identity(content::mojom::kPackagedServicesServiceName,
                                   service_manager::mojom::kRootUserID),
         std::move(service_), mojo::MakeRequest(&pid_receiver_));
 
     DCHECK(pid_receiver_.is_bound());
     pid_receiver_->SetPID(pid);
     pid_receiver_.reset();
 
-    std::move(on_process_launched_).Run();
+    background_service_manager_->StartService(
+        service_manager::Identity(mash::session::mojom::kServiceName,
+                                  service_manager::mojom::kRootUserID));
   }
 
   mojo::edk::OutgoingBrokerClientInvitation broker_client_invitation_;
   MojoTestConnector* connector_;
+  std::unique_ptr<service_manager::BackgroundServiceManager>
+      background_service_manager_;
 
   // The ServicePtr must be created before child process launch so that the pipe
   // can be set on the command line. It is held until SetupService is called at
   // which point |background_service_manager_| takes over ownership.
   service_manager::mojom::ServicePtr service_;
 
   // NOTE: HandlePassingInformation must remain valid through process launch,
   // hence it lives here instead of within Init()'s stack.
   mojo::edk::HandlePassingInformation handle_passing_info_;
 
   std::unique_ptr<mojo::edk::PlatformChannelPair> platform_channel_;
   service_manager::mojom::PIDReceiverPtr pid_receiver_;
   const scoped_refptr<base::TaskRunner> main_task_runner_;
-  base::OnceClosure on_process_launched_;
 
   base::WeakPtrFactory<MojoTestState> weak_factory_;
 
   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());
@@ skipping 72 matching lines @@
     ipc_support_ = base::MakeUnique<mojo::edk::ScopedIPCSupport>(
         ipc_thread_->task_runner(),
         mojo::edk::ScopedIPCSupport::ShutdownPolicy::FAST);
   }
 }
 
 service_manager::mojom::ServiceRequest
 MojoTestConnector::InitBackgroundServiceManager() {
   service_manager::mojom::ServicePtr service;
   auto request = mojo::MakeRequest(&service);
+  background_service_manager_ =
+      CreateBackgroundServiceManager(std::move(service));
+  return request;
+}
 
+std::unique_ptr<service_manager::BackgroundServiceManager>
+MojoTestConnector::CreateBackgroundServiceManager(
+    service_manager::mojom::ServicePtr service) {
   // BackgroundServiceManager must be created after mojo::edk::Init() as it
   // attempts to create mojo pipes for the provided catalog on a separate
   // thread.
-  background_service_manager_ =
-      base::MakeUnique<service_manager::BackgroundServiceManager>(
-          service_process_launcher_delegate_.get(),
-          catalog_contents_->CreateDeepCopy());
-  background_service_manager_->RegisterService(
+  std::unique_ptr<service_manager::BackgroundServiceManager>
+      background_service_manager =
+          base::MakeUnique<service_manager::BackgroundServiceManager>(
+              service_process_launcher_delegate_.get(),
+              catalog_contents_->CreateDeepCopy());
+  background_service_manager->RegisterService(
       service_manager::Identity(config_ == MojoTestConnector::Config::MASH
                                     ? kMashTestRunnerName
                                     : kMusTestRunnerName,
                                 service_manager::mojom::kRootUserID),
       std::move(service), nullptr);
-  return request;
+
+  return background_service_manager;
 }
 
 MojoTestConnector::~MojoTestConnector() {}
 
 std::unique_ptr<content::TestState> MojoTestConnector::PrepareForTest(
     base::CommandLine* command_line,
-    base::TestLauncher::LaunchOptions* test_launch_options,
-    base::OnceClosure on_process_launched) {
+    base::TestLauncher::LaunchOptions* test_launch_options) {
   return base::MakeUnique<MojoTestState>(
       this, command_line, test_launch_options,
       config_ == MojoTestConnector::Config::MASH ? switches::kMash
-                                                 : switches::kMus,
-      std::move(on_process_launched));
+                                                 : switches::kMus);
 }
 
 void MojoTestConnector::StartService(const std::string& service_name) {
   background_service_manager_->StartService(service_manager::Identity(
       service_name, service_manager::mojom::kRootUserID));
 }