Remove unbound base::Bind overload

base/bind_helpers.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.
 
 // This defines a set of argument wrappers and related factory methods that
 // can be used specify the refcounting and reference semantics of arguments
 // that are bound by the Bind() function in base/bind.h.
 //
 // It also defines a set of simple functions and utilities that people want
 // when using Callback<> and Bind().
@@ skipping 509 matching lines @@
 
 template <>
 struct DropTypeListItemImpl<0, TypeList<>> {
   typedef TypeList<> Type;
 };
 
 // A type-level function that drops |n| list item from given TypeList.
 template <size_t n, typename List>
 using DropTypeListItem = typename DropTypeListItemImpl<n, List>::Type;
 
+// Used for TakeTypeListItem implementation.
+template <size_t n, typename List, typename... Accum>
+struct TakeTypeListItemImpl;
+
+// Do not use enable_if and SFINAE here to avoid MSVC2013 compile failure.
+template <size_t n, typename T, typename... List, typename... Accum>
+struct TakeTypeListItemImpl<n, TypeList<T, List...>, Accum...>
+    : TakeTypeListItemImpl<n - 1, TypeList<List...>, Accum..., T> {};
+
+template <typename T, typename... List, typename... Accum>
+struct TakeTypeListItemImpl<0, TypeList<T, List...>, Accum...> {
+  typedef TypeList<Accum...> Type;

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

Let's do using Type = TypeList<Accum...>;

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

Done.

+};
+
+template <typename... Accum>
+struct TakeTypeListItemImpl<0, TypeList<>, Accum...> {
+  typedef TypeList<Accum...> Type;
+};
+
+// A type-level function that takes first |n| list item from given TypeList.

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

Can this comment include an example input and the output? e.g.

TakeTypeListItem<3, TypeList<A, B, C, D>> will evaluate to TypeList<A, B, C>

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

Done.

+template <size_t n, typename List>
+using TakeTypeListItem = typename TakeTypeListItemImpl<n, List>::Type;
+
 // Used for ConcatTypeLists implementation.
 template <typename List1, typename List2>
 struct ConcatTypeListsImpl;
 
 template <typename... Types1, typename... Types2>
 struct ConcatTypeListsImpl<TypeList<Types1...>, TypeList<Types2...>> {
   typedef TypeList<Types1..., Types2...> Type;
 };
 
 // A type-level function that concats two TypeLists.
 template <typename List1, typename List2>
 using ConcatTypeLists = typename ConcatTypeListsImpl<List1, List2>::Type;
 
 // Used for MakeFunctionType implementation.
 template <typename R, typename ArgList>
 struct MakeFunctionTypeImpl;
 
 template <typename R, typename... Args>
 struct MakeFunctionTypeImpl<R, TypeList<Args...>> {
   typedef R(Type)(Args...);
 };
 
 // A type-level function that constructs a function type that has |R| as its
 // return type and has TypeLists items as its arguments.
 template <typename R, typename ArgList>
 using MakeFunctionType = typename MakeFunctionTypeImpl<R, ArgList>::Type;
 
+// Used for ExtractArgs.
+template <typename Signature>
+struct ExtractArgsImpl;
+
+template <typename R, typename... Args>
+struct ExtractArgsImpl<R(Args...)> {
+  using Type = TypeList<Args...>;
+};
+
+// A type-level function that extracts function arguments into a TypeList.

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

Ditto:

Input: R(A1, A2, A3) => TypeList<A1, A2, A3>

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

Done.

+template <typename Signature>
+using ExtractArgs = typename ExtractArgsImpl<Signature>::Type;
+
 }  // namespace internal
 
 template <typename T>
 static inline internal::UnretainedWrapper<T> Unretained(T* o) {
   return internal::UnretainedWrapper<T>(o);
 }
 
 template <typename T>
 static inline internal::ConstRefWrapper<T> ConstRef(const T& o) {
   return internal::ConstRefWrapper<T>(o);
@@ skipping 39 matching lines @@
 BASE_EXPORT void DoNothing();
 
 template<typename T>
 void DeletePointer(T* obj) {
   delete obj;
 }
 
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_