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 988 matching lines @@
             delete m_keepAlive;
             m_keepAlive = 0;
         }
     }
 
     bool hasOneRef()
     {
         return m_refCount == 1;
     }
 
+    int refCount()
+    {
+        return m_refCount;
+    }
+
 protected:
     ~RefCountedGarbageCollected() { }
 
 private:
     int m_refCount;
     Persistent<T>* m_keepAlive;
 };
 
 template<typename T>
 T* adoptRefCountedGarbageCollected(T* ptr)
 {
-    ASSERT(ptr->hasOneRef());

[Mads Ager (chromium), 2014/03/20 08:30:00]

All ref counted object should start with ref count one and be adopted as the
first thing. Therefore if we get an object that does not have one ref here that
is usually a problem. What are the issues caused by this?

[keishi, 2014/03/27 07:39:37]

I was hitting this at one point but the issue seems to have gone away. Reverted.

     ptr->deref();
     WTF::adopted(ptr);
     return ptr;
 }
 
 #if COMPILER_SUPPORTS(CXX_DELETED_FUNCTIONS)
 #define DISALLOW_ALLOCATION() \
     private: \
         void* operator new(size_t) = delete;
 #else
@@ skipping 103 matching lines @@
     ASSERT(heapPageFromAddress(headerAddress + allocationSize - 1));
     return result;
 }
 
 // FIXME: Allocate objects that do not need finalization separately
 // and use separate sweeping to not have to check for finalizers.
 template<typename T>
 Address Heap::allocate(size_t size)
 {
     ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
+    ASSERT(state);

[Mads Ager (chromium), 2014/03/20 08:30:00]

I would remove this assert. The assert below will cause a null pointer exception
when !state and that should be enough to catch issues.

[keishi, 2014/03/27 07:39:37]

Removed.

     ASSERT(state->isAllocationAllowed());
     BaseHeap* heap = state->heap(HeapTrait<T>::index);
     Address addr =
         static_cast<typename HeapTrait<T>::HeapType*>(heap)->allocate(size, GCInfoTrait<T>::get());
     return addr;
 }
 
 // FIXME: Allocate objects that do not need finalization separately
 // and use separate sweeping to not have to check for finalizers.
 template<typename T>
@@ skipping 560 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