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): Considering deprecating this since it takes |InterfacePtr|.

[viettrungluu, 2016/02/11 18:26:29]

Deprecating this sounds good. Logically, its interface is kind of busted, since
even if one wants an InterfacePtr one may actually want different async waiters
for the ptr versus the binding.

[vardhan, 2016/02/11 22:47:53]

oh true! but i guess this won't be a problem once we remove the InterfacePtr<>*
overload.

i'll make this TODO less of a question and address it in a following CL. 

+  // It would be nice to only accept |InterfaceHandle<>| so that |Binding<>|
+  // can abstract away details about the client's implementation.
   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?

[viettrungluu, 2016/02/11 18:26:29]

Ditto.

(Also, why are there two spaces after the ':'? To trigger my OCD?)

[vardhan, 2016/02/11 22:47:53]

Done.

   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_