Move webaudio to oilpan

Source/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 21 matching lines @@
 #define Heap_h
 
 #include "heap/AddressSanitizer.h"
 #include "heap/HeapExport.h"
 #include "heap/ThreadState.h"
 #include "heap/Visitor.h"
 
 #include "wtf/Assertions.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassRefPtr.h"
+#include "wtf/ThreadSafeRefCounted.h"
 
 #include <stdint.h>
 
 namespace WebCore {
 
 const size_t blinkPageSizeLog2 = 17;
 const size_t blinkPageSize = 1 << blinkPageSizeLog2;
 const size_t blinkPageOffsetMask = blinkPageSize - 1;
 const size_t blinkPageBaseMask = ~blinkPageOffsetMask;
 // Double precision floats are more efficient when 8 byte aligned, so we 8 byte
@@ skipping 476 matching lines @@
     static const int numberOfEntriesLog2 = 12;
     static const int numberOfEntries = 1 << numberOfEntriesLog2;
 
     static size_t hash(Address);
 
     WTF::OwnPtr<HeapContainsCache::Entry[]> m_entries;
 
     friend class ThreadState;
 };
 
+// FIXME(oilpan): The current implementation requires the deallocating
+// thread to be the same as the thread on which this instance was first
+// allocated. Only the refs/derefs that are not 0 -> 1 or 1 -> 0 are
+// thread safe.

[haraken, 2014/03/27 11:44:05]

Probably you can eliminate this restriction by using a CrossThreadPersistent for
the keep alive handle?

[keishi, 2014/04/03 06:53:19]

Done.

+// This is currently used by the WebAudio code and the WebDatabase code.

[haraken, 2014/03/27 11:44:05]

Remove the "WebDatabase code" part. I think tkent-san has fixed the issue in the
database thread.

[keishi, 2014/04/03 06:53:19]

Done.

+// 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 WTF::ThreadSafeRefCountedBase, public GarbageCollectedFinalized<T> {

[Mads Ager (chromium), 2014/03/27 11:06:49]

I think it was like this on the branch as well, but could you swap the order of
the super classes so we have GarbageCollectedFinalized first? :)

[keishi, 2014/04/03 06:53:19]

Done.

+    WTF_MAKE_NONCOPYABLE(ThreadSafeRefCountedGarbageCollected);
+
+public:
+    ThreadSafeRefCountedGarbageCollected()
+    {
+#ifndef NDEBUG
+        m_threadState = ThreadState::current();
+#endif
+        m_keepAlive = new Persistent<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);
+            ASSERT(m_threadState->contains(reinterpret_cast<Address>(this)));
+            ASSERT(m_threadState == ThreadState::current());
+            m_keepAlive = new Persistent<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()) {

[haraken, 2014/03/27 11:44:05]

I suspect this leaks memory, because currently derefBase() does not decrement
the refcount from 1 to 0. I guess you need to make a change to
RefCounted::derefBase() so that it does the decrement.

[keishi, 2014/04/03 06:53:19]

haraken fixed this in r170256

+            ASSERT(m_threadState == ThreadState::current());
+            m_keepAlive = 0;

[haraken, 2014/03/27 11:44:05]

m_keepAlive = nullptr;

[keishi, 2014/04/03 06:53:19]

Done.

+        }
+    }
+
+    using GarbageCollectedFinalized<T>::operator new;
+    using GarbageCollectedFinalized<T>::operator delete;
+
+protected:
+    ~ThreadSafeRefCountedGarbageCollected() { }
+
+private:
+    Persistent<T>* m_keepAlive;

[haraken, 2014/03/27 11:44:05]

Shall we use an OwnPtr<Persistent<T> > ?

[keishi, 2014/04/03 06:53:19]

Done.

+    mutable Mutex m_mutex;
+#ifndef NDEBUG
+    ThreadState* m_threadState;
+#endif
+};
+
 // 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
 // together with the former instance. I.e. a logical CallbackStack can be made of
 // multiple chained CallbackStack object instances.
 // There are two logical callback stacks. One containing all the marking callbacks and
 // one containing the weak pointer callbacks.
 class CallbackStack {
 public:
     CallbackStack(CallbackStack** first)
@@ skipping 452 matching lines @@
             delete m_keepAlive;
             m_keepAlive = 0;
         }
     }
 
     bool hasOneRef()
     {
         return m_refCount == 1;
     }
 
+    int refCount()

[Mads Ager (chromium), 2014/03/27 11:06:49]

Do we need this? When something is RefCountedGarbageCollected that usually means
that we will start moving away from RefPtr to Member/Persistent. At that point
all asserts about refCount() are wrong. So I would prefer not to add this method
if we can avoid it?

[keishi, 2014/04/03 06:53:19]

Done.

+    {
+        return m_refCount;
+    }
+
 protected:
     ~RefCountedGarbageCollected() { }
 
 private:
     int m_refCount;
     Persistent<T>* m_keepAlive;
 };
 
 template<typename T>
 T* adoptRefCountedGarbageCollected(T* ptr)
@@ skipping 714 matching lines @@
 // to export. This forces it to export all the methods from ThreadHeap.
 template<> void ThreadHeap<FinalizedHeapObjectHeader>::addPageToHeap(const GCInfo*);
 template<> void ThreadHeap<HeapObjectHeader>::addPageToHeap(const GCInfo*);
 extern template class HEAP_EXPORT ThreadHeap<FinalizedHeapObjectHeader>;
 extern template class HEAP_EXPORT ThreadHeap<HeapObjectHeader>;
 #endif
 
 }
 
 #endif // Heap_h