Adds the ability to run chromeos with mus

chrome/app/mash/mash_runner.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/app/mash/mash_runner.h"
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
@@ skipping 44 matching lines @@
 #include "ui/base/ui_base_paths.h"
 #include "ui/base/ui_base_switches.h"
 
 #if defined(OS_POSIX)
 #include <signal.h>
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/app/shutdown_signal_handlers_posix.h"
 #endif  // defined(OS_POSIX)
 
+#if defined(OS_CHROMEOS)
+#include "chrome/app/mash/chrome_mus_catalog.h"
+#endif
+
 using service_manager::mojom::ServiceFactory;
 
 namespace {
 
 // kProcessType used to identify child processes.
 const char* kMashChild = "mash-child";
 
 const char kChromeMashServiceName[] = "chrome_mash";
 
+// Name used for --mus. This is only applicable to ChromeOS. it is placed
+// outside of ifdefs to make code slightly more readable.
+const char kChromeMusServiceName[] = "chrome_mus";
+
 bool IsChild() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kProcessType) &&
          base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
              switches::kProcessType) == kMashChild;
 }
 
 void InitializeResources() {
   ui::RegisterPathProvider();
   const std::string locale =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kLang);
   // This loads the Chrome's resources (chrome_100_percent.pak etc.)
   ui::ResourceBundle::InitSharedInstanceWithLocale(
       locale, nullptr, ui::ResourceBundle::LOAD_COMMON_RESOURCES);
 }
 
 class ServiceProcessLauncherDelegateImpl
     : public service_manager::ServiceProcessLauncher::Delegate {
  public:
   ServiceProcessLauncherDelegateImpl() {}
   ~ServiceProcessLauncherDelegateImpl() override {}
 
  private:
   // service_manager::ServiceProcessLauncher::Delegate:
   void AdjustCommandLineArgumentsForTarget(
         const service_manager::Identity& target,
         base::CommandLine* command_line) override {
     if (target.name() == kChromeMashServiceName ||
+        target.name() == kChromeMusServiceName ||
         target.name() == content::mojom::kPackagedServicesServiceName) {
       base::FilePath exe_path;
       base::PathService::Get(base::FILE_EXE, &exe_path);
       command_line->SetProgram(exe_path);
     }
     if (target.name() != content::mojom::kPackagedServicesServiceName) {
       // If running anything other than the browser process, launch a mash
       // child process. The new process will execute MashRunner::RunChild().
       command_line->AppendSwitchASCII(switches::kProcessType, kMashChild);
 #if defined(OS_WIN)
       command_line->AppendArg(switches::kPrefetchArgumentOther);
 #endif
       return;
     }
 
     // When launching the browser process, ensure that we don't inherit the
-    // --mash flag so it proceeds with the normal content/browser startup path.
+    // the mash/mus flag so it proceeds with the normal content/browser startup
+    // path.
+    const bool is_mash = command_line->HasSwitch(switches::kMash);
     base::CommandLine::SwitchMap new_switches = command_line->GetSwitches();
     new_switches.erase(switches::kMash);
+    new_switches.erase(switches::kMus);
     *command_line = base::CommandLine(command_line->GetProgram());
     for (const std::pair<std::string, base::CommandLine::StringType>& sw :
          new_switches) {
       command_line->AppendSwitchNative(sw.first, sw.second);
     }
+    // Add kMusConfig so that launched processes know what config they are
+    // running in.
+    command_line->AppendSwitchASCII(switches::kMusConfig,
+                                    is_mash ? switches::kMash : switches::kMus);
   }
 
   DISALLOW_COPY_AND_ASSIGN(ServiceProcessLauncherDelegateImpl);
 };
 
 // Quits |run_loop| if the |identity| of the quitting service is critical to the
 // system (e.g. the window manager). Used in the main process.
 void OnInstanceQuitInMain(base::RunLoop* run_loop,
                           int* exit_value,
                           const service_manager::Identity& identity) {
@@ skipping 46 matching lines @@
   ipc_thread.Stop();
   base::TaskScheduler::GetInstance()->Shutdown();
   return exit_value;
 }
 
 int MashRunner::RunServiceManagerInMain() {
   // TODO(sky): refactor BackgroundServiceManager so can supply own context, we
   // shouldn't we using context as it has a lot of stuff we don't really want
   // in chrome.
   ServiceProcessLauncherDelegateImpl service_process_launcher_delegate;
+  const bool is_mash =
+      base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kMash);
+#if defined(OS_CHROMEOS)
+  service_manager::BackgroundServiceManager background_service_manager(
+      &service_process_launcher_delegate,
+      is_mash ? CreateChromeMashCatalog() : CreateChromeMusCatalog());
+#else
   service_manager::BackgroundServiceManager background_service_manager(
       &service_process_launcher_delegate, CreateChromeMashCatalog());
+#endif
   service_manager::mojom::ServicePtr service;
   service_manager::ServiceContext context(
       base::MakeUnique<mash::MashPackagedService>(),
       service_manager::mojom::ServiceRequest(&service));
   background_service_manager.RegisterService(
       service_manager::Identity(
-          kChromeMashServiceName, service_manager::mojom::kRootUserID),
+          is_mash ? kChromeMashServiceName : kChromeMusServiceName,
+          service_manager::mojom::kRootUserID),
       std::move(service), nullptr);
 
   // Quit the main process if an important child (e.g. window manager) dies.
   // On Chrome OS the OS-level session_manager will restart the main process.
   base::RunLoop run_loop;
   int exit_value = 0;
   background_service_manager.SetInstanceQuitCallback(
       base::Bind(&OnInstanceQuitInMain, &run_loop, &exit_value));
 
 #if defined(OS_POSIX)
   // Quit the main process in response to shutdown signals (like SIGTERM).
   // These signals are used by Linux distributions to request clean shutdown.
   // On Chrome OS the SIGTERM signal is sent by session_manager.
   InstallShutdownSignalHandlers(run_loop.QuitClosure(),
                                 base::ThreadTaskRunnerHandle::Get());
 #endif
 
   // Ping services that we know we want to launch on startup (UI service,
   // window manager, quick launch app).
   context.connector()->Connect(ui::mojom::kServiceName);
-  context.connector()->Connect(mash::common::GetWindowManagerServiceName());
-  context.connector()->Connect(mash::quick_launch::mojom::kServiceName);
   context.connector()->Connect(content::mojom::kPackagedServicesServiceName);
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kMash)) {
+    context.connector()->Connect(mash::common::GetWindowManagerServiceName());
+    context.connector()->Connect(mash::quick_launch::mojom::kServiceName);
+  }
 
   run_loop.Run();
 
   // |context| must be destroyed before the message loop.
   return exit_value;
 }
 
 int MashRunner::RunChild() {
   service_manager::WaitForDebuggerIfNecessary();
 
@@ skipping 75 matching lines @@
       command_line->GetSwitchValueASCII(switches::kWaitForDebugger)) {
     return;
   }
 
   // Include the pid as logging may not have been initialized yet (the pid
   // printed out by logging is wrong).
   LOG(WARNING) << "waiting for debugger to attach for service " << service_name
                << " pid=" << base::Process::Current().Pid();
   base::debug::WaitForDebugger(120, true);
 }