[mojo] Add GenericInterface_ to interface class variants

mojo/public/cpp/bindings/associated_interface_ptr.h

 // 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.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_INTERFACE_PTR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_INTERFACE_PTR_H_
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "mojo/public/cpp/bindings/associated_group.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
 #include "mojo/public/cpp/bindings/associated_interface_request.h"
 #include "mojo/public/cpp/bindings/callback.h"
 #include "mojo/public/cpp/bindings/lib/associated_interface_ptr_state.h"
 
 namespace mojo {
 
 // Represents the client side of an associated interface. It is similar to
 // InterfacePtr, except that it doesn't own a message pipe handle.
 template <typename Interface>
 class AssociatedInterfacePtr {
   DISALLOW_COPY_AND_ASSIGN_WITH_MOVE_FOR_BIND(AssociatedInterfacePtr)
 
  public:
+  using GenericInterface = typename Interface::GenericInterface;
+
   // Constructs an unbound AssociatedInterfacePtr.
   AssociatedInterfacePtr() {}
   AssociatedInterfacePtr(decltype(nullptr)) {}
 
   AssociatedInterfacePtr(AssociatedInterfacePtr&& other) {
     internal_state_.Swap(&other.internal_state_);
   }
 
   AssociatedInterfacePtr& operator=(AssociatedInterfacePtr&& other) {
     reset();
@@ skipping 10 matching lines @@
 
   ~AssociatedInterfacePtr() {}
 
   // Sets up this object as the client side of an associated interface.
   // Calling with an invalid |info| has the same effect as reset(). In this
   // case, the AssociatedInterfacePtr is not considered as bound.
   //
   // NOTE: Please see the comments of
   // AssociatedGroup.CreateAssociatedInterface() about when you can use this
   // object to make calls.
-  void Bind(AssociatedInterfacePtrInfo<Interface> info) {
+  void Bind(AssociatedInterfacePtrInfo<GenericInterface> info) {
     reset();
 
     bool is_local =
         internal::AssociatedInterfacePtrInfoHelper::GetHandle(&info).is_local();
 
     DCHECK(is_local) << "The AssociatedInterfacePtrInfo is supposed to be used "
                         "at the other side of the message pipe.";
 
     if (info.is_valid() && is_local)
       internal_state_.Bind(info.Pass());
@@ skipping 47 matching lines @@
     internal_state_.set_connection_error_handler(error_handler);
   }
 
   // Unbinds and returns the associated interface pointer information which
   // could be used to setup an AssociatedInterfacePtr again. This method may be
   // used to move the proxy to a different thread.
   //
   // It is an error to call PassInterface() while there are pending responses.
   // TODO: fix this restriction, it's not always obvious when there is a
   // pending response.
-  AssociatedInterfacePtrInfo<Interface> PassInterface() {
+  AssociatedInterfacePtrInfo<GenericInterface> PassInterface() {
     DCHECK(!internal_state_.has_pending_callbacks());
     State state;
     internal_state_.Swap(&state);
 
     return state.PassInterface();
   }
 
   // Returns the associated group that this object belongs to. Returns null if
   // the object is not bound.
   AssociatedGroup* associated_group() {
@@ skipping 32 matching lines @@
 // Creates an associated interface. The output |ptr| should be used locally
 // while the returned request should be passed through the message pipe endpoint
 // referred to by |associated_group| to setup the corresponding asssociated
 // interface implementation at the remote side.
 //
 // NOTE: |ptr| should NOT be used to make calls before the request is sent.
 // Violating that will cause the message pipe to be closed. On the other hand,
 // as soon as the request is sent, |ptr| is usable. There is no need to wait
 // until the request is bound to an implementation at the remote side.
 template <typename Interface>
-AssociatedInterfaceRequest<Interface> GetProxy(
+AssociatedInterfaceRequest<typename Interface::GenericInterface> GetProxy(
     AssociatedInterfacePtr<Interface>* ptr,
     AssociatedGroup* group) {
-  AssociatedInterfaceRequest<Interface> request;
-  AssociatedInterfacePtrInfo<Interface> ptr_info;
+  AssociatedInterfaceRequest<typename Interface::GenericInterface> request;
+  AssociatedInterfacePtrInfo<typename Interface::GenericInterface> ptr_info;
   group->CreateAssociatedInterface(AssociatedGroup::WILL_PASS_REQUEST,
                                    &ptr_info, &request);
 
   ptr->Bind(ptr_info.Pass());
   return request.Pass();
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_INTERFACE_PTR_H_