Deletes mojo::Callback

mojo/public/cpp/bindings/binding_set.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_SET_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_BINDING_SET_H_
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
+#include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "mojo/public/cpp/bindings/binding.h"
 
 namespace mojo {
 
 // Use this class to manage a set of bindings, which are automatically destroyed
 // and removed from the set when the pipe they are bound to is disconnected.
 template <typename Interface>
 class BindingSet {
  public:
   BindingSet() {}
   ~BindingSet() { CloseAllBindings(); }
 
-  void set_connection_error_handler(const Closure& error_handler) {
+  void set_connection_error_handler(const base::Closure& error_handler) {
     error_handler_ = error_handler;
   }
 
   void AddBinding(Interface* impl, InterfaceRequest<Interface> request) {
     auto binding = new Element(impl, std::move(request));
     binding->set_connection_error_handler(
         base::Bind(&BindingSet::OnConnectionError, base::Unretained(this)));
     bindings_.push_back(binding->GetWeakPtr());
   }
 
@@ skipping 21 matching lines @@
   class Element {
    public:
     Element(Interface* impl, InterfaceRequest<Interface> request)
         : binding_(impl, std::move(request)), weak_ptr_factory_(this) {
       binding_.set_connection_error_handler(
           base::Bind(&Element::OnConnectionError, base::Unretained(this)));
     }
 
     ~Element() {}
 
-    void set_connection_error_handler(const Closure& error_handler) {
+    void set_connection_error_handler(const base::Closure& error_handler) {
       error_handler_ = error_handler;
     }
 
     base::WeakPtr<Element> GetWeakPtr() {
       return weak_ptr_factory_.GetWeakPtr();
     }
 
     void Close() { binding_.Close(); }
 
     void OnConnectionError() {
-      Closure error_handler = error_handler_;
+      base::Closure error_handler = error_handler_;
       delete this;
       if (!error_handler.is_null())
         error_handler.Run();
     }
 
    private:
     Binding<Interface> binding_;
-    Closure error_handler_;
+    base::Closure error_handler_;
     base::WeakPtrFactory<Element> weak_ptr_factory_;
 
     DISALLOW_COPY_AND_ASSIGN(Element);
   };
 
   void OnConnectionError() {
     // Clear any deleted bindings.
     bindings_.erase(std::remove_if(bindings_.begin(), bindings_.end(),
                                    [](const base::WeakPtr<Element>& p) {
                                      return p.get() == nullptr;
                                    }),
                     bindings_.end());
 
     if (!error_handler_.is_null())
       error_handler_.Run();
   }
 
-  Closure error_handler_;
+  base::Closure error_handler_;
   std::vector<base::WeakPtr<Element>> bindings_;
 
   DISALLOW_COPY_AND_ASSIGN(BindingSet);
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_BINDING_SET_H_