More switching to standard type traits

third_party/WebKit/Source/platform/heap/ThreadingTraits.h

 // Copyright 2015 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 ThreadingTraits_h
 #define ThreadingTraits_h
 
 #include "wtf/Deque.h"
 #include "wtf/HashCountedSet.h"
 #include "wtf/HashMap.h"
@@ skipping 17 matching lines @@
     AnyThread,
     MainThreadOnly,
 };
 
 // TODO(haraken): These forward declarations violate dependency rules.
 // Remove them.
 class Node;
 class NodeList;
 
 template<typename T,
-    bool mainThreadOnly = WTF::IsSubclass<typename std::remove_const<T>::type, Node>::value
-        || WTF::IsSubclass<typename std::remove_const<T>::type, NodeList>::value> struct DefaultThreadingTrait;
+    bool mainThreadOnly = std::is_convertible<typename std::remove_const<T>::type*, Node*>::value
+        || std::is_convertible<typename std::remove_const<T>::type*, NodeList*>::value> struct DefaultThreadingTrait;

[Nico, 2015/12/18 14:14:14]

Now that I think about it, this is a risky change, right? It's a good thing that
is_base_of requires the types to be complete (unless they're the same).
Consider:

#include <type_traits>
class A; class B;
static_assert(std::is_base_of<A, B>::value, "");

This doesn't build, it complains that A and B aren't complete.

Now consider:
#include <type_traits>
class A; class B;
static_assert(std::is_convertible<B*, A*>::value, "");


This builds, and the static_assert fails. Now we add the definitions:

#include <type_traits>
class A; class B;
class A {}; class B : public A {};
static_assert(std::is_convertible<B*, A*>::value, "");

This builds, and the static_assert doesn't fail! This means is_convertible will
have different results based on if classes are defined or not (which is
unpredictable). This is actually fairly worrying. Maybe we shouldn't be using
std::is_convertible much...

 
 template<typename T>
 struct DefaultThreadingTrait<T, false> {
     static const ThreadAffinity Affinity = AnyThread;
 };
 
 template<typename T>
 struct DefaultThreadingTrait<T, true> {
     static const ThreadAffinity Affinity = MainThreadOnly;
 };
@@ skipping 82 matching lines @@
 template<typename T, size_t inlineCapacity>
 struct ThreadingTrait<HeapVector<T, inlineCapacity>> : public ThreadingTrait<Vector<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, size_t inlineCapacity>
 struct ThreadingTrait<HeapDeque<T, inlineCapacity>> : public ThreadingTrait<Deque<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, typename U, typename V>
 struct ThreadingTrait<HeapHashCountedSet<T, U, V>> : public ThreadingTrait<HashCountedSet<T, U, V, HeapAllocator>> { };
 
 } // namespace blink
 
 #endif