ThreadSafeRefCountedGarbageCollected should use makeKeepAlive

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 653 matching lines @@
 // 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()
     {
-        m_keepAlive = adoptPtr(new CrossThreadPersistent<T>(static_cast<T*>(this)));
+        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())) {
-            ASSERT(!m_keepAlive);
-            m_keepAlive = adoptPtr(new CrossThreadPersistent<T>(static_cast<T*>(this)));
+            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 {
@@ skipping 1727 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