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

mojo/public/cpp/bindings/binding.h

 // 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.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_BINDING_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_BINDING_H_
 
 #include <memory>
 #include <utility>
 
@@ skipping 64 matching lines @@
       : Binding(impl) {
     Bind(handle.Pass(), waiter);
   }
 
   // Constructs a completed binding of |impl| to a new message pipe, passing the
   // client end to |ptr|, which takes ownership of it. The caller is expected to
   // pass |ptr| on to the client of the service. Does not take ownership of any
   // of the parameters. |impl| must outlive the binding. |ptr| only needs to
   // last until the constructor returns. See class comment for definition of
   // |waiter|.
+  // TODO(vardhan): Deprecate this in favor of the |InterfaceHandle<>| overload
+  // below.
   Binding(Interface* impl,
           InterfacePtr<Interface>* ptr,
           const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter())
       : Binding(impl) {
     Bind(ptr, waiter);
   }
 
+  // Constructs a completed binding of |impl| to a new message pipe, passing the
+  // client end to |ptr|, which takes ownership of it. The caller is expected to
+  // pass |ptr| on to the client of the service. Does not take ownership of any
+  // of the parameters. |impl| must outlive the binding. |ptr| only needs to
+  // last until the constructor returns. See class comment for definition of
+  // |waiter|.
+  Binding(Interface* impl,
+          InterfaceHandle<Interface>* interface_handle,
+          const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter())
+      : Binding(impl) {
+    Bind(interface_handle, waiter);
+  }
+
   // Constructs a completed binding of |impl| to the message pipe endpoint in
   // |request|, taking ownership of the endpoint. Does not take ownership of
   // |impl|, which must outlive the binding. See class comment for definition of
   // |waiter|.
   Binding(Interface* impl,
           InterfaceRequest<Interface> request,
           const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter())
       : Binding(impl) {
     Bind(request.PassMessagePipe(), waiter);
   }
@@ skipping 22 matching lines @@
     internal_router_->set_connection_error_handler(
         [this]() { connection_error_handler_.Run(); });
   }
 
   // Completes a binding that was constructed with only an interface
   // implementation by creating a new message pipe, binding one end of it to the
   // previously specified implementation, and passing the other to |ptr|, which
   // takes ownership of it. The caller is expected to pass |ptr| on to the
   // eventual client of the service. Does not take ownership of |ptr|. See
   // class comment for definition of |waiter|.
+  // TODO(vardhan): Deprecate this in favor of the |InterfaceHandle<>| overload
+  // below.
   void Bind(
       InterfacePtr<Interface>* ptr,
       const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
     MessagePipe pipe;
     ptr->Bind(
         InterfaceHandle<Interface>(pipe.handle0.Pass(), Interface::Version_),
         waiter);
     Bind(pipe.handle1.Pass(), waiter);
   }
 
   // Completes a binding that was constructed with only an interface
+  // implementation by creating a new message pipe, binding one end of it to the
+  // previously specified implementation, and passing the other to |ptr|, which
+  // takes ownership of it. The caller is expected to pass |ptr| on to the
+  // eventual client of the service. Does not take ownership of |ptr|. See
+  // class comment for definition of |waiter|.
+  void Bind(
+      InterfaceHandle<Interface>* interface_handle,
+      const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
+    MessagePipe pipe;
+    *interface_handle =
+        InterfaceHandle<Interface>(pipe.handle0.Pass(), Interface::Version_);
+    Bind(pipe.handle1.Pass(), waiter);
+  }
+
+  // Completes a binding that was constructed with only an interface
   // implementation by removing the message pipe endpoint from |request| and
   // binding it to the previously specified implementation. See class comment
   // for definition of |waiter|.
   void Bind(
       InterfaceRequest<Interface> request,
       const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
     Bind(request.PassMessagePipe(), waiter);
   }
 
   // Blocks the calling thread until either a call arrives on the previously
@@ skipping 53 matching lines @@
   typename Interface::Stub_ stub_;
   Interface* impl_;
   Closure connection_error_handler_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(Binding);
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_BINDING_H_