mash: Exit the root process if the window manager service crashes

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 14 matching lines @@
 #include "base/sys_info.h"
 #include "base/task_scheduler/task_scheduler.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread.h"
 #include "base/trace_event/trace_event.h"
 #include "chrome/app/mash/chrome_mash_catalog.h"
 #include "components/tracing/common/trace_to_console.h"
 #include "components/tracing/common/tracing_switches.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/service_names.mojom.h"
+#include "mash/common/config.h"
 #include "mash/package/mash_packaged_service.h"
-#include "mash/session/public/interfaces/constants.mojom.h"
+#include "mash/quick_launch/public/interfaces/constants.mojom.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/scoped_ipc_support.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/catalog/public/interfaces/catalog.mojom.h"
 #include "services/catalog/public/interfaces/constants.mojom.h"
 #include "services/service_manager/background/background_service_manager.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/service_manager/public/cpp/identity.h"
 #include "services/service_manager/public/cpp/service.h"
 #include "services/service_manager/public/cpp/service_context.h"
@@ skipping 104 matching lines @@
 MashRunner::MashRunner() {}
 
 MashRunner::~MashRunner() {}
 
 int MashRunner::Run() {
   base::TaskScheduler::CreateAndSetSimpleTaskScheduler(
       base::SysInfo::NumberOfProcessors());
 
   if (IsChild())
     return RunChild();
-  RunMain();
-  return 0;
+
+  return RunMain();
 }
 
-void MashRunner::RunMain() {
+int MashRunner::RunMain() {
   base::SequencedWorkerPool::EnableWithRedirectionToTaskSchedulerForProcess();
 
   mojo::edk::Init();
 
   base::Thread ipc_thread("IPC thread");
   ipc_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
   mojo::edk::ScopedIPCSupport ipc_support(
       ipc_thread.task_runner(),
       mojo::edk::ScopedIPCSupport::ShutdownPolicy::FAST);
 
+  RunServiceManagerInMain();
+
+  ipc_thread.Stop();
+  base::TaskScheduler::GetInstance()->Shutdown();
+  return main_return_value_;
+}
+
+void MashRunner::RunServiceManagerInMain() {
+  // Ensure run loop exists before instance quit callback is constructed.
+  main_run_loop_ = base::MakeUnique<base::RunLoop>();
+
   // 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;
   service_manager::BackgroundServiceManager background_service_manager(
       &service_process_launcher_delegate, CreateChromeMashCatalog());
   service_manager::mojom::ServicePtr service;
   context_.reset(new service_manager::ServiceContext(
       base::MakeUnique<mash::MashPackagedService>(),
       service_manager::mojom::ServiceRequest(&service)));
   background_service_manager.RegisterService(
       service_manager::Identity(
           kChromeMashServiceName, service_manager::mojom::kRootUserID),
       std::move(service), nullptr);
 
-  // Ping mash_session to ensure an instance is brought up
-  context_->connector()->Connect(mash::session::mojom::kServiceName);
-  base::RunLoop().Run();
+  // Quit the main process if an important child (e.g. window manager) dies.
+  background_service_manager.SetInstanceQuitCallback(
+      base::Bind(&MashRunner::OnInstanceQuitInMain, base::Unretained(this)));

[Ken Rockot(use gerrit already), 2017/01/31 23:33:28]

Instead of making the RunLoop and return values instance variables, I would just
make them locals and pass their addresses to OnInstanceQuitInMain. We know it's
safe because that function will never be called after the RunLoop quits, and the
RunLoop is run only within this function.

[Ken Rockot(use gerrit already), 2017/01/31 23:34:51]

Note: I just realized this would also mean there's no need to make
OnInstanceQuitInMain a member function. It can be a free-floating function or,
if you're feeling saucy, a lambda.

[James Cook, 2017/02/01 00:41:32]

Done and done. I used an anonymous function because the lambda was pretty
unreadable.

 
-  base::TaskScheduler::GetInstance()->Shutdown();
+  // Ping services that we know we want to launch on startup.
+  // TODO(jamescook): Start the window server / ui service explicitly.
+  context_->connector()->Connect(mash::common::GetWindowManagerServiceName());
+  context_->connector()->Connect(mash::quick_launch::mojom::kServiceName);
+
+  main_run_loop_->Run();
+
+  context_.reset();
+}
+
+void MashRunner::OnInstanceQuitInMain(
+    const service_manager::Identity& identity) {
+  // If the window manager goes down then exit the main process with an error.
+  // On Chrome OS the OS-level session_manager will restart the main process.
+  // TODO(jamescook): Also shut down if the window server dies.
+  if (identity.name() != mash::common::GetWindowManagerServiceName())
+    return;
+
+  if (!main_run_loop_->running())
+    return;
+
+  main_return_value_ = 1;
+  main_run_loop_->Quit();
 }
 
 int MashRunner::RunChild() {
   service_manager::WaitForDebuggerIfNecessary();
 
   base::i18n::InitializeICU();
   InitializeResources();
   service_manager::RunStandaloneService(
       base::Bind(&MashRunner::StartChildApp, base::Unretained(this)));
   return 0;
 }
 
 void MashRunner::StartChildApp(
     service_manager::mojom::ServiceRequest service_request) {
   // TODO(sad): Normally, this would be a TYPE_DEFAULT message loop. However,
   // TYPE_UI is needed for mojo:ui. But it is not known whether the child app is
   // going to be mojo:ui at this point. So always create a TYPE_UI message loop
   // for now.
   base::MessageLoop message_loop(base::MessageLoop::TYPE_UI);
+  base::RunLoop run_loop;
   context_.reset(new service_manager::ServiceContext(
       base::MakeUnique<mash::MashPackagedService>(),
       std::move(service_request)));
-  base::RunLoop().Run();
+  // Quit the child process if it loses its connection to service manager.
+  context_->SetConnectionLostClosure(run_loop.QuitClosure());
+  run_loop.Run();
 }
 
 int MashMain() {
 #if !defined(OFFICIAL_BUILD) && defined(OS_WIN)
   base::RouteStdioToConsole(false);
 #endif
   // TODO(sky): wire this up correctly.
   service_manager::InitializeLogging();
 
 #if defined(OS_LINUX)
@@ skipping 41 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);
 }