Revert of Deletes mojo::Callback

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 <stdint.h>
 #include <utility>
 
-#include "base/callback.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.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 {
  public:
   // Constructs an unbound AssociatedInterfacePtr.
@@ skipping 55 matching lines @@
 
   // Returns the version number of the interface that the remote side supports.
   uint32_t version() const { return internal_state_.version(); }
 
   // Returns the internal interface ID of this associated interface.
   uint32_t interface_id() const { return internal_state_.interface_id(); }
 
   // Queries the max version that the remote side supports. On completion, the
   // result will be returned as the input of |callback|. The version number of
   // this object will also be updated.
-  void QueryVersion(const base::Callback<void(uint32_t)>& callback) {
+  void QueryVersion(const Callback<void(uint32_t)>& callback) {
     internal_state_.QueryVersion(callback);
   }
 
   // If the remote side doesn't support the specified version, it will close the
   // associated interface asynchronously. This does nothing if it's already
   // known that the remote side supports the specified version, i.e., if
   // |version <= this->version()|.
   //
   // After calling RequireVersion() with a version not supported by the remote
   // side, all subsequent calls to interface methods will be ignored.
   void RequireVersion(uint32_t version) {
     internal_state_.RequireVersion(version);
   }
 
   // Closes the associated interface (if any) and returns the pointer to the
   // unbound state.
   void reset() {
     State doomed;
     internal_state_.Swap(&doomed);
   }
 
   // Indicates whether an error has been encountered. If true, method calls made
   // on this interface will be dropped (and may already have been dropped).
   bool encountered_error() const { return internal_state_.encountered_error(); }
 
   // Registers a handler to receive error notifications.
   //
   // This method may only be called after the AssociatedInterfacePtr has been
   // bound.
-  void set_connection_error_handler(const base::Closure& error_handler) {
+  void set_connection_error_handler(const Closure& error_handler) {
     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.
@@ skipping 63 matching lines @@
   group->CreateAssociatedInterface(AssociatedGroup::WILL_PASS_REQUEST,
                                    &ptr_info, &request);
 
   ptr->Bind(std::move(ptr_info), std::move(runner));
   return request;
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_INTERFACE_PTR_H_