Move webaudio to oilpan

Source/platform/heap/Heap.h

Index: Source/platform/heap/Heap.h
diff --git a/Source/platform/heap/Heap.h b/Source/platform/heap/Heap.h
index e464e89dcfb4c2596f1cc1f532ebc3f2c16f394c..79d2ac8e5a09631816fa2d49483d71e0f4e9678d 100644
--- a/Source/platform/heap/Heap.h
+++ b/Source/platform/heap/Heap.h
@@ -42,6 +42,7 @@
 #include "wtf/ListHashSet.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassRefPtr.h"
+#include "wtf/ThreadSafeRefCounted.h"
 
 #include <stdint.h>
 
@@ -70,6 +71,7 @@ class HeapStats;
 class PageMemory;
 template<ThreadAffinity affinity> class ThreadLocalPersistents;
 template<typename T, typename RootsAccessor = ThreadLocalPersistents<ThreadingTrait<T>::Affinity > > class Persistent;
+template<typename T> class CrossThreadPersistent;
 
 PLATFORM_EXPORT size_t osPageSize();
 
@@ -559,6 +561,56 @@ private:
     friend class ThreadState;
 };
 
+// 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.

[Ken Russell (switch to Gerrit), 2014/05/07 22:07:20]

Agreed, though the audio thread needs to traverse the AudioNode graph directly.
This seems to require that Oilpan would not use a compacting GC for the
garbage-collected objects in its heap. Is this the case?

How could the Audio thread indicate to the main thread that it's OK to perform a
GC?

[haraken, 2014/05/08 00:52:09]

Yes. Oilpan won't introduce a compacting GC. Copying Blink objects causes a ton
of issues and we won't take that way.
One way to do that is using an Interrupter. By using the Interruptor, the audio
thread can indicate that "I'm currently at a point where GC can happen" (this is
called a "safe point").

The audio thread needs to enter the safe point very frequently. Otherwise, the
main thread has to wait for a long time to start a GC, which will increase GC
pause. For more details, you can see a comment in
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...
.

[Ken Russell (switch to Gerrit), 2014/05/08 02:01:20]

We will need to be careful to not introduce hitches or dropouts in the
high-priority audio thread. If keeping a persistent handle to the audio nodes
currently being used by the audio thread is a solution that avoids any
possibility of pausing the audio thread, we should consider making that solution
permanent.

[Mads Ager (chromium), 2014/05/08 05:50:14]

Thanks for your comments Ken. You are absolutely right that we cannot do a
compacting collector for AudioNodes as long as they are handled this way.  We
have no current plans of registering the audio thread with oilpan. The real-time
requirements are too strict. If we do not register the audio thread with oilpan
we cannot get it to a safe-point and can't move AudioNodes. However, compaction
doesn't have to be all or nothing. We can split heap segments by object type (we
are going to do that for security anyway). There could be a space for objects
that are not allowed to move. AudioNodes could be in that space. I'm not yet
willing to give up on a compacting collector down the line! :-)

The FIXME comment here should probably be removed. I added it when we did the
first version on this on the oilpan branch. The ref/derefs from the audio thread
*are* the message from the audio thread about life-time and I agree that we
should just keep that setup permanently.

+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)));
+    }
+
+    // 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)));
+        }
+        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:
+    OwnPtr<CrossThreadPersistent<T> > m_keepAlive;
+    mutable Mutex m_mutex;
+};
+
 // The CallbackStack contains all the visitor callbacks used to trace and mark
 // objects. A specific CallbackStack instance contains at most bufferSize elements.
 // If more space is needed a new CallbackStack instance is created and chained