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)

[Raymond Toy, 2016/07/25 16:56:52]

The whole of the original bug was to figure out how to get rid of this
ENABLE(ASSERT).

[HyungwookLee, 2016/07/26 00:42:40]

Yes, I will make new CL for removing ENABLE(ASSERT) of
DeferredTaskHandler::isGraphOwner() after landing this CL.

 bool DeferredTaskHandler::isGraphOwner()
 {
     return m_contextGraphMutex.locked();
 }
 #endif
 
 void DeferredTaskHandler::addDeferredBreakConnection(AudioHandler& node)
 {
-    ASSERT(isAudioThread());
+    DCHECK(isAudioThread());
     m_deferredBreakConnectionList.append(&node);
 }
 
 void DeferredTaskHandler::breakConnections()
 {
-    ASSERT(isAudioThread());
+    DCHECK(isAudioThread());
     ASSERT(isGraphOwner());
 
     for (unsigned i = 0; i < m_deferredBreakConnectionList.size(); ++i)
         m_deferredBreakConnectionList[i]->breakConnectionWithLock();
     m_deferredBreakConnectionList.clear();
 }
 
 void DeferredTaskHandler::markSummingJunctionDirty(AudioSummingJunction* summingJunction)
 {
     ASSERT(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(isMainThread());
     m_dirtyAudioNodeOutputs.add(output);
 }
 
 void DeferredTaskHandler::removeMarkedAudioNodeOutput(AudioNodeOutput* output)
 {
     ASSERT(isGraphOwner());
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
     m_dirtyAudioNodeOutputs.remove(output);
 }
 
 void DeferredTaskHandler::handleDirtyAudioSummingJunctions()
 {
     ASSERT(isGraphOwner());
 
     for (AudioSummingJunction* junction : m_dirtySummingJunctions)
         junction->updateRenderingState();
     m_dirtySummingJunctions.clear();
@@ skipping 38 matching lines @@
     ASSERT(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(isMainThread());
     m_deferredCountModeChange.add(node);
 }
 
 void DeferredTaskHandler::removeChangedChannelCountMode(AudioHandler* node)
 {
     ASSERT(isGraphOwner());
 
     m_deferredCountModeChange.remove(node);
 }
 
 void DeferredTaskHandler::addChangedChannelInterpretation(AudioHandler* node)
 {
     ASSERT(isGraphOwner());
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
     m_deferredChannelInterpretationChange.add(node);
 }
 
 void DeferredTaskHandler::removeChangedChannelInterpretation(AudioHandler* node)
 {
     ASSERT(isGraphOwner());
 
     m_deferredChannelInterpretationChange.remove(node);
 }
 
@@ skipping 21 matching lines @@
 {
 }
 
 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(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