Explicitly delete some Callback constructors to improve errors.

base/callback.h

 // Copyright (c) 2012 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 BASE_CALLBACK_H_
 #define BASE_CALLBACK_H_
 
 #include "base/callback_forward.h"
 #include "base/callback_internal.h"
 
@@ skipping 99 matching lines @@
   using RunType = R(Args...);
 
   Callback() : internal::CallbackBase<copy_mode>(nullptr) {}
 
   explicit Callback(internal::BindStateBase* bind_state)
       : internal::CallbackBase<copy_mode>(bind_state) {
   }
 
   template <typename OtherCallback,
             typename = typename std::enable_if<
-                internal::IsCallbackConvertible<OtherCallback, Callback>::value
-            >::type>
+                internal::IsOnceCallback<OtherCallback>::value>::type>
+  Callback(const OtherCallback&) = delete;
+
+  template <typename OtherCallback,
+            typename = typename std::enable_if<
+                internal::IsCallbackConvertible<OtherCallback,
+                                                Callback>::value>::type>

[brucedawson, 2016/12/19 19:16:00]

The diffs are very confusing here - it took me a while to realize that the
IsCallbackConvertible clause is unchanged. Can you undo the reformat of that so
that the diffs make the actual change clearer?

Although, I still find enable_if very confusing.

[dcheng, 2016/12/19 20:18:11]

//base requires clang-formatting now =P

Do you think adding a comment above the explicitly deleted methods would be
helpful for disambiguating this diff a bit?

   Callback(OtherCallback other)
       : internal::CallbackBase<copy_mode>(std::move(other)) {}
 
   template <typename OtherCallback,
             typename = typename std::enable_if<
                 internal::IsCallbackConvertible<OtherCallback, Callback>::value
             >::type>
   Callback& operator=(OtherCallback other) {
     static_cast<internal::CallbackBase<copy_mode>&>(*this) = std::move(other);
     return *this;
   }
 
   bool Equals(const Callback& other) const {
     return this->EqualsInternal(other);
   }
 
   friend class internal::RunMixin<Callback>;
 };
 
 }  // namespace base
 
 #endif  // BASE_CALLBACK_H_