Hook embedded shell up to MojoShellConnection

mojo/shell/runner/child/runner_connection.cc

 // Copyright 2015 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 "mojo/shell/runner/child/runner_connection.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 78 matching lines @@
   ~RunnerConnectionImpl() override {
     controller_runner_->PostTask(
         FROM_HERE, base::Bind(&RunnerConnectionImpl::ShutdownOnControllerThread,
                               base::Unretained(this)));
     controller_thread_.Stop();
   }
 
   // Returns true if a connection to the runner has been established and
   // |request| has been modified, false if no connection was established.
   bool WaitForApplicationRequest(InterfaceRequest<mojom::ShellClient>* request,
-                                 ScopedMessagePipeHandle handle);
+                                 ScopedMessagePipeHandle handle,
+                                 bool exit_on_error);
 
   ChildControllerImpl* controller() const { return controller_.get(); }
 
   void set_controller(scoped_ptr<ChildControllerImpl> controller) {
     controller_ = std::move(controller);
   }
 
  private:
   void StartControllerThread() {
     base::Thread::Options controller_thread_options;
@@ skipping 24 matching lines @@
 
     // TODO(vtl): Pass in the result from |MainMain()|.
     on_app_complete_.Run(MOJO_RESULT_UNIMPLEMENTED);
   }
 
   // To be executed on the controller thread. Creates the |ChildController|,
   // etc.
   static void Create(RunnerConnectionImpl* connection,
                      const GotApplicationRequestCallback& callback,
                      ScopedMessagePipeHandle runner_handle,
-                     const Blocker::Unblocker& unblocker) {
+                     const Blocker::Unblocker& unblocker,
+                     bool exit_on_error) {
     DCHECK(connection);
     DCHECK(!connection->controller());
 
     scoped_ptr<ChildControllerImpl> impl(
-        new ChildControllerImpl(connection, callback, unblocker));
+        new ChildControllerImpl(connection, callback, unblocker,
+                                exit_on_error));
 
     impl->Bind(std::move(runner_handle));
 
     connection->set_controller(std::move(impl));
   }
 
   void Bind(ScopedMessagePipeHandle handle) {
     binding_.Bind(std::move(handle));
     binding_.set_connection_error_handler([this]() { OnConnectionError(); });
   }
 
   void OnConnectionError() {
     // A connection error means the connection to the shell is lost. This is not
     // recoverable.
     DLOG(ERROR) << "Connection error to the shell.";
-    _exit(1);
+    if (exit_on_error_) {
+      _exit(1);
+    } else if (on_app_complete_.is_null()) {
+      // If we failed before we could even get a ShellClient request from the
+      // shell, signal failure to the RunnerConnection, as it's still blocking
+      // on a response.
+      unblocker_.Unblock(
+          base::Bind(&ChildControllerImpl::ReturnApplicationRequestOnMainThread,
+                     callback_, nullptr));
+    }
   }
 
   // |mojom::ChildController| methods:
   void StartApp(InterfaceRequest<mojom::ShellClient> request,
                 const StartAppCallback& on_app_complete) override {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     on_app_complete_ = on_app_complete;
     unblocker_.Unblock(
         base::Bind(&ChildControllerImpl::ReturnApplicationRequestOnMainThread,
                    callback_, base::Passed(&request)));
   }
 
   void ExitNow(int32_t exit_code) override {
     DVLOG(2) << "ChildControllerImpl::ExitNow(" << exit_code << ")";
     _exit(exit_code);
   }
 
  private:
   ChildControllerImpl(RunnerConnectionImpl* connection,
                       const GotApplicationRequestCallback& callback,
-                      const Blocker::Unblocker& unblocker)
+                      const Blocker::Unblocker& unblocker,
+                      bool exit_on_error)
       : connection_(connection),
         callback_(callback),
         unblocker_(unblocker),
-        binding_(this) {}
+        binding_(this),
+        exit_on_error_(exit_on_error) {}
 
   static void ReturnApplicationRequestOnMainThread(
       const GotApplicationRequestCallback& callback,
       InterfaceRequest<mojom::ShellClient> request) {
     callback.Run(std::move(request));
   }
 
   base::ThreadChecker thread_checker_;
   RunnerConnectionImpl* const connection_;
   GotApplicationRequestCallback callback_;
   Blocker::Unblocker unblocker_;
   StartAppCallback on_app_complete_;
 
   Binding<ChildController> binding_;
 
+  bool exit_on_error_;
+
   DISALLOW_COPY_AND_ASSIGN(ChildControllerImpl);
 };
 
 bool RunnerConnectionImpl::WaitForApplicationRequest(
     InterfaceRequest<mojom::ShellClient>* request,
-    ScopedMessagePipeHandle handle) {
+    ScopedMessagePipeHandle handle,
+    bool exit_on_error) {
   // If a valid message pipe to the runner was not provided, look for one on the
   // command line.
   if (!handle.is_valid()) {
     edk::ScopedPlatformHandle platform_channel =
         edk::PlatformChannelPair::PassClientHandleFromParentProcess(
             *base::CommandLine::ForCurrentProcess());
     if (!platform_channel.is_valid())
       return false;
     edk::SetParentPipeHandle(std::move(platform_channel));
     std::string primordial_pipe_token =
         base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             switches::kPrimordialPipeToken);
     handle = edk::CreateChildMessagePipe(primordial_pipe_token);
   }
 
   DCHECK(handle.is_valid());
 
   Blocker blocker;
   controller_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &ChildControllerImpl::Create, base::Unretained(this),
-          base::Bind(&OnGotApplicationRequest, base::Unretained(request)),
-          base::Passed(&handle), blocker.GetUnblocker()));
+          base::Bind(&OnGotApplicationRequest, request), base::Passed(&handle),
+          blocker.GetUnblocker(), exit_on_error));
   blocker.Block();
 
-  return true;
+  return request->is_pending();
 }
 
 }  // namespace
 
 RunnerConnection::~RunnerConnection() {}
 
 // static
 RunnerConnection* RunnerConnection::ConnectToRunner(
     InterfaceRequest<mojom::ShellClient>* request,
-    ScopedMessagePipeHandle handle) {
+    ScopedMessagePipeHandle handle,
+    bool exit_on_error) {
   RunnerConnectionImpl* connection = new RunnerConnectionImpl;
-  if (!connection->WaitForApplicationRequest(request, std::move(handle))) {
+  if (!connection->WaitForApplicationRequest(
+      request, std::move(handle), exit_on_error)) {
     delete connection;
     return nullptr;
   }
   return connection;
 }
 
 RunnerConnection::RunnerConnection() {}
 
 }  // namespace shell
 }  // namespace mojo