Oilpan: Support nested pre-finalizers

Source/platform/heap/HeapTest.cpp

Index: Source/platform/heap/HeapTest.cpp
diff --git a/Source/platform/heap/HeapTest.cpp b/Source/platform/heap/HeapTest.cpp
index d31058a26d4c83d2b8702e372d55b31eee5c8167..b02ba05eb13113493a6ae3bc6a416a7aa88efd12 100644
--- a/Source/platform/heap/HeapTest.cpp
+++ b/Source/platform/heap/HeapTest.cpp
@@ -648,7 +648,7 @@ protected:
         BookEnd()
             : m_store(nullptr)
         {
-            ThreadState::current()->registerPreFinalizer(*this);
+            ThreadState::current()->registerPreFinalizer(this);
         }
 
         void initialize(PersistentStore* store)
@@ -1192,25 +1192,25 @@ private:
 
 bool Observable::s_willFinalizeWasCalled = false;
 
-class ObservableWithPreFinalizer : public GarbageCollected<ObservableWithPreFinalizer> {
+class ObservableWithPreFinalizer : public GarbageCollectedFinalized<ObservableWithPreFinalizer> {

[haraken, 2015/06/24 07:59:28]

This was a bug -- ObservableWithPreFinalizer should be
GarbageCollected"Finalized". I'm wondering why the GC plugin cannot detect the
error.

     USING_PRE_FINALIZER(ObservableWithPreFinalizer, dispose);
 public:
     static ObservableWithPreFinalizer* create() { return new ObservableWithPreFinalizer();  }
     ~ObservableWithPreFinalizer() { m_wasDestructed = true; }
-    DEFINE_INLINE_TRACE() { }
+    DEFINE_INLINE_VIRTUAL_TRACE() { }

[haraken, 2015/06/24 07:59:27]

Not related to this CL, it took me a couple of hours to notice that this VIRTUAL
is missing. It would be great if the GC plugin could detect the error.

[sof, 2015/06/24 11:21:56]

Please notice that the GC plugin doesn't run inside of platform/heap/ :-)

[haraken, 2015/06/24 12:54:01]

Ah, makes sense; thanks!

     void dispose()
     {
-        ThreadState::current()->unregisterPreFinalizer(*this);
+        ThreadState::current()->unregisterPreFinalizer(this);
         EXPECT_FALSE(m_wasDestructed);
         s_disposeWasCalled = true;
     }
     static bool s_disposeWasCalled;
 
-private:
-    explicit ObservableWithPreFinalizer()
+protected:
+    ObservableWithPreFinalizer()
         : m_wasDestructed(false)
     {
-        ThreadState::current()->registerPreFinalizer(*this);
+        ThreadState::current()->registerPreFinalizer(this);
     }
 
     bool m_wasDestructed;
@@ -1218,6 +1218,57 @@ private:
 
 bool ObservableWithPreFinalizer::s_disposeWasCalled = false;
 
+class ObservableWithPreFinalizerMixin : public GarbageCollectedMixin {
+    USING_PRE_FINALIZER(ObservableWithPreFinalizerMixin, dispose);
+public:
+    ~ObservableWithPreFinalizerMixin() { m_wasDestructed = true; }
+    DEFINE_INLINE_VIRTUAL_TRACE() { }
+    void dispose()
+    {
+        EXPECT_FALSE(m_wasDestructed);
+        s_disposeWasCalled = true;
+    }
+    static bool s_disposeWasCalled;
+
+protected:
+    ObservableWithPreFinalizerMixin()
+        : m_wasDestructed(false)
+    {
+        ThreadState::current()->registerPreFinalizer(this);
+    }
+
+    bool m_wasDestructed;
+};
+
+bool ObservableWithPreFinalizerMixin::s_disposeWasCalled = false;
+
+class ObservableWithPreFinalizerSubClass : public ObservableWithPreFinalizer, public ObservableWithPreFinalizerMixin {
+    USING_GARBAGE_COLLECTED_MIXIN(ObservableWithPreFinalizerSubClass);
+    USING_PRE_FINALIZER(ObservableWithPreFinalizerSubClass, dispose);
+public:
+    static ObservableWithPreFinalizerSubClass* create() { return new ObservableWithPreFinalizerSubClass();  }
+    ~ObservableWithPreFinalizerSubClass() { m_wasDestructed = true; }
+    DEFINE_INLINE_VIRTUAL_TRACE() { }
+    void dispose()
+    {
+        EXPECT_FALSE(m_wasDestructed);
+        s_disposeWasCalled = true;
+    }
+    static bool s_disposeWasCalled;
+
+protected:
+    ObservableWithPreFinalizerSubClass()
+        : ObservableWithPreFinalizer()
+        , m_wasDestructed(false)
+    {
+        ThreadState::current()->registerPreFinalizer(this);
+    }
+
+    bool m_wasDestructed;
+};
+
+bool ObservableWithPreFinalizerSubClass::s_disposeWasCalled = false;
+
 template <typename T> class FinalizationObserver : public GarbageCollected<FinalizationObserver<T>> {
 public:
     static FinalizationObserver* create(T* data) { return new FinalizationObserver(data); }
@@ -1603,7 +1654,7 @@ public:
     PreFinalizationAllocator(Persistent<IntWrapper>* wrapper)
         : m_wrapper(wrapper)
     {
-        ThreadState::current()->registerPreFinalizer(*this);
+        ThreadState::current()->registerPreFinalizer(this);
     }
 
     void dispose()
@@ -3616,7 +3667,7 @@ TEST(HeapTest, PreFinalizer)
     Observable::s_willFinalizeWasCalled = false;
     {
         Observable* foo = Observable::create(Bar::create());
-        ThreadState::current()->registerPreFinalizer(*foo);
+        ThreadState::current()->registerPreFinalizer(foo);
     }
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
     EXPECT_TRUE(Observable::s_willFinalizeWasCalled);
@@ -3627,8 +3678,8 @@ TEST(HeapTest, PreFinalizerIsNotCalledIfUnregistered)
     Observable::s_willFinalizeWasCalled = false;
     {
         Observable* foo = Observable::create(Bar::create());
-        ThreadState::current()->registerPreFinalizer(*foo);
-        ThreadState::current()->unregisterPreFinalizer(*foo);
+        ThreadState::current()->registerPreFinalizer(foo);
+        ThreadState::current()->unregisterPreFinalizer(foo);
     }
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
     EXPECT_FALSE(Observable::s_willFinalizeWasCalled);
@@ -3643,6 +3694,19 @@ TEST(HeapTest, PreFinalizerUnregistersItself)
     // Don't crash, and assertions don't fail.
 }
 
+TEST(HeapTest, NestedPreFinalizer)
+{
+    ObservableWithPreFinalizer::s_disposeWasCalled = false;
+    ObservableWithPreFinalizerSubClass::s_disposeWasCalled = false;
+    ObservableWithPreFinalizerMixin::s_disposeWasCalled = false;
+    ObservableWithPreFinalizerSubClass::create();
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    EXPECT_TRUE(ObservableWithPreFinalizer::s_disposeWasCalled);
+    EXPECT_TRUE(ObservableWithPreFinalizerSubClass::s_disposeWasCalled);
+    EXPECT_TRUE(ObservableWithPreFinalizerMixin::s_disposeWasCalled);
+    // Don't crash, and assertions don't fail.
+}
+
 TEST(HeapTest, Comparisons)
 {
     Persistent<Bar> barPersistent = Bar::create();