Replace ChildController with ShellClientFactory

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>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/message_pump/message_pump_mojo.h"
 #include "mojo/public/cpp/bindings/binding.h"
-#include "mojo/shell/runner/child/child_controller.mojom.h"
+#include "mojo/shell/public/interfaces/shell_client_factory.mojom.h"
 #include "mojo/shell/runner/common/switches.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 
 // Blocks a thread until another thread unblocks it, at which point it unblocks
 // and runs a closure provided by that thread.
 class Blocker {
  public:
@@ skipping 85 matching lines @@
 
   base::Thread controller_thread_;
   scoped_refptr<base::SingleThreadTaskRunner> controller_runner_;
 
   // Accessed only on the controller thread.
   scoped_ptr<ChildControllerImpl> controller_;
 
   DISALLOW_COPY_AND_ASSIGN(RunnerConnectionImpl);
 };
 
-class ChildControllerImpl : public mojom::ChildController {
+class ChildControllerImpl : public mojom::ShellClientFactory {
  public:
   ~ChildControllerImpl() override {
     DCHECK(thread_checker_.CalledOnValidThread());
-
-    // 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,
                      bool exit_on_error) {
     DCHECK(connection);
@@ skipping 12 matching lines @@
     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.";
     if (exit_on_error_) {
       _exit(1);
-    } else if (on_app_complete_.is_null()) {
+    } else {
       // 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 {
+  // |mojom::ShellClientFactory| methods:
+  void CreateShellClient(mojom::ShellClientRequest request,
+                         const String& name) 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,
                       bool exit_on_error)
       : connection_(connection),
         callback_(callback),
         unblocker_(unblocker),
         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_;
+  Binding<mojom::ShellClientFactory> binding_;
 
   bool exit_on_error_;
 
   DISALLOW_COPY_AND_ASSIGN(ChildControllerImpl);
 };
 
 bool RunnerConnectionImpl::WaitForApplicationRequest(
     InterfaceRequest<mojom::ShellClient>* request,
     ScopedMessagePipeHandle handle,
     bool exit_on_error) {
@@ skipping 41 matching lines @@
     delete connection;
     return nullptr;
   }
   return connection;
 }
 
 RunnerConnection::RunnerConnection() {}
 
 }  // namespace shell
 }  // namespace mojo