Use <type_traits> in the C++ bindings library wherever possible.

mojo/public/cpp/bindings/lib/bindings_internal.h

 // Copyright 2013 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_LIB_BINDINGS_INTERNAL_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_BINDINGS_INTERNAL_H_
 
+#include <type_traits>
+
 #include "mojo/public/cpp/bindings/lib/template_util.h"
 #include "mojo/public/cpp/bindings/struct_ptr.h"
 #include "mojo/public/cpp/system/core.h"
 
 namespace mojo {
 class String;
 
 template <typename T>
 class Array;
 
@@ skipping 61 matching lines @@
 
 template <typename T>
 T FetchAndReset(T* ptr) {
   T temp = *ptr;
   *ptr = T();
   return temp;
 }
 
 template <typename H>
 struct IsHandle {
-  enum { value = IsBaseOf<Handle, H>::value };
+  enum { value = std::is_base_of<Handle, H>::value };
 };
 
 template <typename T>
 struct RemoveStructPtr {
   typedef T type;
 };
 
 template <typename T>
 struct RemoveStructPtr<StructPtr<T>> {
   typedef T type;
@@ skipping 42 matching lines @@
 
 template <typename T>
 struct IsUnionWrapperType {
   template <typename U>
   static YesType Test(const typename U::Data_::MojomUnionDataType*);
 
   template <typename U>
   static NoType Test(...);
 
   static const bool value =
-      sizeof(Test<T>(0)) == sizeof(YesType) && !IsConst<T>::value;
+      sizeof(Test<T>(0)) == sizeof(YesType) && !std::is_const<T>::value;
 };
 
 template <typename T>
 struct IsUnionDataType {
   template <typename U>
   static YesType Test(const typename U::MojomUnionDataType*);
 
   template <typename U>
   static NoType Test(...);
 
   static const bool value =
-      sizeof(Test<T>(0)) == sizeof(YesType) && !IsConst<T>::value;
+      sizeof(Test<T>(0)) == sizeof(YesType) && !std::is_const<T>::value;
 };
 
 template <typename T,
           bool move_only = IsMoveOnlyType<T>::value,
           bool is_union =
               IsUnionWrapperType<typename RemoveStructPtr<T>::type>::value>
 struct WrapperTraits;
 
 template <typename T>
 struct WrapperTraits<T, false, false> {
@@ skipping 23 matching lines @@
 struct WrapperTraits<S, true, false> {
   typedef typename S::Data_* DataType;
 };
 
 template <typename T, typename Enable = void>
 struct ValueTraits {
   static bool Equals(const T& a, const T& b) { return a == b; }
 };
 
 template <typename T>
-struct ValueTraits<
-    T,
-    typename EnableIf<IsSpecializationOf<Array, T>::value ||
-                      IsSpecializationOf<Map, T>::value ||
-                      IsSpecializationOf<StructPtr, T>::value ||
-                      IsSpecializationOf<InlinedStructPtr, T>::value>::type> {
+struct ValueTraits<T,
+                   typename std::enable_if<
+                       IsSpecializationOf<Array, T>::value ||
+                       IsSpecializationOf<Map, T>::value ||
+                       IsSpecializationOf<StructPtr, T>::value ||
+                       IsSpecializationOf<InlinedStructPtr, T>::value>::type> {
   static bool Equals(const T& a, const T& b) { return a.Equals(b); }
 };
 
 template <typename T>
 struct ValueTraits<ScopedHandleBase<T>> {
   static bool Equals(const ScopedHandleBase<T>& a,
                      const ScopedHandleBase<T>& b) {
     return a.get().value() == b.get().value();
   }
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_BINDINGS_INTERNAL_H_