Mus Browser Tests

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 18 matching lines @@
 #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 kTestRunnerName[] = "mash_browser_tests";
+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)
       : background_service_manager_(background_service_manager),
         weak_factory_(this) {}
   ~MojoTestState() override {}
 
   void Init(base::CommandLine* command_line,
-            base::TestLauncher::LaunchOptions* test_launch_options) {
+            base::TestLauncher::LaunchOptions* test_launch_options,
+            const std::string& mus_config_switch) {
     command_line->AppendSwitch(MojoTestConnector::kTestSwitch);
     command_line->AppendSwitch(switches::kChildProcess);
-    command_line->AppendSwitchASCII(switches::kMusConfig, switches::kMash);
+    command_line->AppendSwitchASCII(switches::kMusConfig, mus_config_switch);
 
     platform_channel_ = base::MakeUnique<mojo::edk::PlatformChannelPair>();
 
     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)
     CHECK(false) << "Launching mojo process with inherit_handles is insecure!";
@@ skipping 77 matching lines @@
   command_line->SetProgram(exe_path);
 }
 
 }  // namespace
 
 // ServiceProcessLauncher::Delegate that makes exe:mash_browser_tests to
 // exe:browser_tests and removes '--run-in-mash'.
 class MojoTestConnector::ServiceProcessLauncherDelegateImpl
     : public service_manager::ServiceProcessLauncher::Delegate {
  public:
-  ServiceProcessLauncherDelegateImpl() {}
+  explicit ServiceProcessLauncherDelegateImpl(
+      const std::string& test_runner_name)
+      : test_runner_name_(test_runner_name) {}
   ~ServiceProcessLauncherDelegateImpl() override {}
 
  private:
   // service_manager::ServiceProcessLauncherDelegate:
   void AdjustCommandLineArgumentsForTarget(
       const service_manager::Identity& target,
       base::CommandLine* command_line) override {
     if (target.name() != content::mojom::kPackagedServicesServiceName) {
-      if (target.name() == kTestRunnerName) {
+      if (target.name() == test_runner_name_) {
         RemoveMashFromBrowserTests(command_line);
         command_line->SetProgram(
             base::CommandLine::ForCurrentProcess()->GetProgram());
       }
       command_line->AppendSwitch(MojoTestConnector::kMashApp);
       return;
     }
 
     base::CommandLine::StringVector argv(command_line->argv());
     auto iter =
         std::find(argv.begin(), argv.end(), FILE_PATH_LITERAL("--run-in-mash"));
     if (iter != argv.end())
       argv.erase(iter);
     *command_line = base::CommandLine(argv);
   }
 
+  const std::string test_runner_name_;
+
   DISALLOW_COPY_AND_ASSIGN(ServiceProcessLauncherDelegateImpl);
 };
 
 // static
 const char MojoTestConnector::kTestSwitch[] = "is_test";
 // static
 const char MojoTestConnector::kMashApp[] = "mash-app";
 
 MojoTestConnector::MojoTestConnector(
-    std::unique_ptr<base::Value> catalog_contents)
-    : service_process_launcher_delegate_(
-          new ServiceProcessLauncherDelegateImpl),
+    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() {
   // 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::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_));
   background_service_manager_->RegisterService(
-      service_manager::Identity(kTestRunnerName,
+      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) {
   auto test_state =
       base::MakeUnique<MojoTestState>(background_service_manager_.get());
-  test_state->Init(command_line, test_launch_options);
+  test_state->Init(command_line, test_launch_options,
+                   config_ == MojoTestConnector::Config::MASH ? switches::kMash
+                                                              : switches::kMus);
   return test_state;
 }