Oilpan: Allocation should be allowed in 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 2b7c7bf243e5e9e46495205c16c421f7360469f8..d371cbc49fb56bc759433c9f9dcad151c8c60be7 100644
--- a/Source/platform/heap/HeapTest.cpp
+++ b/Source/platform/heap/HeapTest.cpp
@@ -1597,6 +1597,31 @@ 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);
+    }
+
+    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();
+    }
+
+    DEFINE_INLINE_TRACE() { }
+
+private:
+    Persistent<IntWrapper>* m_wrapper;
+};
+
 TEST(HeapTest, Transition)
 {
     {
@@ -4303,6 +4328,31 @@ TEST(HeapTest, AllocationDuringFinalization)
     EXPECT_EQ(32, LargeHeapObject::s_destructorCalls);
 }
 
+TEST(HeapTest, AllocationDuringPrefinalizer)
+{
+    clearOutOldGarbage();
+    IntWrapper::s_destructorCalls = 0;
+    OneKiloByteObject::s_destructorCalls = 0;
+    LargeHeapObject::s_destructorCalls = 0;
+
+    Persistent<IntWrapper> wrapper;
+    new PreFinalizationAllocator(&wrapper);
+
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    EXPECT_EQ(0, IntWrapper::s_destructorCalls);
+    EXPECT_EQ(0, OneKiloByteObject::s_destructorCalls);
+    EXPECT_EQ(0, LargeHeapObject::s_destructorCalls);
+    // Check that the wrapper allocated during finalization is not
+    // swept away and zapped later in the same sweeping phase.
+    EXPECT_EQ(42, wrapper->value());
+
+    wrapper.clear();
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    EXPECT_EQ(42, IntWrapper::s_destructorCalls);

[sof, 2015/06/18 12:18:03]

Could you add a comment where the 42 IntWrappers come from; saves a bit of time
for anyone trying to make sense of the pass condition later.

[haraken, 2015/06/18 16:30:13]

Done.

+    EXPECT_EQ(512, OneKiloByteObject::s_destructorCalls);
+    EXPECT_EQ(32, LargeHeapObject::s_destructorCalls);
+}
+
 class SimpleClassWithDestructor {
 public:
     SimpleClassWithDestructor() { }