Mojo C++ bindings: Generate InterfaceHandle<> instead of InterfacePtr<>.

services/native_support/process_impl.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 "services/native_support/process_impl.h"
 
 #include <fcntl.h>
 #include <stdio.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/process/launch.h"
 #include "base/process/process.h"
 #include "build/build_config.h"
+#include "mojo/public/cpp/bindings/interface_handle.h"
 #include "mojo/services/files/interfaces/types.mojom.h"
 #include "services/native_support/make_pty_pair.h"
 #include "services/native_support/process_controller_impl.h"
 #include "services/native_support/process_io_redirection.h"
 
+using mojo::files::FilePtr;
+
 namespace native_support {
 
 namespace {
 
 class SetsidPreExecDelegate : public base::LaunchOptions::PreExecDelegate {
  public:
   SetsidPreExecDelegate() {}
   ~SetsidPreExecDelegate() override {}
 
   void RunAsyncSafe() override {
@@ skipping 14 matching lines @@
                          mojo::ApplicationConnection* connection,
                          mojo::InterfaceRequest<Process> request)
     : worker_runner_(worker_runner.Pass()), binding_(this, request.Pass()) {}
 
 ProcessImpl::~ProcessImpl() {}
 
 void ProcessImpl::Spawn(
     mojo::Array<uint8_t> path,
     mojo::Array<mojo::Array<uint8_t>> argv,
     mojo::Array<mojo::Array<uint8_t>> envp,
-    mojo::files::FilePtr stdin_file,
-    mojo::files::FilePtr stdout_file,
-    mojo::files::FilePtr stderr_file,
+    mojo::InterfaceHandle<mojo::files::File> stdin_file,
+    mojo::InterfaceHandle<mojo::files::File> stdout_file,
+    mojo::InterfaceHandle<mojo::files::File> stderr_file,
     mojo::InterfaceRequest<ProcessController> process_controller,
     const SpawnCallback& callback) {
   std::vector<int> fds_to_inherit(3, -1);
 
   // stdin:
   base::ScopedFD stdin_fd;
   base::ScopedFD stdin_parent_fd;
   if (stdin_file) {
     int stdin_pipe_fds[2] = {-1, -1};
     CHECK_EQ(pipe(stdin_pipe_fds), 0);
@@ skipping 25 matching lines @@
     CHECK_EQ(pipe(stderr_pipe_fds), 0);
     stderr_fd.reset(stderr_pipe_fds[1]);
     stderr_parent_fd.reset(stderr_pipe_fds[0]);
   } else {
     stderr_fd.reset(HANDLE_EINTR(open("/dev/null", O_WRONLY)));
   }
   fds_to_inherit[STDERR_FILENO] = stderr_fd.get();
 
   std::unique_ptr<ProcessIORedirection> process_io_redirection(
       new ProcessIORedirectionForStdIO(
-          stdin_file.Pass(), stdout_file.Pass(), stderr_file.Pass(),
-          stdin_parent_fd.Pass(), stdout_parent_fd.Pass(),
-          stderr_parent_fd.Pass()));
+          FilePtr::Create(std::move(stdin_file)),
+          FilePtr::Create(std::move(stdout_file)),
+          FilePtr::Create(std::move(stderr_file)), stdin_parent_fd.Pass(),
+          stdout_parent_fd.Pass(), stderr_parent_fd.Pass()));
 
   SpawnImpl(path.Pass(), argv.Pass(), envp.Pass(),
             std::move(process_io_redirection), fds_to_inherit,
             process_controller.Pass(), callback);
 }
 
 void ProcessImpl::SpawnWithTerminal(
     mojo::Array<uint8_t> path,
     mojo::Array<mojo::Array<uint8_t>> argv,
     mojo::Array<mojo::Array<uint8_t>> envp,
-    mojo::files::FilePtr terminal_file,
+    mojo::InterfaceHandle<mojo::files::File> terminal_file,
     mojo::InterfaceRequest<ProcessController> process_controller,
     const SpawnWithTerminalCallback& callback) {
   DCHECK(terminal_file);
 
   std::vector<int> fds_to_inherit(3, -1);
 
   base::ScopedFD master_fd;
   base::ScopedFD slave_fd;
   int errno_value = 0;
   if (!MakePtyPair(&master_fd, &slave_fd, &errno_value)) {
     // TODO(vtl): Well, this is dumb (we should use errno_value).
     callback.Run(mojo::files::Error::UNKNOWN);
     return;
   }
 
   // stdin:
   base::ScopedFD stdin_fd(slave_fd.Pass());
   fds_to_inherit[STDIN_FILENO] = stdin_fd.get();
 
   // stdout:
   base::ScopedFD stdout_fd(HANDLE_EINTR(dup(stdin_fd.get())));
   fds_to_inherit[STDOUT_FILENO] = stdout_fd.get();
 
   // stderr:
   base::ScopedFD stderr_fd(HANDLE_EINTR(dup(stdin_fd.get())));
   fds_to_inherit[STDERR_FILENO] = stderr_fd.get();
 
   std::unique_ptr<ProcessIORedirection> process_io_redirection(
-      new ProcessIORedirectionForTerminal(terminal_file.Pass(),
-                                          master_fd.Pass()));
+      new ProcessIORedirectionForTerminal(
+          FilePtr::Create(std::move(terminal_file)), master_fd.Pass()));
 
   SpawnImpl(path.Pass(), argv.Pass(), envp.Pass(),
             std::move(process_io_redirection), fds_to_inherit,
             process_controller.Pass(), callback);
 }
 
 void ProcessImpl::SpawnImpl(
     mojo::Array<uint8_t> path,
     mojo::Array<mojo::Array<uint8_t>> argv,
     mojo::Array<mojo::Array<uint8_t>> envp,
@@ skipping 81 matching lines @@
     callback.Run(mojo::files::Error::UNKNOWN);
     return;
   }
 
   new ProcessControllerImpl(worker_runner_, process_controller.Pass(),
                             process.Pass(), std::move(process_io_redirection));
   callback.Run(mojo::files::Error::OK);
 }
 
 }  // namespace native_support