Replace template_util.h stuff with C++11 <type_traits>

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 <stddef.h>
 
 #include <type_traits>
@@ skipping 50 matching lines @@
 //  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 List>
-struct HasNonConstReferenceItem : false_type {};
+struct HasNonConstReferenceItem : std::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 T, typename... Args>
 struct HasNonConstReferenceItem<TypeList<T, Args...>>
     : std::conditional<is_non_const_reference<T>::value,
-                       true_type,
+                       std::true_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 {};
+struct HasRefCountedTypeAsRawPtr : std::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
 // parameters recursively.
 template <typename T, typename... Args>
 struct HasRefCountedTypeAsRawPtr<T, Args...>
     : std::conditional<NeedsScopedRefptrButGetsRawPtr<T>::value,
-                       true_type,
+                       std::true_type,
                        HasRefCountedTypeAsRawPtr<Args...>>::type {};
 
 // BindsArrayToFirstArg selects true_type when |is_method| is true and the first
 // item of |Args| is an array type.
 // Implementation note: This non-specialized case handles !is_method case and
 // zero-arity case only.  Other cases should be handled by the specialization
 // below.
 template <bool is_method, typename... Args>
-struct BindsArrayToFirstArg : false_type {};
+struct BindsArrayToFirstArg : std::false_type {};
 
 template <typename T, typename... Args>
 struct BindsArrayToFirstArg<true, T, Args...>
-    : is_array<typename std::remove_reference<T>::type> {};
+    : std::is_array<typename std::remove_reference<T>::type> {};
 
 // HasRefCountedParamAsRawPtr is the same to HasRefCountedTypeAsRawPtr except
 // when |is_method| is true HasRefCountedParamAsRawPtr skips the first argument.
 // Implementation note: This non-specialized case handles !is_method case and
 // zero-arity case only.  Other cases should be handled by the specialization
 // below.
 template <bool is_method, typename... Args>
 struct HasRefCountedParamAsRawPtr : HasRefCountedTypeAsRawPtr<Args...> {};
 
 template <typename T, typename... Args>
@@ skipping 44 matching lines @@
   R (*function_)(Args...);
 };
 
 // Method.
 template <typename R, typename T, typename... Args>
 class RunnableAdapter<R(T::*)(Args...)> {
  public:
   // MSVC 2013 doesn't support Type Alias of function types.
   // Revisit this after we update it to newer version.
   typedef R RunType(T*, Args...);
-  using IsMethod = true_type;
+  using IsMethod = std::true_type;
 
   explicit RunnableAdapter(R(T::*method)(Args...))
       : method_(method) {
   }
 
   template <typename... RunArgs>
   R Run(T* object, RunArgs&&... args) {
     return (object->*method_)(std::forward<RunArgs>(args)...);
   }
 
  private:
   R (T::*method_)(Args...);
 };
 
 // Const Method.
 template <typename R, typename T, typename... Args>
 class RunnableAdapter<R(T::*)(Args...) const> {
  public:
   using RunType = R(const T*, Args...);
-  using IsMethod = true_type;
+  using IsMethod = std::true_type;
 
   explicit RunnableAdapter(R(T::*method)(Args...) const)
       : method_(method) {
   }
 
   template <typename... RunArgs>
   R Run(const T* object, RunArgs&&... args) {
     return (object->*method_)(std::forward<RunArgs>(args)...);
   }
 
@@ skipping 111 matching lines @@
   }
 };
 
 #if !defined(_MSC_VER)
 
 template <typename ReturnType, typename Runnable>
 struct InvokeHelper<true, ReturnType, Runnable> {
   // WeakCalls are only supported for functions with a void return type.
   // Otherwise, the function result would be undefined if the the WeakPtr<>
   // is invalidated.
-  static_assert(is_void<ReturnType>::value,
+  static_assert(std::is_void<ReturnType>::value,
                 "weak_ptrs can only bind to methods without return values");
 };
 
 #endif
 
 // Invoker<>
 //
 // See description at the top of the file.
 template <typename BoundIndices, typename StorageType,
           typename InvokeHelperType, typename UnboundForwardRunType>
@@ skipping 97 matching lines @@
 
   static void Destroy(BindStateBase* self) {
     delete static_cast<BindState*>(self);
   }
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_BIND_INTERNAL_H_