[oilpan] Resurrect a loop-back persistent handle in RefCountedHeapAllocated

Source/heap/tests/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 330 matching lines @@
         ASSERT_EQ(2, HeapTestSubClass::s_destructorCalls);
         ASSERT_EQ(3, HeapTestSuperClass::s_destructorCalls);
         // Destructors not called again when sweeping again.
         Heap::sweep();
         ASSERT_EQ(2, HeapTestSubClass::s_destructorCalls);
         ASSERT_EQ(3, HeapTestSuperClass::s_destructorCalls);
     }
 
     static void refCountedHeapAllocatedTest()
     {
+        RefCountedAndHeapAllocated::s_destructorCalls = 0;
+        RefCountedAndHeapAllocated2::s_destructorCalls = 0;
         {
             RefPtr<RefCountedAndHeapAllocated> o1 = RefCountedAndHeapAllocated::create();
             RefPtr<RefCountedAndHeapAllocated> o2 = RefCountedAndHeapAllocated::create();
             RefPtr<RefCountedAndHeapAllocated2> o3 = RefCountedAndHeapAllocated2::create();
             RefPtr<RefCountedAndHeapAllocated2> o4 = RefCountedAndHeapAllocated2::create();
             void* objects[4] = { o1.get(), o2.get(), o3.get(), o4.get() };
             RefCountedHeapAllocatedHandleVisitor visitor(4, objects);
             PersistentBase::visitRoots(&visitor);
             ASSERT_TRUE(visitor.validate());
 
             Heap::collectGarbage();
             ASSERT_EQ(0, RefCountedAndHeapAllocated::s_destructorCalls);
             ASSERT_EQ(0, RefCountedAndHeapAllocated2::s_destructorCalls);
         }
         Heap::collectGarbage();
         ASSERT_EQ(2, RefCountedAndHeapAllocated::s_destructorCalls);
         ASSERT_EQ(2, RefCountedAndHeapAllocated2::s_destructorCalls);
     }
 
+    static void refCountedHeapAllocatedWithHandlesTest()
+    {
+        RefCountedAndHeapAllocated::s_destructorCalls = 0;
+        RefCountedAndHeapAllocated2::s_destructorCalls = 0;
+        {
+            HandleScope scope;
+            Handle<RefCountedAndHeapAllocated> handle1;
+            Handle<RefCountedAndHeapAllocated> handle2;
+            {
+                RefPtr<RefCountedAndHeapAllocated> object1 = RefCountedAndHeapAllocated::create();
+                RefPtr<RefCountedAndHeapAllocated> object2 = RefCountedAndHeapAllocated::create();
+                handle1 = Handle<RefCountedAndHeapAllocated>(object1.get());
+                handle2 = Handle<RefCountedAndHeapAllocated>(object2.get());
+                void* objects[2] = { object1.get(), object2.get() };
+                RefCountedHeapAllocatedHandleVisitor visitor(2, objects);
+                PersistentBase::visitRoots(&visitor);
+                ASSERT_TRUE(visitor.validate());
+
+                Heap::collectGarbage();
+                ASSERT_EQ(0, RefCountedAndHeapAllocated::s_destructorCalls);
+            }
+            Heap::collectGarbage();
+            ASSERT_EQ(0, RefCountedAndHeapAllocated::s_destructorCalls);
+
+            // At this point, the reference counts of object1 and object2 are 0.
+            // Only handle1 and handle2 keep references to object1 and object2.
+            void* objects[] = { };
+            RefCountedHeapAllocatedHandleVisitor visitor(0, objects);
+            PersistentBase::visitRoots(&visitor);
+            ASSERT_TRUE(visitor.validate());
+
+            {
+                RefPtr<RefCountedAndHeapAllocated> object1(handle1.raw());
+                RefPtr<RefCountedAndHeapAllocated> object2(handle2.raw());
+                void* objects[2] = { object1.get(), object2.get() };
+                RefCountedHeapAllocatedHandleVisitor visitor(2, objects);
+                PersistentBase::visitRoots(&visitor);
+                ASSERT_TRUE(visitor.validate());
+
+                Heap::collectGarbage();
+                ASSERT_EQ(0, RefCountedAndHeapAllocated::s_destructorCalls);
+            }
+
+            Heap::collectGarbage();
+            ASSERT_EQ(0, RefCountedAndHeapAllocated::s_destructorCalls);
+        }
+        Heap::collectGarbage();
+        ASSERT_EQ(2, RefCountedAndHeapAllocated::s_destructorCalls);
+    }
+
     static void markTest();
     static void deepTest();
     static void wideTest();
     static void memberTest();
 };
 
 class Bar {
     DECLARE_GC_TYPE_MARKER
 public:
     Bar()
@@ skipping 197 matching lines @@
 TEST(heap, Finalization)
 {
     HeapTester::finalizationTest();
 }
 
 TEST(heap, RefCountedHeapAllocated)
 {
     HeapTester::refCountedHeapAllocatedTest();
 }
 
+TEST(heap, RefCountedHeapAllocatedWithHandles)
+{
+    HeapTester::refCountedHeapAllocatedWithHandlesTest();
+}
+
 TEST(heap, Mark)
 {
     HeapTester::markTest();
 }
 
 TEST(heap, Deep)
 {
     HeapTester::deepTest();
 }
 
 TEST(heap, Wide)
 {
     HeapTester::wideTest();
 }
 
 TEST(heap, Member)
 {
     HeapTester::memberTest();
 }
 
 } // namespace WebCore