Have mash_browser_tests recreate BackgroundServiceManager per test

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"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/service_names.mojom.h"
 #include "content/public/test/test_launcher.h"
+#include "mash/session/public/interfaces/constants.mojom.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/pending_process_connection.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/scoped_ipc_support.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "services/catalog/store.h"
 #include "services/service_manager/background/background_service_manager.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/service_manager/public/cpp/service.h"
 #include "services/service_manager/public/cpp/service_context.h"
 #include "services/service_manager/runner/common/client_util.h"
 #include "services/service_manager/runner/common/switches.h"
 #include "services/service_manager/runner/host/service_process_launcher.h"
 #include "services/service_manager/service_manager.h"
 #include "services/service_manager/switches.h"
 
 namespace {
 
 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:
-  explicit MojoTestState(
-      service_manager::BackgroundServiceManager* background_service_manager,
-      base::CommandLine* command_line,
-      base::TestLauncher::LaunchOptions* test_launch_options,
-      const std::string& mus_config_switch,
-      base::OnceClosure on_process_launched)
-      : background_service_manager_(background_service_manager),
+  MojoTestState(MojoTestConnector* connector,
+                base::CommandLine* command_line,
+                base::TestLauncher::LaunchOptions* test_launch_options,
+                const std::string& mus_config_switch,
+                base::OnceClosure on_process_launched)
+      : connector_(connector),
         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)
@@ skipping 28 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) {
-    background_service_manager_->RegisterService(
+    connector_->InitBackgroundServiceManager();
+    service_manager::BackgroundServiceManager* background_service_manager =
+        connector_->background_service_manager();
+    background_service_manager->RegisterService(
         service_manager::Identity(content::mojom::kPackagedServicesServiceName,
                                   service_manager::mojom::kRootUserID),
         std::move(service_),
         service_manager::mojom::PIDReceiverRequest(&pid_receiver_));
 
     DCHECK(pid_receiver_.is_bound());
     pid_receiver_->SetPID(pid);
     pid_receiver_.reset();
 
     std::move(on_process_launched_).Run();
   }
 
   mojo::edk::PendingProcessConnection process_connection_;
-  service_manager::BackgroundServiceManager* const background_service_manager_;
+  MojoTestConnector* connector_;
 
   // 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_;
 
@@ skipping 67 matching lines @@
 MojoTestConnector::MojoTestConnector(
     std::unique_ptr<base::Value> catalog_contents,
     Config config)
     : config_(config),
       service_process_launcher_delegate_(new ServiceProcessLauncherDelegateImpl(
           config == MojoTestConnector::Config::MASH ? kMashTestRunnerName
                                                     : kMusTestRunnerName)),
       background_service_manager_(nullptr),
       catalog_contents_(std::move(catalog_contents)) {}
 
-service_manager::mojom::ServiceRequest MojoTestConnector::Init() {
+void MojoTestConnector::Init() {

[sky, 2017/05/04 02:49:49]

When multiple tests are run at a time, how many times is this called? It seems
like it's only called once, but I could be wrong.

[jonross, 2017/05/04 13:41:41]

This will be only called once.

MashTestLauncherDelegate::PreRunTest is called N times (once per test)
The first call of this builds MojoTestConnector and calls Init once. This gives
us the mojo environment we need.

N MojoTestStates are made, creating the pipe handles for each test. Which is
sent to them via command line as they are forked.

MojoTestConnector::InitBackgroundServerManager will eventually be ran N times.
However it only runs once per test. When the test case connects.

   // In single-process test mode, browser code will initialize the EDK and IPC.
   // Otherwise we ensure it's initialized here.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           content::kSingleProcessTestsFlag)) {
     mojo::edk::Init();
     ipc_thread_ = base::MakeUnique<base::Thread>("IPC thread");
     ipc_thread_->StartWithOptions(base::Thread::Options(
         base::MessageLoop::TYPE_IO, 0));
     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;
   service_manager::mojom::ServiceRequest request(&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(),
-          std::move(catalog_contents_));
+          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;
 }
 
 MojoTestConnector::~MojoTestConnector() {}
 
 std::unique_ptr<content::TestState> MojoTestConnector::PrepareForTest(
     base::CommandLine* command_line,
     base::TestLauncher::LaunchOptions* test_launch_options,
     base::OnceClosure on_process_launched) {
   return base::MakeUnique<MojoTestState>(
-      background_service_manager_.get(), command_line, test_launch_options,
+      this, command_line, test_launch_options,
       config_ == MojoTestConnector::Config::MASH ? switches::kMash
                                                  : switches::kMus,
       std::move(on_process_launched));
 }
 
 void MojoTestConnector::StartService(const std::string& service_name) {
   background_service_manager_->StartService(service_manager::Identity(
       service_name, service_manager::mojom::kRootUserID));
 }