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

examples/native_run_app/native_run_app.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.
 
 // This is a terminal client (i.e., a "raw" |mojo.terminal.Terminal| -- e.g.,
 // moterm -- can be asked to talk to this) that prompts the user for a native
 // (Linux) binary to run and then does so (via mojo:native_support).
 //
 // E.g., first run mojo:moterm_example_app (embedded by a window manager). Then,
 // at the prompt, enter "mojo:native_run_app". At the next prompt, enter "bash"
 // (or "echo hello mojo").
 //
 // TODO(vtl): Maybe it should optionally be able to extract the binary path (and
 // args) from the connection URL?
 
 #include <string.h>
 
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_split.h"
 #include "mojo/application/application_runner_chromium.h"
 #include "mojo/public/c/system/main.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
@@ skipping 10 matching lines @@
 using mojo::terminal::TerminalClient;
 
 mojo::Array<uint8_t> ToByteArray(const std::string& s) {
   auto rv = mojo::Array<uint8_t>::New(s.size());
   memcpy(rv.data(), s.data(), s.size());
   return rv;
 }
 
 class TerminalConnection {
  public:
-  explicit TerminalConnection(mojo::files::FilePtr terminal,
+  explicit TerminalConnection(mojo::InterfaceHandle<mojo::files::File> terminal,
                               native_support::Process* native_support_process)
-      : terminal_(terminal.Pass()),
+      : terminal_(mojo::files::FilePtr::Create(std::move(terminal))),
         native_support_process_(native_support_process) {
     terminal_.set_connection_error_handler([this]() { delete this; });
     Start();
   }
   ~TerminalConnection() {}
 
  private:
   void Write(const char* s, mojo::files::File::WriteCallback callback) {
     size_t length = strlen(s);
     auto a = mojo::Array<uint8_t>::New(length);
@@ skipping 87 matching lines @@
     }
 
     // Now, we can spawn.
     mojo::Array<mojo::Array<uint8_t>> argv;
     for (const auto& arg : command_line_)
       argv.push_back(ToByteArray(arg));
 
     // TODO(vtl): If the |InterfacePtr| underlying |native_support_process_|
     // encounters an error, then we're sort of dead in the water.
     native_support_process_->SpawnWithTerminal(
-        ToByteArray(command_line_[0]), argv.Pass(), nullptr, terminal_.Pass(),
-        GetProxy(&process_controller_), [this](mojo::files::Error error) {
+        ToByteArray(command_line_[0]), argv.Pass(), nullptr,
+        terminal_.PassInterfaceHandle(), GetProxy(&process_controller_),
+        [this](mojo::files::Error error) {
           this->DidSpawnWithTerminal(error);
         });
     process_controller_.set_connection_error_handler([this]() { delete this; });
   }
   void DidSpawnWithTerminal(mojo::files::Error error) {
     if (error != mojo::files::Error::OK) {
       LOG(ERROR) << "SpawnWithTerminal() error: " << error;
       delete this;
       return;
     }
@@ skipping 23 matching lines @@
 
 class TerminalClientImpl : public TerminalClient {
  public:
   TerminalClientImpl(mojo::InterfaceRequest<TerminalClient> request,
                      native_support::Process* native_support_process)
       : binding_(this, request.Pass()),
         native_support_process_(native_support_process) {}
   ~TerminalClientImpl() override {}
 
   // |TerminalClient| implementation:
-  void ConnectToTerminal(mojo::files::FilePtr terminal) override {
+  void ConnectToTerminal(
+      mojo::InterfaceHandle<mojo::files::File> terminal) override {
     if (terminal) {
       // Owns itself.
-      new TerminalConnection(terminal.Pass(), native_support_process_);
+      new TerminalConnection(std::move(terminal), native_support_process_);
     } else {
       LOG(ERROR) << "No terminal";
     }
   }
 
  private:
   mojo::StrongBinding<TerminalClient> binding_;
   native_support::Process* native_support_process_;
 
   DISALLOW_COPY_AND_ASSIGN(TerminalClientImpl);
@@ skipping 29 matching lines @@
   mojo::ApplicationImpl* application_impl_;
   native_support::ProcessPtr native_support_process_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeRunApp);
 };
 
 MojoResult MojoMain(MojoHandle application_request) {
   mojo::ApplicationRunnerChromium runner(new NativeRunApp());
   return runner.Run(application_request);
 }