Remove unbound base::Bind overload

base/bind_internal.h

 // Copyright (c) 2011 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_BIND_INTERNAL_H_
 #define BASE_BIND_INTERNAL_H_
 
 #include <type_traits>
 
 #include "base/bind_helpers.h"
@@ skipping 53 matching lines @@
 //                    Invoker<>.
 //  Invoker<> -- Unwraps the curried parameters and executes the Runnable.
 //  BindState<> -- Stores the curried parameters, and is the main entry point
 //                 into the Bind() system, doing most of the type resolution.
 //                 There are ARITY BindState types.
 
 // HasNonConstReferenceParam selects true_type when any of the parameters in
 // |Sig| is a non-const reference.
 // Implementation note: This non-specialized case handles zero-arity case only.
 // Non-zero-arity cases should be handled by the specialization below.
-template <typename Sig>
-struct HasNonConstReferenceParam : false_type {};
+template <typename List>
+struct HasNonConstReferenceItem : false_type {};
 
 // Implementation note: Select true_type if the first parameter is a non-const
 // reference.  Otherwise, skip the first parameter and check rest of parameters
 // recursively.
-template <typename R, typename T, typename... Args>
-struct HasNonConstReferenceParam<R(T, Args...)>

[dcheng, 2015/12/14 19:26:46]

I have a dumb question: why can't we just add a template specialization for R()
with no args here?

[tzik, 2015/12/15 05:55:09]

Add specialization for R() and remove the base case impl?
It's a possible option to add it for readability. Using the base case as the
"else case" is just a shorthand for fewer specialization.

+template <typename T, typename... Args>
+struct HasNonConstReferenceItem<TypeList<T, Args...>>
     : std::conditional<is_non_const_reference<T>::value,
                        true_type,
-                       HasNonConstReferenceParam<R(Args...)>>::type {};
+                       HasNonConstReferenceItem<TypeList<Args...>>>::type {};
 
 // HasRefCountedTypeAsRawPtr selects true_type when any of the |Args| is a raw
 // pointer to a RefCounted type.
 // Implementation note: This non-specialized case handles zero-arity case only.
 // Non-zero-arity cases should be handled by the specialization below.
 template <typename... Args>
 struct HasRefCountedTypeAsRawPtr : false_type {};
 
 // Implementation note: Select true_type if the first parameter is a raw pointer
 // to a RefCounted type. Otherwise, skip the first parameter and check rest of
@@ skipping 320 matching lines @@
 
   static void Destroy(BindStateBase* self) {
     delete static_cast<BindState*>(self);
   }
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_BIND_INTERNAL_H_