More switching to standard type traits

third_party/WebKit/Source/platform/CrossThreadCopier.h

 /*
  * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 69 matching lines @@
     };
 
     // Custom copy methods.
     template<typename T> struct CrossThreadCopierBase<false, true, false, T> {
         STATIC_ONLY(CrossThreadCopierBase);
         typedef typename WTF::RemoveTemplate<T, RefPtr>::Type TypeWithoutRefPtr;
         typedef typename WTF::RemoveTemplate<TypeWithoutRefPtr, PassRefPtr>::Type TypeWithoutPassRefPtr;
         typedef typename std::remove_pointer<TypeWithoutPassRefPtr>::type RefCountedType;
 
         // Verify that only one of the above did a change.
-        static_assert((WTF::IsSameType<RefPtr<RefCountedType>, T>::value
-                        || WTF::IsSameType<PassRefPtr<RefCountedType>, T>::value
-                        || WTF::IsSameType<RefCountedType*, T>::value),
+        static_assert((std::is_same<RefPtr<RefCountedType>, T>::value
+                        || std::is_same<PassRefPtr<RefCountedType>, T>::value
+                        || std::is_same<RefCountedType*, T>::value),
                         "only one type modification should be allowed");
 
         typedef PassRefPtr<RefCountedType> Type;
         static Type copy(const T& refPtr)
         {
             return refPtr;
         }
     };
 
     template<typename T> struct CrossThreadCopierBase<false, false, false, PassOwnPtr<T>> {
@@ skipping 74 matching lines @@
 
     template<typename T> struct CrossThreadCopierBase<false, false, true, WeakMember<T>> {
         STATIC_ONLY(CrossThreadCopierBase);
         typedef RawPtr<T> Type;
         static Type copy(const WeakMember<T>& ptr)
         {
             return ptr;
         }
     };
 
-    template<typename T> struct CrossThreadCopier : public CrossThreadCopierBase<WTF::IsConvertibleToInteger<T>::value,
+    template<typename T> struct CrossThreadCopier : public CrossThreadCopierBase<std::is_convertible<T, int>::value,
         WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, RefPtr>::Type, ThreadSafeRefCounted>::value
             || WTF::IsSubclassOfTemplate<typename std::remove_pointer<T>::type, ThreadSafeRefCounted>::value
             || WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, PassRefPtr>::Type, ThreadSafeRefCounted>::value,
         WTF::IsSubclassOfTemplate<typename std::remove_pointer<T>::type, GarbageCollected>::value
             || WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, RawPtr>::Type, GarbageCollected>::value
             || WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, Member>::Type, GarbageCollected>::value
             || WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, WeakMember>::Type, GarbageCollected>::value,
         T> {
         STATIC_ONLY(CrossThreadCopier);
     };
@@ skipping 26 matching lines @@
     }
 
     template<typename T> AllowCrossThreadAccessWrapper<const WeakPtr<T>&> AllowCrossThreadAccess(const WeakPtr<T>& value)
     {
         return AllowCrossThreadAccessWrapper<const WeakPtr<T>&>(value);
     }
 
 } // namespace blink
 
 #endif // CrossThreadCopier_h