Split out Members, Persistents and SelfKeepAlive in separate headers.

third_party/WebKit/Source/platform/heap/GarbageCollected.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 GarbageCollected_h
 #define GarbageCollected_h
 
 #include "platform/heap/ThreadState.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
-#include "wtf/ListHashSet.h"
 #include "wtf/TypeTraits.h"
 
 namespace blink {
 
 template<typename T> class GarbageCollected;
-template<typename T, typename U, typename V, typename W, typename X> class HeapHashMap;
-template<typename T, typename U, typename V> class HeapHashSet;
-template<typename T, typename U, typename V> class HeapLinkedHashSet;
-template<typename T, size_t inlineCapacity, typename U> class HeapListHashSet;
-template<typename T, size_t inlineCapacity> class HeapVector;
-template<typename T, size_t inlineCapacity> class HeapDeque;
-template<typename T, typename U, typename V> class HeapHashCountedSet;
-template<typename T> class HeapTerminatedArray;
-template<typename T, typename Traits> class HeapVectorBacking;
-template<typename Table> class HeapHashTableBacking;
-template<typename ValueArg, size_t inlineCapacity> class HeapListHashSetAllocator;
 class InlinedGlobalMarkingVisitor;
 class WrapperVisitor;
-template<typename T> class Persistent;
 
 // GC_PLUGIN_IGNORE is used to make the plugin ignore a particular class or
 // field when checking for proper usage.  When using GC_PLUGIN_IGNORE
 // a bug-number should be provided as an argument where the bug describes
 // what needs to happen to remove the GC_PLUGIN_IGNORE again.
 #if COMPILER(CLANG)
 #define GC_PLUGIN_IGNORE(bug)                           \
     __attribute__((annotate("blink_gc_plugin_ignore")))
 #else
 #define GC_PLUGIN_IGNORE(bug)
 #endif
 
 // Template to determine if a class is a GarbageCollectedMixin by checking if it
 // has IsGarbageCollectedMixinMarker
 template<typename T>
 struct IsGarbageCollectedMixin {
 private:
     typedef char YesType;
     struct NoType {
         char padding[8];
     };
 
     template <typename U> static YesType checkMarker(typename U::IsGarbageCollectedMixinMarker*);
     template <typename U> static NoType checkMarker(...);
 
 public:
     static const bool value = sizeof(checkMarker<T>(nullptr)) == sizeof(YesType);
 };
 
-template <typename T>
-struct IsGarbageCollectedType {
-    using TrueType = char;
-    struct FalseType {
-        char dummy[2];
-    };
-
-    using NonConstType = typename std::remove_const<T>::type;
-    using GarbageCollectedSubclass = WTF::IsSubclassOfTemplate<NonConstType, GarbageCollected>;
-    using GarbageCollectedMixinSubclass = IsGarbageCollectedMixin<NonConstType>;
-    using HeapHashSetSubclass = WTF::IsSubclassOfTemplate<NonConstType, HeapHashSet>;
-    using HeapLinkedHashSetSubclass = WTF::IsSubclassOfTemplate<NonConstType, HeapLinkedHashSet>;
-    using HeapListHashSetSubclass = WTF::IsSubclassOfTemplateTypenameSizeTypename<NonConstType, HeapListHashSet>;
-    using HeapHashMapSubclass = WTF::IsSubclassOfTemplate<NonConstType, HeapHashMap>;
-    using HeapVectorSubclass = WTF::IsSubclassOfTemplateTypenameSize<NonConstType, HeapVector>;
-    using HeapDequeSubclass = WTF::IsSubclassOfTemplateTypenameSize<NonConstType, HeapDeque>;
-    using HeapHashCountedSetSubclass = WTF::IsSubclassOfTemplate<NonConstType, HeapHashCountedSet>;
-    using HeapTerminatedArraySubclass = WTF::IsSubclassOfTemplate<NonConstType, HeapTerminatedArray>;
-    using HeapVectorBackingSubclass = WTF::IsSubclassOfTemplate<NonConstType, HeapVectorBacking>;
-    using HeapHashTableBackingSubclass = WTF::IsSubclassOfTemplate<NonConstType, HeapHashTableBacking>;
-
-    template<typename U, size_t inlineCapacity> static TrueType listHashSetNodeIsHeapAllocated(WTF::ListHashSetNode<U, HeapListHashSetAllocator<U, inlineCapacity>>*);
-    static FalseType listHashSetNodeIsHeapAllocated(...);
-    static const bool isHeapAllocatedListHashSetNode = sizeof(TrueType) == sizeof(listHashSetNodeIsHeapAllocated(reinterpret_cast<NonConstType*>(0)));
-
-    static_assert(sizeof(T), "T must be fully defined");
-
-    static const bool value =
-        GarbageCollectedSubclass::value
-        || GarbageCollectedMixinSubclass::value
-        || HeapHashSetSubclass::value
-        || HeapLinkedHashSetSubclass::value
-        || HeapListHashSetSubclass::value
-        || HeapHashMapSubclass::value
-        || HeapVectorSubclass::value
-        || HeapDequeSubclass::value
-        || HeapHashCountedSetSubclass::value
-        || HeapTerminatedArraySubclass::value
-        || HeapVectorBackingSubclass::value
-        || HeapHashTableBackingSubclass::value
-        || isHeapAllocatedListHashSetNode;
-};
-
-template <>
-struct IsGarbageCollectedType<void> {
-    static const bool value = false;
-};
-
 // The GarbageCollectedMixin interface and helper macro
 // USING_GARBAGE_COLLECTED_MIXIN can be used to automatically define
 // TraceTrait/ObjectAliveTrait on non-leftmost deriving classes
 // which need to be garbage collected.
 //
 // Consider the following case:
 // class B {};
 // class A : public GarbageCollected, public B {};
 //
 // We can't correctly handle "Member<B> p = &a" as we can't compute addr of
 // object header statically. This can be solved by using GarbageCollectedMixin:
 // class B : public GarbageCollectedMixin {};
 // class A : public GarbageCollected, public B {
-//   USING_GARBAGE_COLLECTED_MIXIN(A)
+//   USING_GARBAGE_COLLECTED_MIXIN(A);
 // };
 //
 // With the helper, as long as we are using Member<B>, TypeTrait<B> will
 // dispatch adjustAndMark dynamically to find collect addr of the object header.
 // Note that this is only enabled for Member<B>. For Member<A> which we can
 // compute the object header addr statically, this dynamic dispatch is not used.
+//
 class PLATFORM_EXPORT GarbageCollectedMixin {
-    IS_GARBAGE_COLLECTED_TYPE();
 public:
     typedef int IsGarbageCollectedMixinMarker;
     virtual void adjustAndMark(Visitor*) const = 0;
     virtual void trace(Visitor*) { }
     virtual void adjustAndMark(InlinedGlobalMarkingVisitor) const = 0;
     virtual void trace(InlinedGlobalMarkingVisitor);
     virtual void adjustAndMarkWrapper(const WrapperVisitor*) const = 0;
     virtual bool isHeapObjectAlive() const = 0;
 };
 
@@ skipping 181 matching lines @@
 
     template<typename U, size_t sz = sizeof(U)> static TrueType isSizeofKnown(U*);
     static FalseType isSizeofKnown(...);
     static T& t;
 public:
     static const bool value = sizeof(TrueType) == sizeof(isSizeofKnown(&t));
 };
 
 } // namespace blink
 
-namespace WTF {
-
-} // namespace WTF
-
 #endif