Mojo C++ bindings: Rename InterfaceInfoPtr -> InterfaceHandle

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 <algorithm>
 #include <cstddef>
 
 #include "mojo/public/cpp/bindings/callback.h"
-#include "mojo/public/cpp/bindings/interface_ptr_info.h"
+#include "mojo/public/cpp/bindings/interface_handle.h"
 #include "mojo/public/cpp/bindings/lib/interface_ptr_internal.h"
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 
 // A pointer to a local proxy of a remote Interface implementation. Uses a
 // message pipe to communicate with the remote implementation, and automatically
 // closes the pipe and deletes the proxy on destruction. The pointer must be
 // bound to a message pipe before the interface methods can be called.
 //
 // This class is thread hostile, as is the local proxy it manages. All calls to
 // 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
+// InterfaceHandle (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 {
  public:
   // Constructs an unbound InterfacePtr.
   InterfacePtr() {}
   InterfacePtr(std::nullptr_t) {}
 
   // Takes over the binding of another InterfacePtr.
@@ skipping 21 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,
+      InterfaceHandle<Interface> 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 66 matching lines @@
   //
   // This method may only be called after the InterfacePtr has been bound to a
   // message pipe.
   void set_connection_error_handler(const Closure& error_handler) {
     internal_state_.set_connection_error_handler(error_handler);
   }
 
   // Unbinds the InterfacePtr and returns the information which could be used
   // to setup an InterfacePtr again. This method may be used to move the proxy
   // to a different thread (see class comments for details).
-  InterfacePtrInfo<Interface> PassInterface() {
+  InterfaceHandle<Interface> PassInterface() {
     State state;
     internal_state_.Swap(&state);
 
     return state.PassInterface();
   }
 
   // DO NOT USE. Exposed only for internal use and for testing.
   internal::InterfacePtrState<Interface>* internal_state() {
     return &internal_state_;
   }
 
  private:
   typedef internal::InterfacePtrState<Interface> State;
   mutable State internal_state_;
 
   MOJO_MOVE_ONLY_TYPE(InterfacePtr);
 };
 
 // If |info| is valid (containing a valid message pipe handle), returns an
 // InterfacePtr bound to it. Otherwise, returns an unbound InterfacePtr. The
 // specified |waiter| will be used as in the InterfacePtr::Bind() method.
 template <typename Interface>
 InterfacePtr<Interface> MakeProxy(
-    InterfacePtrInfo<Interface> info,
+    InterfaceHandle<Interface> info,
     const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
   InterfacePtr<Interface> ptr;
   if (info.is_valid())
     ptr.Bind(info.Pass(), waiter);
   return ptr;
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_PTR_H_