Oilpan: Remove adoptRefCountedGarbageCollected

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 804 matching lines @@
         m_intWrapper = IntWrapper::create(23);
     }
     Member<IntWrapper> m_intWrapper;
     char m_data[s_length];
 };
 
 int LargeObject::s_destructorCalls = 0;
 
 class RefCountedAndGarbageCollected : public RefCountedGarbageCollected<RefCountedAndGarbageCollected> {
 public:
-    static PassRefPtr<RefCountedAndGarbageCollected> create()
+    static RefCountedAndGarbageCollected* create()
     {
-        return adoptRef(new RefCountedAndGarbageCollected());
+        return new RefCountedAndGarbageCollected();
     }
 
     ~RefCountedAndGarbageCollected()
     {
         ++s_destructorCalls;
     }
 
     // These are here with their default implementations so you can break in
     // them in the debugger.
     void ref() { RefCountedGarbageCollected<RefCountedAndGarbageCollected>::ref(); }
     void deref() { RefCountedGarbageCollected<RefCountedAndGarbageCollected>::deref(); }
 
     void trace(Visitor*) { }
 
     static int s_destructorCalls;
 
 private:
     RefCountedAndGarbageCollected()
     {
     }
 };
 
 int RefCountedAndGarbageCollected::s_destructorCalls = 0;
 
 class RefCountedAndGarbageCollected2 : public HeapTestOtherSuperClass, public RefCountedGarbageCollected<RefCountedAndGarbageCollected2> {
 public:
     static RefCountedAndGarbageCollected2* create()
     {
-        return adoptRefCountedGarbageCollected(new RefCountedAndGarbageCollected2());
+        return new RefCountedAndGarbageCollected2();
     }
 
     ~RefCountedAndGarbageCollected2()
     {
         ++s_destructorCalls;
     }
 
     void trace(Visitor*) { }
 
     static int s_destructorCalls;
@@ skipping 393 matching lines @@
 private:
     OwnPtrWillBeMember<SubData> m_data;
 };
 
 int SubClass::s_aliveCount = 0;
 
 class TransitionRefCounted : public RefCountedWillBeRefCountedGarbageCollected<TransitionRefCounted> {
 public:
     static PassRefPtrWillBeRawPtr<TransitionRefCounted> create()
     {
-        return adoptRefWillBeRefCountedGarbageCollected(new TransitionRefCounted());
+        return adoptRefWillBeNoop(new TransitionRefCounted());
     }
 
     ~TransitionRefCounted()
     {
         --s_aliveCount;
     }
 
     void trace(Visitor* visitor) { }
 
     static int s_aliveCount;
@@ skipping 153 matching lines @@
 
     void trace(Visitor*) { }
 
 private:
     Persistent<IntWrapper>* m_wrapper;
 };
 
 TEST(HeapTest, Transition)
 {
     {
-        RefPtr<TransitionRefCounted> refCounted = TransitionRefCounted::create();
+        RefPtrWillBePersistent<TransitionRefCounted> refCounted = TransitionRefCounted::create();
         EXPECT_EQ(1, TransitionRefCounted::s_aliveCount);
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         EXPECT_EQ(1, TransitionRefCounted::s_aliveCount);
     }
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0, TransitionRefCounted::s_aliveCount);
 
     RefPtrWillBePersistent<PointsBack> pointsBack1 = PointsBack::create();
     RefPtrWillBePersistent<PointsBack> pointsBack2 = PointsBack::create();
     RefPtrWillBePersistent<SuperClass> superClass = SuperClass::create(pointsBack1);
@@ skipping 1280 matching lines @@
 struct ThingWithDestructorTraits : public HashTraits<ThingWithDestructor> {
     static const bool needsDestruction = true;
 };
 
 static void heapMapDestructorHelper(bool clearMaps)
 {
     HeapStats initialHeapStats;
     clearOutOldGarbage(&initialHeapStats);
     ThingWithDestructor::s_liveThingsWithDestructor = 0;
 
-    typedef HeapHashMap<WeakMember<IntWrapper>, RefPtr<RefCountedAndGarbageCollected> > RefMap;
+    typedef HeapHashMap<WeakMember<IntWrapper>, Member<RefCountedAndGarbageCollected> > RefMap;
 
     typedef HeapHashMap<
         WeakMember<IntWrapper>,
         ThingWithDestructor,
         DefaultHash<WeakMember<IntWrapper> >::Hash,
         HashTraits<WeakMember<IntWrapper> >,
         ThingWithDestructorTraits> Map;
 
     Persistent<Map> map(new Map());
     Persistent<RefMap> refMap(new RefMap());
@@ skipping 406 matching lines @@
 }
 
 TEST(HeapTest, RefCountedGarbageCollected)
 {
     RefCountedAndGarbageCollected::s_destructorCalls = 0;
     {
         RefPtr<RefCountedAndGarbageCollected> refPtr3;
         {
             Persistent<RefCountedAndGarbageCollected> persistent;
             {
-                RefPtr<RefCountedAndGarbageCollected> refPtr1 = RefCountedAndGarbageCollected::create();
-                RefPtr<RefCountedAndGarbageCollected> refPtr2 = RefCountedAndGarbageCollected::create();
+                Persistent<RefCountedAndGarbageCollected> refPtr1 = RefCountedAndGarbageCollected::create();
+                Persistent<RefCountedAndGarbageCollected> refPtr2 = RefCountedAndGarbageCollected::create();
                 Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
                 EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
                 persistent = refPtr1.get();
             }
             // Reference count is zero for both objects but one of
             // them is kept alive by a persistent handle.
             Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
             EXPECT_EQ(1, RefCountedAndGarbageCollected::s_destructorCalls);
             refPtr3 = persistent.get();
         }
         // The persistent handle is gone but the ref count has been
         // increased to 1.
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         EXPECT_EQ(1, RefCountedAndGarbageCollected::s_destructorCalls);
     }
     // Both persistent handle is gone and ref count is zero so the
     // object can be collected.
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(2, RefCountedAndGarbageCollected::s_destructorCalls);
 }
 
 TEST(HeapTest, RefCountedGarbageCollectedWithStackPointers)
 {
     RefCountedAndGarbageCollected::s_destructorCalls = 0;
     RefCountedAndGarbageCollected2::s_destructorCalls = 0;
     {
         RefCountedAndGarbageCollected* pointer1 = 0;
         RefCountedAndGarbageCollected2* pointer2 = 0;
         {
-            RefPtr<RefCountedAndGarbageCollected> object1 = RefCountedAndGarbageCollected::create();
-            RefPtr<RefCountedAndGarbageCollected2> object2 = RefCountedAndGarbageCollected2::create();
+            Persistent<RefCountedAndGarbageCollected> object1 = RefCountedAndGarbageCollected::create();
+            Persistent<RefCountedAndGarbageCollected2> object2 = RefCountedAndGarbageCollected2::create();
             pointer1 = object1.get();
             pointer2 = object2.get();
             void* objects[2] = { object1.get(), object2.get() };
             RefCountedGarbageCollectedVisitor visitor(2, objects);
             ThreadState::current()->visitPersistents(&visitor);
             EXPECT_TRUE(visitor.validate());
 
             Heap::collectGarbage(ThreadState::HeapPointersOnStack);
             EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
             EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
         }
         Heap::collectGarbage(ThreadState::HeapPointersOnStack);
         EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
         EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
 
         // At this point, the reference counts of object1 and object2 are 0.
         // Only pointer1 and pointer2 keep references to object1 and object2.
         void* objects[] = { 0 };
         RefCountedGarbageCollectedVisitor visitor(0, objects);
         ThreadState::current()->visitPersistents(&visitor);
         EXPECT_TRUE(visitor.validate());
 
         {
-            RefPtr<RefCountedAndGarbageCollected> object1(pointer1);
-            RefPtr<RefCountedAndGarbageCollected2> object2(pointer2);
+            Persistent<RefCountedAndGarbageCollected> object1(pointer1);
+            Persistent<RefCountedAndGarbageCollected2> object2(pointer2);
             void* objects[2] = { object1.get(), object2.get() };
             RefCountedGarbageCollectedVisitor visitor(2, objects);
             ThreadState::current()->visitPersistents(&visitor);
             EXPECT_TRUE(visitor.validate());
 
             Heap::collectGarbage(ThreadState::HeapPointersOnStack);
             EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
             EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
         }
 
@@ skipping 2157 matching lines @@
 TEST(HeapTest, NonNodeAllocatingNodeInDestructor)
 {
     new NonNodeAllocatingNodeInDestructor();
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(10, (*NonNodeAllocatingNodeInDestructor::s_node)->value());
     delete NonNodeAllocatingNodeInDestructor::s_node;
     NonNodeAllocatingNodeInDestructor::s_node = 0;
 }
 
 } // namespace blink