[mojo] Add Mojo bindings support for IPC::ParamTraits

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 "base/macros.h"
 #include "mojo/public/c/environment/async_waiter.h"
 #include "mojo/public/cpp/bindings/callback.h"
@@ skipping 41 matching lines @@
 // However, the caller may provide their own implementation if needed. The
 // |Binding| will not take ownership of the waiter, and the waiter must outlive
 // the |Binding|. The provided waiter must be able to signal the implementation
 // which generally means it needs to be able to schedule work on the thread the
 // implementation runs on. If writing library code that has to work on different
 // types of threads callers may need to provide different waiter
 // implementations.
 template <typename Interface>
 class Binding {
  public:
+  using GenericInterface_ = typename Interface::GenericInterface_;
+
   // Constructs an incomplete binding that will use the implementation |impl|.
   // The binding may be completed with a subsequent call to the |Bind| method.
   // Does not take ownership of |impl|, which must outlive the binding.
   explicit Binding(Interface* impl) : internal_state_(impl) {}
 
   // Constructs a completed binding of message pipe |handle| to implementation
   // |impl|. Does not take ownership of |impl|, which must outlive the binding.
   // See class comment for definition of |waiter|.
   Binding(Interface* impl,
           ScopedMessagePipeHandle handle,
           const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter())
       : 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|.
   Binding(Interface* impl,
-          InterfacePtr<Interface>* ptr,
+          InterfacePtr<GenericInterface_>* ptr,
           const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter())
       : Binding(impl) {
     Bind(ptr, 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,
+          InterfaceRequest<GenericInterface_> request,
           const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter())
       : Binding(impl) {
     Bind(request.PassMessagePipe(), waiter);
   }
 
   // Tears down the binding, closing the message pipe and leaving the interface
   // implementation unbound.
   ~Binding() {}
 
   // Completes a binding that was constructed with only an interface
   // implementation. Takes ownership of |handle| and binds it to the previously
   // specified implementation. See class comment for definition of |waiter|.
   void Bind(
       ScopedMessagePipeHandle handle,
       const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
     internal_state_.Bind(handle.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(
-      InterfacePtr<Interface>* ptr,
+      InterfacePtr<GenericInterface_>* ptr,
       const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
     MessagePipe pipe;
     ptr->Bind(
         InterfacePtrInfo<Interface>(pipe.handle0.Pass(), Interface::Version_),
         waiter);
     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,
+      InterfaceRequest<GenericInterface_> request,
       const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
     Bind(request.PassMessagePipe(), waiter);
   }
 
   // Whether there are any associated interfaces running on the pipe currently.
   bool HasAssociatedInterfaces() const {
     return internal_state_.HasAssociatedInterfaces();
   }
 
   // Stops processing incoming messages until
@@ skipping 33 matching lines @@
   // implementation. Put this object into a state where it can be rebound to a
   // new pipe.
   //
   // This method may only be called if the object has been bound to a message
   // pipe and there are no associated interfaces running.
   //
   // TODO(yzshen): For now, users need to make sure there is no one holding
   // on to associated interface endpoint handles at both sides of the
   // message pipe in order to call this method. We need a way to forcefully
   // invalidate associated interface endpoint handles.
-  InterfaceRequest<Interface> Unbind() {
+  InterfaceRequest<GenericInterface_> Unbind() {
     CHECK(!HasAssociatedInterfaces());
     return internal_state_.Unbind();
   }
 
   // Sets an error handler that will be called if a connection error occurs on
   // the bound message pipe.
   void set_connection_error_handler(const Closure& error_handler) {
     internal_state_.set_connection_error_handler(error_handler);
   }
 
@@ skipping 25 matching lines @@
  private:
   internal::BindingState<Interface, Interface::PassesAssociatedKinds_>
       internal_state_;
 
   DISALLOW_COPY_AND_ASSIGN(Binding);
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_BINDING_H_