Oilpan: Remove GC_INFO_{DEFINE,DECLARE} macros

Source/heap/HeapTest.cpp

 /*
  * 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 97 matching lines @@
     FOR_EACH_TYPED_HEAP(DEFINE_VISITOR_METHODS)
 
     size_t count() { return m_count; }
     void reset() { m_count = 0; }
 
 private:
     size_t m_count;
 };
 
 class SimpleObject : public GarbageCollected<SimpleObject> {
-    DECLARE_GC_INFO;
 public:
     static SimpleObject* create() { return new SimpleObject(); }
     void trace(Visitor*) { }
     char getPayload(int i) { return payload[i]; }
 private:
     SimpleObject() { }
     char payload[64];
 };
 
 #undef DEFINE_VISITOR_METHODS
 
 class HeapTestSuperClass : public GarbageCollectedFinalized<HeapTestSuperClass> {
-    DECLARE_GC_INFO
 public:
     static HeapTestSuperClass* create()
     {
         return new HeapTestSuperClass();
     }
 
     virtual ~HeapTestSuperClass()
     {
         ++s_destructorCalls;
     }
@@ skipping 32 matching lines @@
 private:
 
     HeapTestSubClass() : m_magic(classMagic) { }
 
     const size_t m_magic;
 };
 
 int HeapTestSubClass::s_destructorCalls = 0;
 
 class HeapAllocatedArray : public GarbageCollected<HeapAllocatedArray> {
-    DECLARE_GC_INFO
 public:
     HeapAllocatedArray()
     {
         for (int i = 0; i < s_arraySize; ++i) {
             m_array[i] = i % 128;
         }
     }
 
     int8_t at(size_t i) { return m_array[i]; }
     void trace(Visitor*) { }
@@ skipping 10 matching lines @@
         getHeapStats(heapStats);
         size_t used = heapStats->totalObjectSpace();
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         getHeapStats(heapStats);
         if (heapStats->totalObjectSpace() >= used)
             break;
     }
 }
 
 class IntWrapper : public GarbageCollectedFinalized<IntWrapper> {
-    DECLARE_GC_INFO
 public:
     static IntWrapper* create(int x)
     {
         return new IntWrapper(x);
     }
 
     virtual ~IntWrapper()
     {
         ++s_destructorCalls;
     }
@@ skipping 94 matching lines @@
 // sizes. This is done in a different way on 32 bit and 64 bit, so we have to
 // have some slack in the tests.
 template<typename T>
 void CheckWithSlack(T expected, T actual, int slack)
 {
     EXPECT_LE(expected, actual);
     EXPECT_GE((intptr_t)expected + slack, (intptr_t)actual);
 }
 
 class TraceCounter : public GarbageCollectedFinalized<TraceCounter> {
-    DECLARE_GC_INFO
 public:
     static TraceCounter* create()
     {
         return new TraceCounter();
     }
 
     void trace(Visitor*) { m_traceCount++; }
 
     int traceCount() { return m_traceCount; }
 
 private:
     TraceCounter()
         : m_traceCount(0)
     {
     }
 
     int m_traceCount;
 };
 
 class ClassWithMember : public GarbageCollected<ClassWithMember> {
-    DECLARE_GC_INFO
 public:
     static ClassWithMember* create()
     {
         return new ClassWithMember();
     }
 
     void trace(Visitor* visitor)
     {
         EXPECT_TRUE(visitor->isMarked(this));
         if (!traceCount())
             EXPECT_FALSE(visitor->isMarked(m_traceCounter));
         else
             EXPECT_TRUE(visitor->isMarked(m_traceCounter));
 
         visitor->trace(m_traceCounter);
     }
 
     int traceCount() { return m_traceCounter->traceCount(); }
 
 private:
     ClassWithMember()
         : m_traceCounter(TraceCounter::create())
     { }
 
     Member<TraceCounter> m_traceCounter;
 };
 
 class SimpleFinalizedObject : public GarbageCollectedFinalized<SimpleFinalizedObject> {
-    DECLARE_GC_INFO
 public:
     static SimpleFinalizedObject* create()
     {
         return new SimpleFinalizedObject();
     }
 
     ~SimpleFinalizedObject()
     {
         ++s_destructorCalls;
     }
 
     static int s_destructorCalls;
 
     void trace(Visitor*) { }
 
 private:
     SimpleFinalizedObject() { }
 };
 
 int SimpleFinalizedObject::s_destructorCalls = 0;
 
 class TestTypedHeapClass : public GarbageCollected<TestTypedHeapClass> {
-    DECLARE_GC_INFO
 public:
     static TestTypedHeapClass* create()
     {
         return new TestTypedHeapClass();
     }
 
     void trace(Visitor*) { }
 
 private:
     TestTypedHeapClass() { }
 };
 
 class Bar : public GarbageCollectedFinalized<Bar> {
-    DECLARE_GC_INFO
 public:
     static Bar* create()
     {
         return new Bar();
     }
 
     void finalize()
     {
         EXPECT_TRUE(m_magic == magic);
         m_magic = 0;
@@ skipping 10 matching lines @@
     Bar()
         : m_magic(magic)
     {
         s_live++;
     }
 };
 
 unsigned Bar::s_live = 0;
 
 class Baz : public GarbageCollected<Baz> {
-    DECLARE_GC_INFO
 public:
     static Baz* create(Bar* bar)
     {
         return new Baz(bar);
     }
 
     void trace(Visitor* visitor)
     {
         visitor->trace(m_bar);
     }
@@ skipping 74 matching lines @@
             m_bars[i] = Bar::create();
             m_width++;
         }
     }
 
     unsigned m_width;
     Member<Bar> m_bars[width];
 };
 
 class ConstructorAllocation : public GarbageCollected<ConstructorAllocation> {
-    DECLARE_GC_INFO
 public:
     static ConstructorAllocation* create() { return new ConstructorAllocation(); }
 
     void trace(Visitor* visitor) { visitor->trace(m_intWrapper); }
 
 private:
     ConstructorAllocation()
     {
         m_intWrapper = IntWrapper::create(42);
     }
 
     Member<IntWrapper> m_intWrapper;
 };
 
 class LargeObject : public GarbageCollectedFinalized<LargeObject> {
-    DECLARE_GC_INFO
 public:
     ~LargeObject()
     {
         s_destructorCalls++;
     }
     static LargeObject* create() { return new LargeObject(); }
     char get(size_t i) { return m_data[i]; }
     void set(size_t i, char c) { m_data[i] = c; }
     size_t length() { return s_length; }
     void trace(Visitor* visitor)
     {
         visitor->trace(m_intWrapper);
     }
     static int s_destructorCalls;
 
 private:
     static const size_t s_length = 1024*1024;
     LargeObject()
     {
         m_intWrapper = IntWrapper::create(23);
     }
     Member<IntWrapper> m_intWrapper;
     char m_data[s_length];
 };
 
 int LargeObject::s_destructorCalls = 0;
 
 class RefCountedAndGarbageCollected : public RefCountedGarbageCollected<RefCountedAndGarbageCollected> {
-    DECLARE_GC_INFO
 public:
     static PassRefPtr<RefCountedAndGarbageCollected> create()
     {
         return adoptRef(new RefCountedAndGarbageCollected());
     }
 
     ~RefCountedAndGarbageCollected()
     {
         ++s_destructorCalls;
     }
 
     void trace(Visitor*) { }
 
     static int s_destructorCalls;
 
 private:
     RefCountedAndGarbageCollected()
     {
     }
 };
 
 int RefCountedAndGarbageCollected::s_destructorCalls = 0;
 
 class RefCountedAndGarbageCollected2 : public HeapTestOtherSuperClass, public RefCountedGarbageCollected<RefCountedAndGarbageCollected2> {
-    DECLARE_GC_INFO
 public:
     static RefCountedAndGarbageCollected2* create()
     {
         return adoptRefCountedGarbageCollected(new RefCountedAndGarbageCollected2());
     }
 
     ~RefCountedAndGarbageCollected2()
     {
         ++s_destructorCalls;
     }
@@ skipping 139 matching lines @@
     }
 
     Member<Bar> m_strongBar;
     WeakMember<Bar> m_weakBar;
 };
 
 
 class SuperClass;
 
 class PointsBack : public RefCountedWillBeGarbageCollectedFinalized<PointsBack> {
-    DECLARE_GC_INFO;
 public:
     static PassRefPtrWillBeRawPtr<PointsBack> create()
     {
         return adoptRefWillBeNoop(new PointsBack());
     }
 
     ~PointsBack()
     {
         --s_aliveCount;
     }
@@ skipping 18 matching lines @@
     {
         ++s_aliveCount;
     }
 
     RawPtrWillBeWeakMember<SuperClass> m_backPointer;
 };
 
 int PointsBack::s_aliveCount = 0;
 
 class SuperClass : public RefCountedWillBeGarbageCollectedFinalized<SuperClass> {
-    DECLARE_GC_INFO;
 public:
     static PassRefPtrWillBeRawPtr<SuperClass> create(PassRefPtrWillBeRawPtr<PointsBack> pointsBack)
     {
         return adoptRefWillBeNoop(new SuperClass(pointsBack));
     }
 
     virtual ~SuperClass()
     {
 #if !ENABLE_OILPAN
         m_pointsBack->setBackPointer(0);
@@ skipping 26 matching lines @@
         m_pointsBack->setBackPointer(this);
         ++s_aliveCount;
     }
 
 private:
     RefPtrWillBeMember<PointsBack> m_pointsBack;
 };
 
 int SuperClass::s_aliveCount = 0;
 class SubData : public NoBaseWillBeGarbageCollectedFinalized<SubData> {
-    DECLARE_GC_INFO
 public:
     SubData() { ++s_aliveCount; }
     ~SubData() { --s_aliveCount; }
 
     void trace(Visitor*) { }
 
     static int s_aliveCount;
 };
 
 int SubData::s_aliveCount = 0;
@@ skipping 27 matching lines @@
         ++s_aliveCount;
     }
 
 private:
     OwnPtrWillBeMember<SubData> m_data;
 };
 
 int SubClass::s_aliveCount = 0;
 
 class TransitionRefCounted : public RefCountedWillBeRefCountedGarbageCollected<TransitionRefCounted> {
-    DECLARE_GC_INFO
 public:
     static PassRefPtrWillBeRawPtr<TransitionRefCounted> create()
     {
         return adoptRefCountedWillBeRefCountedGarbageCollected(new TransitionRefCounted());
     }
 
     ~TransitionRefCounted()
     {
         --s_aliveCount;
     }
@@ skipping 553 matching lines @@
     }
     HeapStats backToInitial;
     clearOutOldGarbage(&backToInitial);
     EXPECT_TRUE(initialHeapSize == backToInitial);
     EXPECT_EQ(11, IntWrapper::s_destructorCalls);
     EXPECT_EQ(11, LargeObject::s_destructorCalls);
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
 }
 
 class Container : public GarbageCollected<Container> {
-    DECLARE_GC_INFO
 public:
     static Container* create() { return new Container(); }
     HeapHashMap<Member<IntWrapper>, Member<IntWrapper> > map;
     HeapHashSet<Member<IntWrapper> > set;
     HeapHashSet<Member<IntWrapper> > set2;
     HeapVector<Member<IntWrapper>, 2> vector;
     void trace(Visitor* visitor)
     {
         visitor->trace(map);
         visitor->trace(set);
         visitor->trace(set2);
         visitor->trace(vector);
     }
 };
 
 struct ShouldBeTraced {
     explicit ShouldBeTraced(IntWrapper* wrapper) : m_wrapper(wrapper) { }
     void trace(Visitor* visitor) { visitor->trace(m_wrapper); }
     Member<IntWrapper> m_wrapper;
 };
 
 class OffHeapContainer : public GarbageCollectedFinalized<OffHeapContainer> {
-    DECLARE_GC_INFO
 public:
     static OffHeapContainer* create() { return new OffHeapContainer(); }
 
     OffHeapContainer()
     {
         m_deque1.append(ShouldBeTraced(IntWrapper::create(1)));
         m_vector1.append(ShouldBeTraced(IntWrapper::create(2)));
         m_deque2.append(IntWrapper::create(3));
         m_vector2.append(IntWrapper::create(4));
         m_hashSet.add(IntWrapper::create(5));
@@ skipping 767 matching lines @@
 
     it->value.append(IntWrapper::create(42));
     EXPECT_EQ(1u, map->get(key).size());
 
     Persistent<HeapHashMap<void*, IntVector> > keepAlive(map);
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(1u, map->get(key).size());
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 }
 
-DEFINE_GC_INFO(Bar);
-DEFINE_GC_INFO(Baz);
-DEFINE_GC_INFO(ClassWithMember);
-DEFINE_GC_INFO(ConstructorAllocation);
-DEFINE_GC_INFO(Container);
-DEFINE_GC_INFO(HeapAllocatedArray);
-DEFINE_GC_INFO(HeapTestSuperClass);
-DEFINE_GC_INFO(IntWrapper);
-DEFINE_GC_INFO(LargeObject);
-DEFINE_GC_INFO(OffHeapContainer);
-DEFINE_GC_INFO(PointsBack);
-DEFINE_GC_INFO(RefCountedAndGarbageCollected);
-DEFINE_GC_INFO(RefCountedAndGarbageCollected2);
-DEFINE_GC_INFO(SimpleFinalizedObject);
-DEFINE_GC_INFO(SimpleObject);
-DEFINE_GC_INFO(SuperClass);
-DEFINE_GC_INFO(SubData);
-DEFINE_GC_INFO(TestTypedHeapClass);
-DEFINE_GC_INFO(TraceCounter);
-DEFINE_GC_INFO(TransitionRefCounted);
-
 } // namespace