Replace ASSERT with DCHECK in WebAudio

third_party/WebKit/Source/modules/webaudio/AudioBufferSourceNode.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 136 matching lines @@
         }
 
         finish();
         return true;
     }
     return false;
 }
 
 bool AudioBufferSourceHandler::renderFromBuffer(AudioBus* bus, unsigned destinationFrameOffset, size_t numberOfFrames)
 {
-    ASSERT(context()->isAudioThread());
+    DCHECK(context()->isAudioThread());
 
     // Basic sanity checking
-    ASSERT(bus);
-    ASSERT(buffer());
+    DCHECK(bus);
+    DCHECK(buffer());
     if (!bus || !buffer())
         return false;
 
     unsigned numberOfChannels = this->numberOfChannels();
     unsigned busNumberOfChannels = bus->numberOfChannels();
 
     bool channelCountGood = numberOfChannels && numberOfChannels == busNumberOfChannels;
-    ASSERT(channelCountGood);
+    DCHECK(channelCountGood);
     if (!channelCountGood)
         return false;
 
     // Sanity check destinationFrameOffset, numberOfFrames.
     size_t destinationLength = bus->length();
 
     bool isLengthGood = destinationLength <= 4096 && numberOfFrames <= 4096;
-    ASSERT(isLengthGood);
+    DCHECK(isLengthGood);
     if (!isLengthGood)
         return false;
 
     bool isOffsetGood = destinationFrameOffset <= destinationLength && destinationFrameOffset + numberOfFrames <= destinationLength;
-    ASSERT(isOffsetGood);
+    DCHECK(isOffsetGood);
     if (!isOffsetGood)
         return false;
 
     // Potentially zero out initial frames leading up to the offset.
     if (destinationFrameOffset) {
         for (unsigned i = 0; i < numberOfChannels; ++i)
             memset(m_destinationChannels[i], 0, sizeof(float) * destinationFrameOffset);
     }
 
     // Offset the pointers to the correct offset frame.
@@ skipping 43 matching lines @@
 
     // Get local copy.
     double virtualReadIndex = m_virtualReadIndex;
 
     // Render loop - reading from the source buffer to the destination using linear interpolation.
     int framesToProcess = numberOfFrames;
 
     const float** sourceChannels = m_sourceChannels.get();
     float** destinationChannels = m_destinationChannels.get();
 
-    ASSERT(virtualReadIndex >= 0);
-    ASSERT(virtualDeltaFrames >= 0);
-    ASSERT(virtualEndFrame >= 0);
+    DCHECK_GE(virtualReadIndex, 0);
+    DCHECK_GE(virtualDeltaFrames, 0);
+    DCHECK_GE(virtualEndFrame, 0);
 
     // Optimize for the very common case of playing back with computedPlaybackRate == 1.
     // We can avoid the linear interpolation.
     if (computedPlaybackRate == 1 && virtualReadIndex == floor(virtualReadIndex)
         && virtualDeltaFrames == floor(virtualDeltaFrames)
         && virtualEndFrame == floor(virtualEndFrame)) {
         unsigned readIndex = static_cast<unsigned>(virtualReadIndex);
         unsigned deltaFrames = static_cast<unsigned>(virtualDeltaFrames);
         endFrame = static_cast<unsigned>(virtualEndFrame);
         while (framesToProcess > 0) {
             int framesToEnd = endFrame - readIndex;
             int framesThisTime = std::min(framesToProcess, framesToEnd);
             framesThisTime = std::max(0, framesThisTime);
 
             for (unsigned i = 0; i < numberOfChannels; ++i)
                 memcpy(destinationChannels[i] + writeIndex, sourceChannels[i] + readIndex, sizeof(float) * framesThisTime);
 
             writeIndex += framesThisTime;
             readIndex += framesThisTime;
             framesToProcess -= framesThisTime;
 
-            // It can happen that framesThisTime is 0. Assert that we will actually exit the loop in
+            // It can happen that framesThisTime is 0. DCHECK that we will actually exit the loop in
             // this case.  framesThisTime is 0 only if readIndex >= endFrame;
-            ASSERT(framesThisTime ? true : readIndex >= endFrame);
+            DCHECK(framesThisTime ? true : readIndex >= endFrame);
 
             // Wrap-around.
             if (readIndex >= endFrame) {
                 readIndex -= deltaFrames;
                 if (renderSilenceAndFinishIfNotLooping(bus, writeIndex, framesToProcess))
                     break;
             }
         }
         virtualReadIndex = readIndex;
     } else {
@@ skipping 44 matching lines @@
     bus->clearSilentFlag();
 
     m_virtualReadIndex = virtualReadIndex;
 
     return true;
 }
 
 
 void AudioBufferSourceHandler::setBuffer(AudioBuffer* buffer, ExceptionState& exceptionState)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
     if (m_buffer) {
         exceptionState.throwDOMException(
             InvalidStateError,
             "Cannot set buffer after it has been already been set");
         return;
     }
 
     // The context must be locked since changing the buffer can re-configure the number of channels that are output.
     BaseAudioContext::AutoLocker contextLocker(context());
@@ skipping 38 matching lines @@
     m_buffer = buffer;
 }
 
 unsigned AudioBufferSourceHandler::numberOfChannels()
 {
     return output(0).numberOfChannels();
 }
 
 void AudioBufferSourceHandler::clampGrainParameters(const AudioBuffer* buffer)
 {
-    ASSERT(buffer);
+    DCHECK(buffer);
 
     // We have a buffer so we can clip the offset and duration to lie within the buffer.
     double bufferDuration = buffer->duration();
 
     m_grainOffset = clampTo(m_grainOffset, 0.0, bufferDuration);
 
     // If the duration was not explicitly given, use the buffer duration to set the grain
     // duration. Otherwise, we want to use the user-specified value, of course.
     if (!m_isDurationGiven)
         m_grainDuration = bufferDuration - m_grainOffset;
@@ skipping 26 matching lines @@
     startSource(when, grainOffset, buffer() ? buffer()->duration() : 0, false, exceptionState);
 }
 
 void AudioBufferSourceHandler::start(double when, double grainOffset, double grainDuration, ExceptionState& exceptionState)
 {
     startSource(when, grainOffset, grainDuration, true, exceptionState);
 }
 
 void AudioBufferSourceHandler::startSource(double when, double grainOffset, double grainDuration, bool isDurationGiven, ExceptionState& exceptionState)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
     context()->recordUserGestureState();
 
     if (playbackState() != UNSCHEDULED_STATE) {
         exceptionState.throwDOMException(
             InvalidStateError,
             "cannot call start more than once.");
         return;
     }
 
@@ skipping 70 matching lines @@
     double finalPlaybackRate = sampleRateFactor * basePlaybackRate;
 
     // Take the detune value into account for the final playback rate.
     finalPlaybackRate *= pow(2, m_detune->finalValue() / 1200);
 
     // Sanity check the total rate.  It's very important that the resampler not
     // get any bad rate values.
     finalPlaybackRate = clampTo(finalPlaybackRate, 0.0, MaxRate);
 
     bool isPlaybackRateValid = !std::isnan(finalPlaybackRate) && !std::isinf(finalPlaybackRate);
-    ASSERT(isPlaybackRateValid);
+    DCHECK(isPlaybackRateValid);
 
     if (!isPlaybackRateValid)
         finalPlaybackRate = 1.0;
 
     // Record the minimum playback rate for use by handleStoppableSourceNode.
     m_minPlaybackRate = std::min(finalPlaybackRate, m_minPlaybackRate);
 
     return finalPlaybackRate;
 }
 
@@ skipping 139 matching lines @@
 {
     audioBufferSourceHandler().start(when, grainOffset, exceptionState);
 }
 
 void AudioBufferSourceNode::start(double when, double grainOffset, double grainDuration, ExceptionState& exceptionState)
 {
     audioBufferSourceHandler().start(when, grainOffset, grainDuration, exceptionState);
 }
 
 } // namespace blink