Alternative approach to supporting ref counting and garbage collection

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 540 matching lines @@
         : Bar()
         , m_strongBar(strongBar)
         , m_weakBar(weakBar)
     {
     }
 
     Member<Bar> m_strongBar;
     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();
 }
 
 TEST(HeapTest, SimpleAllocation)
 {
     // Get initial heap stats.
     HeapStats initialHeapStats;
     getHeapStats(&initialHeapStats);
@@ skipping 352 matching lines @@
     EXPECT_TRUE(barPersistent == fooPersistent);
 }
 
 DEFINE_GC_INFO(Bar);
 DEFINE_GC_INFO(Baz);
 DEFINE_GC_INFO(ClassWithMember);
 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);
 
 } // namespace