Replace ASSERT with DCHECK in WebAudio

third_party/WebKit/Source/modules/webaudio/ScriptProcessorNode.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 87 matching lines @@
     // This node is the producer for inputBuffer and the consumer for outputBuffer.
     // The JavaScript code is the consumer of inputBuffer and the producer for outputBuffer.
 
     // Get input and output busses.
     AudioBus* inputBus = input(0).bus();
     AudioBus* outputBus = output(0).bus();
 
     // Get input and output buffers. We double-buffer both the input and output sides.
     unsigned doubleBufferIndex = this->doubleBufferIndex();
     bool isDoubleBufferIndexGood = doubleBufferIndex < 2 && doubleBufferIndex < m_inputBuffers.size() && doubleBufferIndex < m_outputBuffers.size();
-    ASSERT(isDoubleBufferIndexGood);
+    DCHECK(isDoubleBufferIndexGood);
     if (!isDoubleBufferIndexGood)
         return;
 
     AudioBuffer* inputBuffer = m_inputBuffers[doubleBufferIndex].get();
     AudioBuffer* outputBuffer = m_outputBuffers[doubleBufferIndex].get();
 
     // Check the consistency of input and output buffers.
     unsigned numberOfInputChannels = m_internalInputBus->numberOfChannels();
     bool buffersAreGood = outputBuffer && bufferSize() == outputBuffer->length() && m_bufferReadWriteIndex + framesToProcess <= bufferSize();
 
     // If the number of input channels is zero, it's ok to have inputBuffer = 0.
     if (m_internalInputBus->numberOfChannels())
         buffersAreGood = buffersAreGood && inputBuffer && bufferSize() == inputBuffer->length();
 
-    ASSERT(buffersAreGood);
+    DCHECK(buffersAreGood);
     if (!buffersAreGood)
         return;
 
     // We assume that bufferSize() is evenly divisible by framesToProcess - should always be true, but we should still check.
     bool isFramesToProcessGood = framesToProcess && bufferSize() >= framesToProcess && !(bufferSize() % framesToProcess);
-    ASSERT(isFramesToProcessGood);
+    DCHECK(isFramesToProcessGood);
     if (!isFramesToProcessGood)
         return;
 
     unsigned numberOfOutputChannels = outputBus->numberOfChannels();
 
     bool channelsAreGood = (numberOfInputChannels == m_numberOfInputChannels) && (numberOfOutputChannels == m_numberOfOutputChannels);
-    ASSERT(channelsAreGood);
+    DCHECK(channelsAreGood);
     if (!channelsAreGood)
         return;
 
     for (unsigned i = 0; i < numberOfInputChannels; ++i)
         m_internalInputBus->setChannelMemory(i, inputBuffer->getChannelData(i)->data() + m_bufferReadWriteIndex, framesToProcess);
 
     if (numberOfInputChannels)
         m_internalInputBus->copyFrom(*inputBus);
 
     // Copy from the output buffer to the output.
@@ skipping 20 matching lines @@
             context()->getExecutionContext()->postTask(BLINK_FROM_HERE,
                 createCrossThreadTask(&ScriptProcessorHandler::fireProcessEvent, PassRefPtr<ScriptProcessorHandler>(this), m_doubleBufferIndex));
         }
 
         swapBuffers();
     }
 }
 
 void ScriptProcessorHandler::fireProcessEvent(unsigned doubleBufferIndex)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
-    ASSERT(doubleBufferIndex < 2);
+    DCHECK_LT(doubleBufferIndex, 2u);
     if (doubleBufferIndex > 1)
         return;
 
     AudioBuffer* inputBuffer = m_inputBuffers[doubleBufferIndex].get();
     AudioBuffer* outputBuffer = m_outputBuffers[doubleBufferIndex].get();
-    ASSERT(outputBuffer);
+    DCHECK(outputBuffer);
     if (!outputBuffer)
         return;
 
     // Avoid firing the event if the document has already gone away.
     if (node() && context() && context()->getExecutionContext()) {
         // This synchronizes with process().
         MutexLocker processLocker(m_processEventLock);
 
         // Calculate a playbackTime with the buffersize which needs to be processed each time onaudioprocess is called.
         // The outputBuffer being passed to JS will be played after exhuasting previous outputBuffer by double-buffering.
         double playbackTime = (context()->currentSampleFrame() + m_bufferSize) / static_cast<double>(context()->sampleRate());
 
         // Call the JavaScript event handler which will do the audio processing.
         node()->dispatchEvent(AudioProcessingEvent::create(inputBuffer, outputBuffer, playbackTime));
     }
 }
 
 double ScriptProcessorHandler::tailTime() const
 {
     return std::numeric_limits<double>::infinity();
 }
 
 double ScriptProcessorHandler::latencyTime() const
 {
     return std::numeric_limits<double>::infinity();
 }
 
 void ScriptProcessorHandler::setChannelCount(unsigned long channelCount, ExceptionState& exceptionState)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
     BaseAudioContext::AutoLocker locker(context());
 
     if (channelCount != m_channelCount) {
         exceptionState.throwDOMException(
             NotSupportedError,
             "channelCount cannot be changed from " + String::number(m_channelCount) + " to " + String::number(channelCount));
     }
 }
 
 void ScriptProcessorHandler::setChannelCountMode(const String& mode, ExceptionState& exceptionState)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
     BaseAudioContext::AutoLocker locker(context());
 
     if ((mode == "max") || (mode == "clamped-max")) {
         exceptionState.throwDOMException(
             NotSupportedError,
             "channelCountMode cannot be changed from 'explicit' to '" + mode + "'");
     }
 }
 
 // ----------------------------------------------------------------
@@ skipping 140 matching lines @@
     // If |onaudioprocess| event handler is defined, the node should not be
     // GCed even if it is out of scope.
     if (hasEventListeners(EventTypeNames::audioprocess))
         return true;
 
     return false;
 }
 
 } // namespace blink