Alternative approach to supporting ref counting and garbage collection

Source/heap/HeapTest.cpp

Index: Source/heap/HeapTest.cpp
diff --git a/Source/heap/HeapTest.cpp b/Source/heap/HeapTest.cpp
index 31f4fbf8600dbcbd7d8c9a898664d20eddb20b23..dda72be938cb1cb2e370631e90766a9c678b95e6 100644
--- a/Source/heap/HeapTest.cpp
+++ b/Source/heap/HeapTest.cpp
@@ -558,6 +558,199 @@ private:
     WeakMember<Bar> m_weakBar;
 };
 
+
+class SuperClass;
+
+class PointsBack : public GarbageCollectedFinalized<PointsBack>::FromRefCounted {
+    DECLARE_GC_INFO;
+public:
+    static Ptr<PointsBack>::FromPassRefPtr create()
+    {
+        return adoptRefWillBeNoop(new PointsBack());
+    }
+
+    ~PointsBack()
+    {
+        --s_aliveCount;
+    }
+
+    void setBackPointer(SuperClass* backPointer)
+    {
+        m_backPointer = backPointer;
+    }
+
+    SuperClass* backPointer() const { return m_backPointer; }
+
+    void trace(Visitor* visitor)
+    {
+#if ENABLE_OILPAN
+        visitor->trace(m_backPointer);
+#endif
+    }
+
+    static int s_aliveCount;
+private:
+    PointsBack() : m_backPointer(nullptr)
+    {
+        ++s_aliveCount;
+    }
+
+    WeakMember<SuperClass>::FromPtr m_backPointer;
+};
+
+int PointsBack::s_aliveCount = 0;
+
+class SuperClass : public GarbageCollectedFinalized<SuperClass>::FromRefCounted {
+    DECLARE_GC_INFO;
+public:
+    static Ptr<SuperClass>::FromPassRefPtr create(Ptr<PointsBack>::FromPassRefPtr pointsBack)
+    {
+        return adoptRefWillBeNoop(new SuperClass(pointsBack));
+    }
+
+    virtual ~SuperClass()
+    {
+#if !ENABLE_OILPAN
+        m_pointsBack->setBackPointer(0);
+#endif
+        --s_aliveCount;
+    }
+
+    void doStuff(Ptr<SuperClass>::FromPassRefPtr targetPass, PointsBack* pointsBack, int superClassCount)
+    {
+        Ptr<SuperClass>::FromRefPtr target = targetPass;
+        Heap::collectGarbage(ThreadState::HeapPointersOnStack);
+        EXPECT_EQ(pointsBack, target->pointsBack());
+        EXPECT_EQ(superClassCount, SuperClass::s_aliveCount);
+    }
+
+    virtual void trace(Visitor* visitor)
+    {
+#if ENABLE_OILPAN
+        visitor->trace(m_pointsBack);
+#endif
+    }
+
+    PointsBack* pointsBack() const { return m_pointsBack.get(); }
+
+    static int s_aliveCount;
+protected:
+    explicit SuperClass(Ptr<PointsBack>::FromPassRefPtr pointsBack)
+        : m_pointsBack(pointsBack)
+    {
+        m_pointsBack->setBackPointer(this);
+        ++s_aliveCount;
+    }
+
+private:
+    Member<PointsBack>::FromRefPtr m_pointsBack;
+};
+
+int SuperClass::s_aliveCount = 0;
+class SubData : public GarbageCollectedFinalized<SubData>::FromNoBase {
+    DECLARE_GC_INFO
+public:
+    SubData() { ++s_aliveCount; }
+    ~SubData() { --s_aliveCount; }
+
+    void trace(Visitor*) { }
+
+    static int s_aliveCount;
+};
+
+int SubData::s_aliveCount = 0;
+
+class SubClass : public SuperClass {
+public:
+    static Ptr<SubClass>::FromPassRefPtr create(Ptr<PointsBack>::FromPassRefPtr pointsBack)
+    {
+        return adoptRefWillBeNoop(new SubClass(pointsBack));
+    }
+
+    virtual ~SubClass()
+    {
+        --s_aliveCount;
+    }
+
+    virtual void trace(Visitor* visitor)
+    {
+#if ENABLE_OILPAN
+        SuperClass::trace(visitor);
+        visitor->trace(m_data);
+#endif
+    }
+
+    static int s_aliveCount;
+private:
+    explicit SubClass(Ptr<PointsBack>::FromPassRefPtr pointsBack)
+        : SuperClass(pointsBack)
+        , m_data(adoptPtrWillBeNoop(new SubData()))
+    {
+        ++s_aliveCount;
+    }
+
+private:
+    Member<SubData>::FromOwnPtr m_data;
+};
+
+int SubClass::s_aliveCount = 0;
+
+TEST(HeapTest, Transition)
+{
+    Heap::init();
+
+    {
+        Persistent<PointsBack>::FromRefPtr pointsBack1 = PointsBack::create();
+        Persistent<PointsBack>::FromRefPtr pointsBack2 = PointsBack::create();
+        Persistent<SuperClass>::FromRefPtr superClass = SuperClass::create(pointsBack1);
+        Persistent<SubClass>::FromRefPtr subClass = SubClass::create(pointsBack2);
+        EXPECT_EQ(2, PointsBack::s_aliveCount);
+        EXPECT_EQ(2, SuperClass::s_aliveCount);
+        EXPECT_EQ(1, SubClass::s_aliveCount);
+        EXPECT_EQ(1, SubData::s_aliveCount);
+
+        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
+        EXPECT_EQ(2, PointsBack::s_aliveCount);
+        EXPECT_EQ(2, SuperClass::s_aliveCount);
+        EXPECT_EQ(1, SubClass::s_aliveCount);
+        EXPECT_EQ(1, SubData::s_aliveCount);
+
+        superClass->doStuff(superClass.release(), pointsBack1.get(), 2);
+        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
+        EXPECT_EQ(2, PointsBack::s_aliveCount);
+        EXPECT_EQ(1, SuperClass::s_aliveCount);
+        EXPECT_EQ(1, SubClass::s_aliveCount);
+        EXPECT_EQ(1, SubData::s_aliveCount);
+        EXPECT_EQ(0, pointsBack1->backPointer());
+
+        pointsBack1.release();
+        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
+        EXPECT_EQ(1, PointsBack::s_aliveCount);
+        EXPECT_EQ(1, SuperClass::s_aliveCount);
+        EXPECT_EQ(1, SubClass::s_aliveCount);
+        EXPECT_EQ(1, SubData::s_aliveCount);
+
+        subClass->doStuff(subClass.release(), pointsBack2.get(), 1);
+        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
+        EXPECT_EQ(1, PointsBack::s_aliveCount);
+        EXPECT_EQ(0, SuperClass::s_aliveCount);
+        EXPECT_EQ(0, SubClass::s_aliveCount);
+        EXPECT_EQ(0, SubData::s_aliveCount);
+        EXPECT_EQ(0, pointsBack2->backPointer());
+
+        pointsBack2.release();
+        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
+        EXPECT_EQ(0, PointsBack::s_aliveCount);
+        EXPECT_EQ(0, SuperClass::s_aliveCount);
+        EXPECT_EQ(0, SubClass::s_aliveCount);
+        EXPECT_EQ(0, SubData::s_aliveCount);
+
+        EXPECT_TRUE(superClass == subClass);
+    }
+
+    Heap::shutdown();
+}
+
 TEST(HeapTest, Threading)
 {
     ThreadedHeapTester::test();
@@ -930,8 +1123,11 @@ DEFINE_GC_INFO(ConstructorAllocation);
 DEFINE_GC_INFO(HeapAllocatedArray);
 DEFINE_GC_INFO(IntWrapper);
 DEFINE_GC_INFO(LargeObject);
+DEFINE_GC_INFO(PointsBack);
 DEFINE_GC_INFO(RefCountedAndGarbageCollected);
 DEFINE_GC_INFO(SimpleFinalizedObject);
+DEFINE_GC_INFO(SuperClass);
+DEFINE_GC_INFO(SubData);
 DEFINE_GC_INFO(TestTypedHeapClass);
 DEFINE_GC_INFO(TraceCounter);