Make the shell work in multiprocess mode some apps.

shell/app_child_process.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 "shell/app_child_process.h"
 
+#include <unistd.h>
+
 #include "base/bind.h"
 #include "base/callback_helpers.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/process_delegate.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
 #include "mojo/public/cpp/system/core.h"
 #include "shell/app_child_process.mojom.h"
 #include "shell/dynamic_service_runner.h"
 
 namespace mojo {
 namespace shell {
 
 namespace {
 
 // Blocker ---------------------------------------------------------------------
 
 // Blocks a thread until another thread unblocks it, at which point it unblocks
 // and runs a closure provided by that thread.
 class Blocker {
  public:
   class Unblocker {
    public:
+    explicit Unblocker(Blocker* blocker = nullptr) : blocker_(blocker) {}
     ~Unblocker() {}
 
     void Unblock(base::Closure run_after) {
       DCHECK(blocker_);
       DCHECK(blocker_->run_after_.is_null());
       blocker_->run_after_ = run_after;
       blocker_->event_.Signal();
-      blocker_ = NULL;
+      blocker_ = nullptr;
     }
 
    private:
-    friend class Blocker;
-    Unblocker(Blocker* blocker) : blocker_(blocker) { DCHECK(blocker_); }
-
     Blocker* blocker_;
 
     // Copy and assign allowed.
   };
 
   Blocker() : event_(true, false) {}
   ~Blocker() {}
 
   void Block() {
     DCHECK(run_after_.is_null());
     event_.Wait();
     run_after_.Run();
   }
 
   Unblocker GetUnblocker() { return Unblocker(this); }
 
  private:
   base::WaitableEvent event_;
   base::Closure run_after_;
 
   DISALLOW_COPY_AND_ASSIGN(Blocker);
 };
 
 // AppContext ------------------------------------------------------------------
 
 class AppChildControllerImpl;
 
-static void DestroyController(scoped_ptr<AppChildControllerImpl> controller) {
-}
-
 // Should be created and initialized on the main thread.
-class AppContext {
+class AppContext : public embedder::ProcessDelegate {
  public:
   AppContext()
       : io_thread_("io_thread"), controller_thread_("controller_thread") {}
   ~AppContext() {}
 
   void Init() {
     // Initialize Mojo before starting any threads.
     embedder::Init(scoped_ptr<mojo::embedder::PlatformSupport>(
         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(&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.
+    embedder::InitIPCSupport(embedder::ProcessType::NONE, controller_runner_,
+                             this, io_runner_,
+                             embedder::ScopedPlatformHandle());
   }
 
   void Shutdown() {
+    Blocker blocker;
+    shutdown_unblocker_ = blocker.GetUnblocker();
     controller_runner_->PostTask(
-        FROM_HERE, base::Bind(&DestroyController, base::Passed(&controller_)));
+        FROM_HERE, base::Bind(&AppContext::ShutdownOnControllerThread,
+                              base::Unretained(this)));
+    blocker.Block();
   }
 
   base::SingleThreadTaskRunner* io_runner() const { return io_runner_.get(); }
 
   base::SingleThreadTaskRunner* controller_runner() const {
     return controller_runner_.get();
   }
 
   AppChildControllerImpl* controller() const { return controller_.get(); }
 
   void set_controller(scoped_ptr<AppChildControllerImpl> controller) {
     controller_ = controller.Pass();
   }
 
  private:
-  // Accessed only on the controller thread.
-  // IMPORTANT: This must be BEFORE |controller_thread_|, so that the controller
-  // thread gets joined (and thus |controller_| reset) before |controller_| is
-  // destroyed.
-  scoped_ptr<AppChildControllerImpl> controller_;
+  void ShutdownOnControllerThread() {
+    // First, destroy the controller.
+    controller_.reset();
+
+    // Next shutdown IPC. We'll unblock the main thread in OnShutdownComplete().
+    embedder::ShutdownIPCSupport();
+  }
+
+  // ProcessDelegate implementation.
+  void OnShutdownComplete() override {
+    shutdown_unblocker_.Unblock(base::Closure());
+  }
 
   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<AppChildControllerImpl> controller_;
+
+  // Used to unblock the main thread on shutdown.
+  Blocker::Unblocker shutdown_unblocker_;
+
   DISALLOW_COPY_AND_ASSIGN(AppContext);
 };
 
 // AppChildControllerImpl ------------------------------------------------------
 
 class AppChildControllerImpl : public AppChildController, public ErrorHandler {
  public:
   ~AppChildControllerImpl() override {
     DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 24 matching lines @@
 
     app_context->set_controller(impl.Pass());
   }
 
   void Bind(ScopedMessagePipeHandle handle) { binding_.Bind(handle.Pass()); }
 
   // |ErrorHandler| methods:
   void OnConnectionError() override {
     // A connection error means the connection to the shell is lost. This is not
     // recoverable.
-    CHECK(false) << "Connection error to the shell.";
+    LOG(ERROR) << "Connection error to the shell.";
+    _exit(1);
   }
 
   // |AppChildController| methods:
   void StartApp(const String& app_path,
                 bool clean_app_path,
                 InterfaceRequest<Application> application_request,
                 const StartAppCallback& on_app_complete) override {
     DVLOG(2) << "AppChildControllerImpl::StartApp(" << app_path << ", ...)";
     DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 70 matching lines @@
       base::Bind(&AppChildControllerImpl::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();
 }
 
 }  // namespace shell
 }  // namespace mojo