Use OnceCallback for Mojo binding connection error handlers.

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 <string>
 #include <utility>
 
@@ skipping 55 matching lines @@
   using ContextTraits = BindingSetContextTraits<ContextType>;
   using Context = typename ContextTraits::Type;
   using PreDispatchCallback = base::Callback<void(const Context&)>;
   using Traits = BindingSetTraits<BindingType>;
   using ProxyType = typename Traits::ProxyType;
   using RequestType = typename Traits::RequestType;
   using ImplPointerType = typename Traits::ImplPointerType;
 
   BindingSetBase() {}
 
-  void set_connection_error_handler(const base::Closure& error_handler) {
-    error_handler_ = error_handler;
+  void set_connection_error_handler(base::RepeatingClosure error_handler) {
+    error_handler_ = std::move(error_handler);
     error_with_reason_handler_.Reset();
   }
 
   void set_connection_error_with_reason_handler(
-      const ConnectionErrorWithReasonCallback& error_handler) {
-    error_with_reason_handler_ = error_handler;
+      RepeatingConnectionErrorWithReasonCallback error_handler) {
+    error_with_reason_handler_ = std::move(error_handler);
     error_handler_.Reset();
   }
 
   // Sets a callback to be invoked immediately before dispatching any message or
   // error received by any of the bindings in the set. This may only be used
   // with a non-void |ContextType|.
   void set_pre_dispatch_handler(const PreDispatchCallback& handler) {
     static_assert(ContextTraits::SupportsContext(),
                   "Pre-dispatch handler usage requires non-void context type.");
     pre_dispatch_handler_ = handler;
@@ skipping 81 matching lines @@
           BindingSetBase* binding_set,
           BindingId binding_id,
           Context context)
         : binding_(std::move(impl), std::move(request)),
           binding_set_(binding_set),
           binding_id_(binding_id),
           context_(std::move(context)) {
       if (ContextTraits::SupportsContext())
         binding_.AddFilter(base::MakeUnique<DispatchFilter>(this));
       binding_.set_connection_error_with_reason_handler(
-          base::Bind(&Entry::OnConnectionError, base::Unretained(this)));
+          base::BindOnce(&Entry::OnConnectionError, base::Unretained(this)));
     }
 
     void FlushForTesting() { binding_.FlushForTesting(); }
 
    private:
     class DispatchFilter : public MessageReceiver {
      public:
       explicit DispatchFilter(Entry* entry) : entry_(entry) {}
       ~DispatchFilter() override {}
 
@@ skipping 51 matching lines @@
                          uint32_t custom_reason,
                          const std::string& description) {
     auto it = bindings_.find(id);
     DCHECK(it != bindings_.end());
 
     // We keep the Entry alive throughout error dispatch.
     std::unique_ptr<Entry> entry = std::move(it->second);
     if (!is_flushing_)
       bindings_.erase(it);
 
-    if (!error_handler_.is_null())
+    if (error_handler_) {
       error_handler_.Run();
-    else if (!error_with_reason_handler_.is_null())
+    } else if (error_with_reason_handler_) {
       error_with_reason_handler_.Run(custom_reason, description);
+    }
   }
 
-  base::Closure error_handler_;
-  ConnectionErrorWithReasonCallback error_with_reason_handler_;
+  base::RepeatingClosure error_handler_;
+  RepeatingConnectionErrorWithReasonCallback error_with_reason_handler_;
   PreDispatchCallback pre_dispatch_handler_;
   BindingId next_binding_id_ = 0;
   std::map<BindingId, std::unique_ptr<Entry>> bindings_;
   bool is_flushing_ = false;
   const Context* dispatch_context_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(BindingSetBase);
 };
 
 template <typename Interface, typename ContextType = void>
 using BindingSet = BindingSetBase<Interface, Binding<Interface>, ContextType>;
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_BINDING_SET_H_