Oilpan: Remove adoptRefCountedGarbageCollected

Source/platform/heap/Heap.h

 /*
  * 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 604 matching lines @@
 private:
     static const int numberOfEntriesLog2 = 12;
     static const int numberOfEntries = 1 << numberOfEntriesLog2;
 
     static size_t hash(Address);
 
     WTF::OwnPtr<Address[]> m_entries;
     bool m_hasEntries;
 };
 
-// FIXME: This is currently used by the WebAudio code.
-// We should attempt to restructure the WebAudio code so that the main thread
-// alone determines life-time and receives messages about life-time from the
-// audio thread.
-template<typename T>
-class ThreadSafeRefCountedGarbageCollected : public GarbageCollectedFinalized<T>, public WTF::ThreadSafeRefCountedBase {
-    WTF_MAKE_NONCOPYABLE(ThreadSafeRefCountedGarbageCollected);
-
-public:
-    ThreadSafeRefCountedGarbageCollected()
-    {
-        makeKeepAlive();
-    }
-
-    // Override ref to deal with a case where a reference count goes up
-    // from 0 to 1. This can happen in the following scenario:
-    // (1) The reference count becomes 0, but on-stack pointers keep references to the object.
-    // (2) The on-stack pointer is assigned to a RefPtr. The reference count becomes 1.
-    // In this case, we have to resurrect m_keepAlive.
-    void ref()
-    {
-        MutexLocker lock(m_mutex);
-        if (UNLIKELY(!refCount())) {
-            makeKeepAlive();
-        }
-        WTF::ThreadSafeRefCountedBase::ref();
-    }
-
-    // Override deref to deal with our own deallocation based on ref counting.
-    void deref()
-    {
-        MutexLocker lock(m_mutex);
-        if (derefBase()) {
-            ASSERT(m_keepAlive);
-            m_keepAlive.clear();
-        }
-    }
-
-    using GarbageCollectedFinalized<T>::operator new;
-    using GarbageCollectedFinalized<T>::operator delete;
-
-protected:
-    ~ThreadSafeRefCountedGarbageCollected() { }
-
-private:
-    void makeKeepAlive()
-    {
-        ASSERT(!m_keepAlive);
-        m_keepAlive = adoptPtr(new CrossThreadPersistent<T>(static_cast<T*>(this)));
-    }
-
-    OwnPtr<CrossThreadPersistent<T> > m_keepAlive;
-    mutable Mutex m_mutex;
-};
-
 template<typename DataType>
 class PagePool {
 protected:
     PagePool();
 
     class PoolEntry {
     public:
         PoolEntry(DataType* data, PoolEntry* next)
             : data(data)
             , next(next)
@@ skipping 497 matching lines @@
 // persistent handle will be deleted. When the garbage collector
 // determines that there are no other references to the object it will
 // be reclaimed and the destructor of the reclaimed object will be
 // called at that time.
 template<typename T>
 class RefCountedGarbageCollected : public GarbageCollectedFinalized<T> {
     WTF_MAKE_NONCOPYABLE(RefCountedGarbageCollected);
 
 public:
     RefCountedGarbageCollected()
-        : m_refCount(1)
+        : m_refCount(0)
     {
-        makeKeepAlive();
     }
 
     // Implement method to increase reference count for use with
     // RefPtrs.
     //
     // In contrast to the normal WTF::RefCounted, the reference count
     // can reach 0 and increase again. This happens in the following
     // scenario:
     //
     // (1) The reference count becomes 0, but members, persistents, or
@@ skipping 41 matching lines @@
     void makeKeepAlive()
     {
         ASSERT(!m_keepAlive);
         m_keepAlive = new Persistent<T>(static_cast<T*>(this));
     }
 
     int m_refCount;
     Persistent<T>* m_keepAlive;
 };
 
-template<typename T>
-T* adoptRefCountedGarbageCollected(T* ptr)
-{
-    ASSERT(ptr->hasOneRef());
-    ptr->deref();
-    WTF::adopted(ptr);
-    return ptr;
-}
-
 // Classes that contain heap references but aren't themselves heap
 // allocated, have some extra macros available which allows their use
 // to be restricted to cases where the garbage collector is able
 // to discover their heap references.
 //
 // STACK_ALLOCATED(): Use if the object is only stack allocated. Heap objects
 // should be in Members but you do not need the trace method as they are on
 // the stack. (Down the line these might turn in to raw pointers, but for
 // now Members indicates that we have thought about them and explicitly
 // taken care of them.)
@@ skipping 1170 matching lines @@
 };
 
 template<typename T>
 struct IfWeakMember<WeakMember<T> > {
     static bool isDead(Visitor* visitor, const WeakMember<T>& t) { return !visitor->isAlive(t.get()); }
 };
 
 }
 
 #endif // Heap_h