[mojo] Add GenericInterface_ to interface class variants

mojo/public/cpp/bindings/interface_ptr.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_INTERFACE_PTR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_PTR_H_
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "mojo/public/cpp/bindings/callback.h"
@@ skipping 14 matching lines @@
 // this class or the proxy should be from the same thread that created it. If
 // you need to move the proxy to a different thread, extract the
 // InterfacePtrInfo (containing just the message pipe and any version
 // information) using PassInterface(), pass it to a different thread, and
 // create and bind a new InterfacePtr from that thread.
 template <typename Interface>
 class InterfacePtr {
   DISALLOW_COPY_AND_ASSIGN_WITH_MOVE_FOR_BIND(InterfacePtr)
 
  public:
+  using GenericInterface = typename Interface::GenericInterface;
+
   // Constructs an unbound InterfacePtr.
   InterfacePtr() {}
   InterfacePtr(decltype(nullptr)) {}
 
   // Takes over the binding of another InterfacePtr.
   InterfacePtr(InterfacePtr&& other) {
     internal_state_.Swap(&other.internal_state_);
   }
 
   // Takes over the binding of another InterfacePtr, and closes any message pipe
@@ skipping 16 matching lines @@
 
   // Binds the InterfacePtr to a remote implementation of Interface. The
   // |waiter| is used for receiving notifications when there is data to read
   // from the message pipe. For most callers, the default |waiter| will be
   // sufficient.
   //
   // Calling with an invalid |info| (containing an invalid message pipe handle)
   // has the same effect as reset(). In this case, the InterfacePtr is not
   // considered as bound.
   void Bind(
-      InterfacePtrInfo<Interface> info,
+      InterfacePtrInfo<GenericInterface> info,
       const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
     reset();
     if (info.is_valid())
       internal_state_.Bind(info.Pass(), waiter);
   }
 
   // Returns whether or not this InterfacePtr is bound to a message pipe.
   bool is_bound() const { return internal_state_.is_bound(); }
 
   // Returns a raw pointer to the local proxy. Caller does not take ownership.
@@ skipping 68 matching lines @@
   //
   // It is an error to call PassInterface() while:
   //   - there are pending responses; or
   //     TODO: fix this restriction, it's not always obvious when there is a
   //     pending response.
   //   - there are 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.
-  InterfacePtrInfo<Interface> PassInterface() {
+  InterfacePtrInfo<GenericInterface> PassInterface() {
     CHECK(!HasAssociatedInterfaces());
     CHECK(!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:
   //   - this object is not bound; or
@@ skipping 44 matching lines @@
     const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
   InterfacePtr<Interface> ptr;
   if (info.is_valid())
     ptr.Bind(info.Pass(), waiter);
   return ptr.Pass();
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_PTR_H_