Replace ASSERT with DCHECK in WebAudio

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

 /*
  * Copyright (C) 2010, 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:
  * 1.  Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 16 matching lines @@
 #include "modules/webaudio/AudioNodeOutput.h"
 #include "modules/webaudio/OfflineAudioContext.h"
 #include "platform/CrossThreadFunctional.h"
 #include "public/platform/Platform.h"
 
 namespace blink {
 
 void DeferredTaskHandler::lock()
 {
     // Don't allow regular lock in real-time audio thread.
-    ASSERT(!isAudioThread());
+    DCHECK(!isAudioThread());
     m_contextGraphMutex.lock();
 }
 
 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;
     }
     return m_contextGraphMutex.tryLock();
 }
 
 void DeferredTaskHandler::unlock()
 {
     m_contextGraphMutex.unlock();
 }
 
 void DeferredTaskHandler::offlineLock()
 {
     // CHECK is here to make sure to explicitly crash if this is called from
     // other than the offline render thread, which is considered as the audio
     // thread in OfflineAudioContext.
     CHECK(isAudioThread())
         << "DeferredTaskHandler::offlineLock() must be called within the offline audio thread.";
 
     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
 }
-#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();
     m_deferredBreakConnectionList.clear();
 }
 
 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();
     m_dirtySummingJunctions.clear();
 }
 
 void DeferredTaskHandler::handleDirtyAudioNodeOutputs()
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
 
     HashSet<AudioNodeOutput*> dirtyOutputs;
     m_dirtyAudioNodeOutputs.swap(dirtyOutputs);
 
     // Note: the updating of rendering state may cause output nodes
     // further down the chain to be marked as dirty. These will not
     // be processed in this render quantum.
     for (AudioNodeOutput* output : dirtyOutputs)
         output->updateRenderingState();
 }
 
 void DeferredTaskHandler::addAutomaticPullNode(AudioHandler* node)
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
 
     if (!m_automaticPullNodes.contains(node)) {
         m_automaticPullNodes.add(node);
         m_automaticPullNodesNeedUpdating = true;
     }
 }
 
 void DeferredTaskHandler::removeAutomaticPullNode(AudioHandler* node)
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
 
     if (m_automaticPullNodes.contains(node)) {
         m_automaticPullNodes.remove(node);
         m_automaticPullNodesNeedUpdating = true;
     }
 }
 
 void DeferredTaskHandler::updateAutomaticPullNodes()
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
 
     if (m_automaticPullNodesNeedUpdating) {
         copyToVector(m_automaticPullNodes, m_renderingAutomaticPullNodes);
         m_automaticPullNodesNeedUpdating = false;
     }
 }
 
 void DeferredTaskHandler::processAutomaticPullNodes(size_t framesToProcess)
 {
-    ASSERT(isAudioThread());
+    DCHECK(isAudioThread());
 
     for (unsigned i = 0; i < m_renderingAutomaticPullNodes.size(); ++i)
         m_renderingAutomaticPullNodes[i]->processIfNecessary(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();
     m_deferredCountModeChange.clear();
 }
 
 void DeferredTaskHandler::updateChangedChannelInterpretation()
 {
-    ASSERT(isGraphOwner());
+    DCHECK(isGraphOwner());
 
     for (AudioHandler* node : m_deferredChannelInterpretationChange)
         node->updateChannelInterpretation();
     m_deferredChannelInterpretationChange.clear();
 }
 
 DeferredTaskHandler::DeferredTaskHandler()
     : m_automaticPullNodesNeedUpdating(false)
     , m_audioThread(0)
 {
 }
 
 PassRefPtr<DeferredTaskHandler> DeferredTaskHandler::create()
 {
     return adoptRef(new DeferredTaskHandler());
 }
 
 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()
 {
     updateChangedChannelCountMode();
     updateChangedChannelInterpretation();
     handleDirtyAudioSummingJunctions();
     handleDirtyAudioNodeOutputs();
     updateAutomaticPullNodes();
 }
@@ skipping 15 matching lines @@
 }
 
 DeferredTaskHandler::OfflineGraphAutoLocker::OfflineGraphAutoLocker(OfflineAudioContext* context)
     : m_handler(context->deferredTaskHandler())
 {
     m_handler.offlineLock();
 }
 
 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);
     m_renderingOrphanHandlers.clear();
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, crossThreadBind(&DeferredTaskHandler::deleteHandlersOnMainThread, PassRefPtr<DeferredTaskHandler>(this)));
 }
 
 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();
 }
 
 void DeferredTaskHandler::setAudioThreadToCurrentThread()
 {
-    ASSERT(!isMainThread());
+    DCHECK(!isMainThread());
     ThreadIdentifier thread = currentThread();
     releaseStore(&m_audioThread, thread);
 }
 
 } // namespace blink