Oilpan: Remove GC_INFO_{DEFINE,DECLARE} macros

Source/heap/Visitor.h

 /*
  * Copyright (C) 2013 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 24 matching lines @@
 #include "heap/ThreadState.h"
 #include "wtf/Assertions.h"
 #include "wtf/Deque.h"
 #include "wtf/Forward.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/HashTraits.h"
 #include "wtf/ListHashSet.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/RefPtr.h"
+#include "wtf/TypeTraits.h"
 
 #ifndef NDEBUG
 #define DEBUG_ONLY(x) x
 #else
 #define DEBUG_ONLY(x)
 #endif
 
 namespace WebCore {
 
 class FinalizedHeapObjectHeader;
@@ skipping 29 matching lines @@
 // reachable. There is a GCInfo struct for each class that directly
 // inherits from GarbageCollected or GarbageCollectedFinalized.
 struct GCInfo {
     bool hasFinalizer() const { return m_nonTrivialFinalizer; }
     const char* m_typeMarker;
     TraceCallback m_trace;
     FinalizationCallback m_finalize;
     bool m_nonTrivialFinalizer;
 };
 
-// Template struct to detect whether type T inherits from
-// GarbageCollectedFinalized.
-template<typename T>
-struct IsGarbageCollectedFinalized {
-    typedef char TrueType;
-    struct FalseType {
-        char dummy[2];
-    };
-    template<typename U> static TrueType has(GarbageCollectedFinalized<U>*);
-    static FalseType has(...);
-    static bool const value = sizeof(has(static_cast<T*>(0))) == sizeof(TrueType);
-};
-
 // The FinalizerTraitImpl specifies how to finalize objects. Object
 // that inherit from GarbageCollectedFinalized are finalized by
 // calling their 'finalize' method which by default will call the
 // destructor on the object.
 template<typename T, bool isGarbageCollectedFinalized>
 struct FinalizerTraitImpl;
 
 template<typename T>
 struct FinalizerTraitImpl<T, true> {
     static void finalize(void* obj) { static_cast<T*>(obj)->finalize(); };
 };
 
 template<typename T>
 struct FinalizerTraitImpl<T, false> {
     static void finalize(void* obj) { };
 };
 
 // The FinalizerTrait is used to determine if a type requires
 // finalization and what finalization means.
 //
 // By default classes that inherit from GarbageCollectedFinalized need
 // finalization and finalization means calling the 'finalize' method
 // of the object. The FinalizerTrait can be specialized if the default
 // behavior is not desired.
 template<typename T>
 struct FinalizerTrait {
-    static const bool nonTrivialFinalizer = IsGarbageCollectedFinalized<T>::value;
+    static const bool nonTrivialFinalizer = WTF::IsSubclassOfTemplate<T, GarbageCollectedFinalized>::value;
     static void finalize(void* obj) { FinalizerTraitImpl<T, nonTrivialFinalizer>::finalize(obj); }
 };
 
-// Macros to declare and define GCInfo structures for objects
-// allocated in the Blink garbage-collected heap.
-#define DECLARE_GC_INFO                                                       \
-public:                                                                       \
-    static const GCInfo s_gcInfo;                                             \
-    template<typename Any> friend struct FinalizerTrait;                      \
-private:                                                                      \
-
-#define DEFINE_GC_INFO(Type)                                                  \
-const GCInfo Type::s_gcInfo = {                                               \
-    #Type,                                                                    \
-    TraceTrait<Type>::trace,                                                  \
-    FinalizerTrait<Type>::finalize,                                           \
-    FinalizerTrait<Type>::nonTrivialFinalizer,                                \
-};                                                                            \
-
 // Trait to get the GCInfo structure for types that have their
 // instances allocated in the Blink garbage-collected heap.
-template<typename T>
-struct GCInfoTrait {
-    static const GCInfo* get()
-    {
-        return &T::s_gcInfo;
-    }
-};
+template<typename T> struct GCInfoTrait;
 
 template<typename T>
 const char* getTypeMarker()
 {
     return GCInfoTrait<T>::get()->m_typeMarker;
 }
 
 // The TraceTrait is used to specify how to mark an object pointer and
 // how to trace all of the pointers in the object.
 //
@@ skipping 366 matching lines @@
 
 template<typename T> bool ObjectAliveTrait<T>::isAlive(Visitor* visitor, T obj)
 {
     return visitor->isMarked(obj);
 }
 template<typename T> bool ObjectAliveTrait<Member<T> >::isAlive(Visitor* visitor, const Member<T>& obj)
 {
     return visitor->isMarked(obj.get());
 }
 
+template<typename T>
+struct GCInfoAtBase {
+    static const GCInfo* get()
+    {
+        static char pseudoTypeMarker = 'a';
+        static const GCInfo gcInfo = {
+            &pseudoTypeMarker,
+            TraceTrait<T>::trace,
+            FinalizerTrait<T>::finalize,
+            FinalizerTrait<T>::nonTrivialFinalizer,
+        };
+        return &gcInfo;
+    }
+};
+
+template<typename T> class GarbageCollected;
+template<typename T, bool = WTF::IsSubclassOfTemplate<T, GarbageCollected>::value> struct GetGarbageCollectedBase;
+
+template<typename T>
+struct GetGarbageCollectedBase<T, true> {
+    typedef typename T::GarbageCollectedBase type;
+};
+
+template<typename T>
+struct GetGarbageCollectedBase<T, false> {
+    typedef T type;
+};
+
+template<typename T>
+struct GCInfoTrait {
+    static const GCInfo* get()
+    {
+        return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
+    }
+};
+
 }
 
 #endif