Oilpan: Support nested pre-finalizers

Source/platform/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 630 matching lines @@
         Persistent<BookEnd> m_bookend;
         int* m_gcCount;
     };
 
     class BookEnd final : public GarbageCollected<BookEnd> {
         USING_PRE_FINALIZER(BookEnd, dispose);
     public:
         BookEnd()
             : m_store(nullptr)
         {
-            ThreadState::current()->registerPreFinalizer(*this);
+            ThreadState::current()->registerPreFinalizer(this);
         }
 
         void initialize(PersistentStore* store)
         {
             m_store = store;
         }
 
         void dispose()
         {
             delete m_store;
@@ skipping 523 matching lines @@
         , m_wasDestructed(false)
     {
     }
 
     Member<Bar> m_bar;
     bool m_wasDestructed;
 };
 
 bool Observable::s_willFinalizeWasCalled = false;
 
-class ObservableWithPreFinalizer : public GarbageCollected<ObservableWithPreFinalizer> {
+class ObservableWithPreFinalizer : public GarbageCollectedFinalized<ObservableWithPreFinalizer> {
     USING_PRE_FINALIZER(ObservableWithPreFinalizer, dispose);
 public:
     static ObservableWithPreFinalizer* create() { return new ObservableWithPreFinalizer();  }
     ~ObservableWithPreFinalizer() { m_wasDestructed = true; }
     DEFINE_INLINE_TRACE() { }
     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;
 };
 
 bool ObservableWithPreFinalizer::s_disposeWasCalled = false;
 
+bool s_disposeWasCalledForPreFinalizerBase = false;
+bool s_disposeWasCalledForPreFinalizerMixin = false;
+bool s_disposeWasCalledForPreFinalizerSubClass = false;
+
+class PreFinalizerBase : public GarbageCollectedFinalized<PreFinalizerBase> {
+    USING_PRE_FINALIZER(PreFinalizerBase, dispose);
+public:
+    static PreFinalizerBase* create() { return new PreFinalizerBase();  }
+    ~PreFinalizerBase() { m_wasDestructed = true; }
+    DEFINE_INLINE_VIRTUAL_TRACE() { }
+    void dispose()
+    {
+        EXPECT_FALSE(s_disposeWasCalledForPreFinalizerBase);
+        EXPECT_TRUE(s_disposeWasCalledForPreFinalizerSubClass);
+        EXPECT_FALSE(m_wasDestructed);
+        s_disposeWasCalledForPreFinalizerBase = true;
+    }
+
+protected:
+    PreFinalizerBase()
+        : m_wasDestructed(false)
+    {
+        ThreadState::current()->registerPreFinalizer(this);
+    }
+    bool m_wasDestructed;
+};
+
+class PreFinalizerMixin : public GarbageCollectedMixin {
+    USING_PRE_FINALIZER(PreFinalizerMixin, dispose);
+public:
+    ~PreFinalizerMixin() { m_wasDestructed = true; }
+    DEFINE_INLINE_VIRTUAL_TRACE() { }
+    void dispose()
+    {
+        EXPECT_FALSE(s_disposeWasCalledForPreFinalizerMixin);
+        EXPECT_FALSE(m_wasDestructed);
+        s_disposeWasCalledForPreFinalizerMixin = true;
+    }
+
+protected:
+    PreFinalizerMixin()
+        : m_wasDestructed(false)
+    {
+        ThreadState::current()->registerPreFinalizer(this);
+    }
+    bool m_wasDestructed;
+};
+
+class PreFinalizerSubClass : public PreFinalizerBase, public PreFinalizerMixin {
+    USING_GARBAGE_COLLECTED_MIXIN(PreFinalizerSubClass);
+    USING_PRE_FINALIZER(PreFinalizerSubClass, dispose);
+public:
+    static PreFinalizerSubClass* create() { return new PreFinalizerSubClass();  }
+    ~PreFinalizerSubClass() { m_wasDestructed = true; }
+    DEFINE_INLINE_VIRTUAL_TRACE() { }
+    void dispose()
+    {
+        EXPECT_FALSE(s_disposeWasCalledForPreFinalizerBase);
+        EXPECT_FALSE(s_disposeWasCalledForPreFinalizerSubClass);
+        EXPECT_FALSE(m_wasDestructed);
+        s_disposeWasCalledForPreFinalizerSubClass = true;
+    }
+
+protected:
+    PreFinalizerSubClass()
+        : m_wasDestructed(false)
+    {
+        ThreadState::current()->registerPreFinalizer(this);
+    }
+    bool m_wasDestructed;
+};
+
 template <typename T> class FinalizationObserver : public GarbageCollected<FinalizationObserver<T>> {
 public:
     static FinalizationObserver* create(T* data) { return new FinalizationObserver(data); }
     bool didCallWillFinalize() const { return m_didCallWillFinalize; }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->template registerWeakMembers<FinalizationObserver<T>, &FinalizationObserver<T>::zapWeakMembers>(this);
     }
 
@@ skipping 365 matching lines @@
 private:
     Persistent<IntWrapper>* m_wrapper;
 };
 
 class PreFinalizationAllocator : public GarbageCollectedFinalized<PreFinalizationAllocator> {
     USING_PRE_FINALIZER(PreFinalizationAllocator, dispose);
 public:
     PreFinalizationAllocator(Persistent<IntWrapper>* wrapper)
         : m_wrapper(wrapper)
     {
-        ThreadState::current()->registerPreFinalizer(*this);
+        ThreadState::current()->registerPreFinalizer(this);
     }
 
     void dispose()
     {
         for (int i = 0; i < 10; ++i)
             *m_wrapper = IntWrapper::create(42);
         for (int i = 0; i < 512; ++i)
             new OneKiloByteObject();
         for (int i = 0; i < 32; ++i)
             LargeHeapObject::create();
@@ skipping 1992 matching lines @@
     EXPECT_TRUE(FinalizationObserverWithHashMap::s_didCallWillFinalize);
 
     FinalizationObserverWithHashMap::clearObservers();
 }
 
 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);
 }
 
 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);
 }
 
 TEST(HeapTest, PreFinalizerUnregistersItself)
 {
     ObservableWithPreFinalizer::s_disposeWasCalled = false;
     ObservableWithPreFinalizer::create();
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
     EXPECT_TRUE(ObservableWithPreFinalizer::s_disposeWasCalled);
     // Don't crash, and assertions don't fail.
 }
 
+TEST(HeapTest, NestedPreFinalizer)
+{
+    s_disposeWasCalledForPreFinalizerBase = false;
+    s_disposeWasCalledForPreFinalizerSubClass = false;
+    s_disposeWasCalledForPreFinalizerMixin = false;
+    PreFinalizerSubClass::create();
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    EXPECT_TRUE(s_disposeWasCalledForPreFinalizerBase);
+    EXPECT_TRUE(s_disposeWasCalledForPreFinalizerSubClass);
+    EXPECT_TRUE(s_disposeWasCalledForPreFinalizerMixin);
+    // Don't crash, and assertions don't fail.
+}
+
 TEST(HeapTest, Comparisons)
 {
     Persistent<Bar> barPersistent = Bar::create();
     Persistent<Foo> fooPersistent = Foo::create(barPersistent);
     EXPECT_TRUE(barPersistent != fooPersistent);
     barPersistent = fooPersistent;
     EXPECT_TRUE(barPersistent == fooPersistent);
 }
 
 TEST(HeapTest, CheckAndMarkPointer)
@@ skipping 2522 matching lines @@
 {
     Persistent<ClassWithMember> object = ClassWithMember::create();
     EXPECT_EQ(0, object->traceCount());
     TestMixinAllocatingObject* mixin = TestMixinAllocatingObject::create(object.get());
     EXPECT_TRUE(mixin);
     EXPECT_GT(object->traceCount(), 0);
     EXPECT_GT(mixin->traceCount(), 0);
 }
 
 } // namespace blink