Replace ASSERT with DCHECK in WebAudio

third_party/WebKit/Source/modules/webaudio/DeferredTaskHandler.cpp

Index: third_party/WebKit/Source/modules/webaudio/DeferredTaskHandler.cpp
diff --git a/third_party/WebKit/Source/modules/webaudio/DeferredTaskHandler.cpp b/third_party/WebKit/Source/modules/webaudio/DeferredTaskHandler.cpp
index f4f79b8f6c48e6f62fcc7daf9fe1c80635326145..60fe37f0faefd51603fbf596c97fd49efff878d0 100644
--- a/third_party/WebKit/Source/modules/webaudio/DeferredTaskHandler.cpp
+++ b/third_party/WebKit/Source/modules/webaudio/DeferredTaskHandler.cpp
@@ -34,7 +34,7 @@ namespace blink {
 void DeferredTaskHandler::lock()
 {
     // Don't allow regular lock in real-time audio thread.
-    ASSERT(!isAudioThread());
+    DCHECK(!isAudioThread());
     m_contextGraphMutex.lock();
 }
 
@@ -42,10 +42,10 @@ bool DeferredTaskHandler::tryLock()
 {
     // Try to catch cases of using try lock on main thread
     // - it should use regular lock.
-    ASSERT(isAudioThread());
+    DCHECK(isAudioThread());
     if (!isAudioThread()) {
         // In release build treat tryLock() as lock() (since above
-        // ASSERT(isAudioThread) never fires) - this is the best we can do.
+        // DCHECK(isAudioThread) never fires) - this is the best we can do.
         lock();
         return true;
     }
@@ -68,23 +68,25 @@ void DeferredTaskHandler::offlineLock()
     m_contextGraphMutex.lock();
 }
 
-#if ENABLE(ASSERT)
 bool DeferredTaskHandler::isGraphOwner()
 {
+#if ENABLE(ASSERT)
     return m_contextGraphMutex.locked();
-}
+#else
+    return true;

[Raymond Toy, 2016/08/10 16:29:15]

Please add comment on why true is the correct result when ASSERT is not enabled.
 At first glance in isolation, this is definitely wrong because it's not always
the case that we're the graph owner.

I wonder if the API would be better if we replaced all DCHECK(isGraphOwner) with
assertGraphOwnership() (or other name) and have assertGraphOwnership() do the
DCHECK there.

This has a penalty that we get an extra function call (maybe make it inline?),
but does make it very clear what should happen if ASSERT is disabled.

[HyungwookLee, 2016/08/11 08:35:15]

I think the best solution is removing #if ENABLE(ASSERT) in MutexBase.
I will try to do this but it looks takes some time.

How about divide replacing ASSERT(isGraphOwner()) with DCHECK into another cl?

 #endif
+}
 
 void DeferredTaskHandler::addDeferredBreakConnection(AudioHandler& node)
 {
-    ASSERT(isAudioThread());
+    DCHECK(isAudioThread());
     m_deferredBreakConnectionList.append(&node);
 }
 
 void DeferredTaskHandler::breakConnections()
 {
-    ASSERT(isAudioThread());
-    ASSERT(isGraphOwner());
+    DCHECK(isAudioThread());
+    DCHECK(isGraphOwner());
 
     for (unsigned i = 0; i < m_deferredBreakConnectionList.size(); ++i)
         m_deferredBreakConnectionList[i]->breakConnectionWithLock();
@@ -93,34 +95,34 @@ void DeferredTaskHandler::breakConnections()
 
 void DeferredTaskHandler::markSummingJunctionDirty(AudioSummingJunction* summingJunction)
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
     m_dirtySummingJunctions.add(summingJunction);
 }
 
 void DeferredTaskHandler::removeMarkedSummingJunction(AudioSummingJunction* summingJunction)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
     AutoLocker locker(*this);
     m_dirtySummingJunctions.remove(summingJunction);
 }
 
 void DeferredTaskHandler::markAudioNodeOutputDirty(AudioNodeOutput* output)
 {
-    ASSERT(isGraphOwner());
-    ASSERT(isMainThread());
+    DCHECK(isGraphOwner());
+    DCHECK(isMainThread());
     m_dirtyAudioNodeOutputs.add(output);
 }
 
 void DeferredTaskHandler::removeMarkedAudioNodeOutput(AudioNodeOutput* output)
 {
-    ASSERT(isGraphOwner());
-    ASSERT(isMainThread());
+    DCHECK(isGraphOwner());
+    DCHECK(isMainThread());
     m_dirtyAudioNodeOutputs.remove(output);
 }
 
 void DeferredTaskHandler::handleDirtyAudioSummingJunctions()
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
 
     for (AudioSummingJunction* junction : m_dirtySummingJunctions)
         junction->updateRenderingState();
@@ -129,7 +131,7 @@ void DeferredTaskHandler::handleDirtyAudioSummingJunctions()
 
 void DeferredTaskHandler::handleDirtyAudioNodeOutputs()
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
 
     HashSet<AudioNodeOutput*> dirtyOutputs;
     m_dirtyAudioNodeOutputs.swap(dirtyOutputs);
@@ -143,7 +145,7 @@ void DeferredTaskHandler::handleDirtyAudioNodeOutputs()
 
 void DeferredTaskHandler::addAutomaticPullNode(AudioHandler* node)
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
 
     if (!m_automaticPullNodes.contains(node)) {
         m_automaticPullNodes.add(node);
@@ -153,7 +155,7 @@ void DeferredTaskHandler::addAutomaticPullNode(AudioHandler* node)
 
 void DeferredTaskHandler::removeAutomaticPullNode(AudioHandler* node)
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
 
     if (m_automaticPullNodes.contains(node)) {
         m_automaticPullNodes.remove(node);
@@ -163,7 +165,7 @@ void DeferredTaskHandler::removeAutomaticPullNode(AudioHandler* node)
 
 void DeferredTaskHandler::updateAutomaticPullNodes()
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
 
     if (m_automaticPullNodesNeedUpdating) {
         copyToVector(m_automaticPullNodes, m_renderingAutomaticPullNodes);
@@ -173,7 +175,7 @@ void DeferredTaskHandler::updateAutomaticPullNodes()
 
 void DeferredTaskHandler::processAutomaticPullNodes(size_t framesToProcess)
 {
-    ASSERT(isAudioThread());
+    DCHECK(isAudioThread());
 
     for (unsigned i = 0; i < m_renderingAutomaticPullNodes.size(); ++i)
         m_renderingAutomaticPullNodes[i]->processIfNecessary(framesToProcess);
@@ -181,35 +183,35 @@ void DeferredTaskHandler::processAutomaticPullNodes(size_t framesToProcess)
 
 void DeferredTaskHandler::addChangedChannelCountMode(AudioHandler* node)
 {
-    ASSERT(isGraphOwner());
-    ASSERT(isMainThread());
+    DCHECK(isGraphOwner());
+    DCHECK(isMainThread());
     m_deferredCountModeChange.add(node);
 }
 
 void DeferredTaskHandler::removeChangedChannelCountMode(AudioHandler* node)
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
 
     m_deferredCountModeChange.remove(node);
 }
 
 void DeferredTaskHandler::addChangedChannelInterpretation(AudioHandler* node)
 {
-    ASSERT(isGraphOwner());
-    ASSERT(isMainThread());
+    DCHECK(isGraphOwner());
+    DCHECK(isMainThread());
     m_deferredChannelInterpretationChange.add(node);
 }
 
 void DeferredTaskHandler::removeChangedChannelInterpretation(AudioHandler* node)
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
 
     m_deferredChannelInterpretationChange.remove(node);
 }
 
 void DeferredTaskHandler::updateChangedChannelCountMode()
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
 
     for (AudioHandler* node : m_deferredCountModeChange)
         node->updateChannelCountMode();
@@ -218,7 +220,7 @@ void DeferredTaskHandler::updateChangedChannelCountMode()
 
 void DeferredTaskHandler::updateChangedChannelInterpretation()
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
 
     for (AudioHandler* node : m_deferredChannelInterpretationChange)
         node->updateChannelInterpretation();
@@ -238,10 +240,10 @@ PassRefPtr<DeferredTaskHandler> DeferredTaskHandler::create()
 
 DeferredTaskHandler::~DeferredTaskHandler()
 {
-    ASSERT(!m_automaticPullNodes.size());
+    DCHECK(!m_automaticPullNodes.size());
     if (m_automaticPullNodesNeedUpdating)
         m_renderingAutomaticPullNodes.resize(m_automaticPullNodes.size());
-    ASSERT(!m_renderingAutomaticPullNodes.size());
+    DCHECK(!m_renderingAutomaticPullNodes.size());
 }
 
 void DeferredTaskHandler::handleDeferredTasks()
@@ -277,15 +279,15 @@ DeferredTaskHandler::OfflineGraphAutoLocker::OfflineGraphAutoLocker(OfflineAudio
 
 void DeferredTaskHandler::addRenderingOrphanHandler(PassRefPtr<AudioHandler> handler)
 {
-    ASSERT(handler);
-    ASSERT(!m_renderingOrphanHandlers.contains(handler));
+    DCHECK(handler);
+    DCHECK(!m_renderingOrphanHandlers.contains(handler));
     m_renderingOrphanHandlers.append(handler);
 }
 
 void DeferredTaskHandler::requestToDeleteHandlersOnMainThread()
 {
-    ASSERT(isGraphOwner());
-    ASSERT(isAudioThread());
+    DCHECK(isGraphOwner());
+    DCHECK(isAudioThread());
     if (m_renderingOrphanHandlers.isEmpty())
         return;
     m_deletableOrphanHandlers.appendVector(m_renderingOrphanHandlers);
@@ -295,14 +297,14 @@ void DeferredTaskHandler::requestToDeleteHandlersOnMainThread()
 
 void DeferredTaskHandler::deleteHandlersOnMainThread()
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
     AutoLocker locker(*this);
     m_deletableOrphanHandlers.clear();
 }
 
 void DeferredTaskHandler::clearHandlersToBeDeleted()
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
     AutoLocker locker(*this);
     m_renderingOrphanHandlers.clear();
     m_deletableOrphanHandlers.clear();
@@ -310,7 +312,7 @@ void DeferredTaskHandler::clearHandlersToBeDeleted()
 
 void DeferredTaskHandler::setAudioThreadToCurrentThread()
 {
-    ASSERT(!isMainThread());
+    DCHECK(!isMainThread());
     ThreadIdentifier thread = currentThread();
     releaseStore(&m_audioThread, thread);
 }