Revert "Revert "Make shell child processes slaves.""

shell/child_main.cc

 // Copyright 2014 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 <unistd.h>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "mojo/common/message_pump_mojo.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
-#include "mojo/edk/embedder/process_delegate.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
+#include "mojo/edk/embedder/slave_process_delegate.h"
 #include "mojo/public/cpp/system/core.h"
 #include "shell/child_controller.mojom.h"
 #include "shell/child_switches.h"
 #include "shell/init.h"
 #include "shell/native_application_support.h"
 
 namespace shell {
 namespace {
 
 // Blocker ---------------------------------------------------------------------
@@ skipping 38 matching lines @@
   base::Closure run_after_;
 
   DISALLOW_COPY_AND_ASSIGN(Blocker);
 };
 
 // AppContext ------------------------------------------------------------------
 
 class ChildControllerImpl;
 
 // Should be created and initialized on the main thread.
-class AppContext : public mojo::embedder::ProcessDelegate {
+class AppContext : public mojo::embedder::SlaveProcessDelegate {
  public:
   AppContext()
       : io_thread_("io_thread"), controller_thread_("controller_thread") {}
   ~AppContext() override {}
 
-  void Init() {
+  void Init(mojo::embedder::ScopedPlatformHandle platform_handle) {
     // Initialize Mojo before starting any threads.
     mojo::embedder::Init(
         make_scoped_ptr(new mojo::embedder::SimplePlatformSupport()));
 
     // Create and start our I/O thread.
     base::Thread::Options io_thread_options(base::MessageLoop::TYPE_IO, 0);
     CHECK(io_thread_.StartWithOptions(io_thread_options));
     io_runner_ = io_thread_.message_loop_proxy().get();
     CHECK(io_runner_.get());
 
     // Create and start our controller thread.
     base::Thread::Options controller_thread_options;
     controller_thread_options.message_loop_type =
         base::MessageLoop::TYPE_CUSTOM;
     controller_thread_options.message_pump_factory =
         base::Bind(&mojo::common::MessagePumpMojo::Create);
     CHECK(controller_thread_.StartWithOptions(controller_thread_options));
     controller_runner_ = controller_thread_.message_loop_proxy().get();
     CHECK(controller_runner_.get());
 
-    // TODO(vtl): This should be SLAVE, not NONE.
-    mojo::embedder::InitIPCSupport(mojo::embedder::ProcessType::NONE,
+    mojo::embedder::InitIPCSupport(mojo::embedder::ProcessType::SLAVE,
                                    controller_runner_, this, io_runner_,
-                                   mojo::embedder::ScopedPlatformHandle());
+                                   platform_handle.Pass());
   }
 
   void Shutdown() {
     Blocker blocker;
     shutdown_unblocker_ = blocker.GetUnblocker();
     controller_runner_->PostTask(
         FROM_HERE, base::Bind(&AppContext::ShutdownOnControllerThread,
                               base::Unretained(this)));
     blocker.Block();
   }
@@ skipping 12 matching lines @@
 
  private:
   void ShutdownOnControllerThread() {
     // First, destroy the controller.
     controller_.reset();
 
     // Next shutdown IPC. We'll unblock the main thread in OnShutdownComplete().
     mojo::embedder::ShutdownIPCSupport();
   }
 
-  // ProcessDelegate implementation.
+  // SlaveProcessDelegate implementation.
   void OnShutdownComplete() override {
     shutdown_unblocker_.Unblock(base::Closure());
   }
 
+  void OnMasterDisconnect() override {
+    // We've lost the connection to the master process. This is not recoverable.
+    LOG(ERROR) << "Disconnected from master";
+    _exit(1);
+  }
+
   base::Thread io_thread_;
   scoped_refptr<base::SingleThreadTaskRunner> io_runner_;
 
   base::Thread controller_thread_;
   scoped_refptr<base::SingleThreadTaskRunner> controller_runner_;
 
   // Accessed only on the controller thread.
   scoped_ptr<ChildControllerImpl> controller_;
 
   // Used to unblock the main thread on shutdown.
@@ skipping 39 matching lines @@
   }
 
   void Bind(mojo::ScopedMessagePipeHandle handle) {
     binding_.Bind(handle.Pass());
   }
 
   // |mojo::ErrorHandler| methods:
   void OnConnectionError() override {
     // A connection error means the connection to the shell is lost. This is not
     // recoverable.
-    LOG(ERROR) << "Connection error to the shell.";
+    LOG(ERROR) << "Connection error to the shell";
     _exit(1);
   }
 
   // |ChildController| methods:
   void StartApp(const mojo::String& app_path,
                 mojo::InterfaceRequest<mojo::Application> application_request,
                 const StartAppCallback& on_app_complete) override {
     DVLOG(2) << "ChildControllerImpl::StartApp(" << app_path << ", ...)";
     DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 48 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ChildControllerImpl);
 };
 
 }  // namespace
 }  // namespace shell
 
 int main(int argc, char** argv) {
   base::AtExitManager at_exit;
   base::CommandLine::Init(argc, argv);
+  const base::CommandLine& command_line =
+      *base::CommandLine::ForCurrentProcess();
 
   shell::InitializeLogging();
 
   // Make sure that we're really meant to be invoked as the child process.
-  CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kChildProcess));
 
-  mojo::embedder::ScopedPlatformHandle platform_channel =
+  CHECK(command_line.HasSwitch(switches::kChildConnectionId));
+  std::string child_connection_id =
+      command_line.GetSwitchValueASCII(switches::kChildConnectionId);
+  CHECK(!child_connection_id.empty());
+
+  mojo::embedder::ScopedPlatformHandle platform_handle =
       mojo::embedder::PlatformChannelPair::PassClientHandleFromParentProcess(
-          *base::CommandLine::ForCurrentProcess());
-  CHECK(platform_channel.is_valid());
+          command_line);
+  CHECK(platform_handle.is_valid());
 
   shell::AppContext app_context;
-  app_context.Init();
+  app_context.Init(platform_handle.Pass());
+
+  mojo::embedder::ScopedPlatformHandle platform_channel;
+  mojo::embedder::ConnectToMaster(child_connection_id, &platform_channel);
 
   shell::Blocker blocker;
   app_context.controller_runner()->PostTask(
       FROM_HERE,
       base::Bind(&shell::ChildControllerImpl::Init,
                  base::Unretained(&app_context),
                  base::Passed(&platform_channel), blocker.GetUnblocker()));
   // This will block, then run whatever the controller wants.
   blocker.Block();
 
   app_context.Shutdown();
 
   return 0;
 }