Oilpan: Support polymorphic objects in HeapVectorBackings

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 3925 matching lines @@
     }
     DEFINE_INLINE_TRACE()
     {
     }
 
     static int s_destructorCalls;
 };
 
 int InlinedVectorObject::s_destructorCalls = 0;
 
+class InlinedVectorObjectWithVtable {
+    ALLOW_ONLY_INLINE_ALLOCATION();
+public:
+    InlinedVectorObjectWithVtable()
+    {
+    }
+    ~InlinedVectorObjectWithVtable()
+    {
+        s_destructorCalls++;
+    }
+    virtual void virtualMethod() { }
+    DEFINE_INLINE_TRACE()
+    {
+    }
+
+    static int s_destructorCalls;
+};
+
+int InlinedVectorObjectWithVtable::s_destructorCalls = 0;
+
 } // namespace blink
 
 WTF_ALLOW_MOVE_AND_INIT_WITH_MEM_FUNCTIONS(blink::InlinedVectorObject);
 
 namespace blink {
 
 class InlinedVectorObjectWrapper final : public GarbageCollectedFinalized<InlinedVectorObjectWrapper> {
 public:
     InlinedVectorObjectWrapper()
     {
@@ skipping 12 matching lines @@
         visitor->trace(m_vector2);
         visitor->trace(m_vector3);
     }
 
 private:
     HeapVector<InlinedVectorObject> m_vector1;
     HeapVector<InlinedVectorObject, 1> m_vector2;
     HeapVector<InlinedVectorObject, 2> m_vector3;
 };
 
+class InlinedVectorObjectWithVtableWrapper final : public GarbageCollectedFinalized<InlinedVectorObjectWithVtableWrapper> {
+public:
+    InlinedVectorObjectWithVtableWrapper()
+    {
+        InlinedVectorObjectWithVtable i1, i2;
+        m_vector1.append(i1);
+        m_vector1.append(i2);
+        m_vector2.append(i1);
+        m_vector2.append(i2); // This allocates an out-of-line buffer.
+        m_vector3.append(i1);
+        m_vector3.append(i2);
+    }
+
+    DEFINE_INLINE_TRACE()
+    {
+        visitor->trace(m_vector1);
+        visitor->trace(m_vector2);
+        visitor->trace(m_vector3);
+    }
+
+private:
+    HeapVector<InlinedVectorObjectWithVtable> m_vector1;
+    HeapVector<InlinedVectorObjectWithVtable, 1> m_vector2;
+    HeapVector<InlinedVectorObjectWithVtable, 2> m_vector3;
+};
+
 TEST(HeapTest, VectorDestructors)
 {
     clearOutOldGarbage();
     InlinedVectorObject::s_destructorCalls = 0;
     {
         HeapVector<InlinedVectorObject> vector;
         InlinedVectorObject i1, i2;
         vector.append(i1);
         vector.append(i2);
     }
@@ skipping 27 matching lines @@
     InlinedVectorObject::s_destructorCalls = 0;
     {
         new InlinedVectorObjectWrapper();
         Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
         EXPECT_EQ(2, InlinedVectorObject::s_destructorCalls);
     }
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
     EXPECT_LE(8, InlinedVectorObject::s_destructorCalls);
 }
 
+TEST(HeapTest, VectorDestructorsWithVtable)
+{
+    clearOutOldGarbage();
+    InlinedVectorObjectWithVtable::s_destructorCalls = 0;
+    {
+        HeapVector<InlinedVectorObjectWithVtable> vector;
+        InlinedVectorObjectWithVtable i1, i2;
+        vector.append(i1);
+        vector.append(i2);
+    }
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    EXPECT_EQ(4, InlinedVectorObjectWithVtable::s_destructorCalls);
+
+    InlinedVectorObjectWithVtable::s_destructorCalls = 0;
+    {
+        HeapVector<InlinedVectorObjectWithVtable, 1> vector;
+        InlinedVectorObjectWithVtable i1, i2;
+        vector.append(i1);
+        vector.append(i2); // This allocates an out-of-line buffer.
+    }
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    EXPECT_EQ(5, InlinedVectorObjectWithVtable::s_destructorCalls);
+
+    InlinedVectorObjectWithVtable::s_destructorCalls = 0;
+    {
+        HeapVector<InlinedVectorObjectWithVtable, 2> vector;
+        InlinedVectorObjectWithVtable i1, i2;
+        vector.append(i1);
+        vector.append(i2);
+    }
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    EXPECT_EQ(4, InlinedVectorObjectWithVtable::s_destructorCalls);
+
+    InlinedVectorObjectWithVtable::s_destructorCalls = 0;
+    {
+        new InlinedVectorObjectWithVtableWrapper();
+        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+        EXPECT_EQ(3, InlinedVectorObjectWithVtable::s_destructorCalls);
+    }
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
+    EXPECT_EQ(9, InlinedVectorObjectWithVtable::s_destructorCalls);
+}
+
 template<typename Set>
 void rawPtrInHashHelper()
 {
     Set set;
     set.add(new int(42));
     set.add(new int(42));
     EXPECT_EQ(2u, set.size());
     for (typename Set::iterator it = set.begin(); it != set.end(); ++it) {
         EXPECT_EQ(42, **it);
         delete *it;
@@ skipping 1932 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