Convert ASSERT(foo) to DCHECK(foo) in platform/audio

third_party/WebKit/Source/platform/audio/HRTFPanner.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 42 matching lines @@
       m_convolverL1(fftSizeForSampleRate(sampleRate)),
       m_convolverR1(fftSizeForSampleRate(sampleRate)),
       m_convolverL2(fftSizeForSampleRate(sampleRate)),
       m_convolverR2(fftSizeForSampleRate(sampleRate)),
       m_delayLineL(MaxDelayTimeSeconds, sampleRate),
       m_delayLineR(MaxDelayTimeSeconds, sampleRate),
       m_tempL1(AudioUtilities::kRenderQuantumFrames),
       m_tempR1(AudioUtilities::kRenderQuantumFrames),
       m_tempL2(AudioUtilities::kRenderQuantumFrames),
       m_tempR2(AudioUtilities::kRenderQuantumFrames) {
-  ASSERT(databaseLoader);
+  DCHECK(databaseLoader);
 }
 
 HRTFPanner::~HRTFPanner() {}
 
 size_t HRTFPanner::fftSizeForSampleRate(float sampleRate) {
   // The HRTF impulse responses (loaded as audio resources) are 512
   // sample-frames @44.1KHz.  Currently, we truncate the impulse responses to
   // half this size, but an FFT-size of twice impulse response size is needed
   // (for convolution).  So for sample rates around 44.1KHz an FFT size of 512
   // is good.  For different sample rates, the truncated response is resampled.
   // The resampled length is used to compute the FFT size by choosing a power
   // of two that is greater than or equal the resampled length. This power of
   // two is doubled to get the actual FFT size.
 
-  ASSERT(AudioUtilities::isValidAudioBufferSampleRate(sampleRate));
+  DCHECK(AudioUtilities::isValidAudioBufferSampleRate(sampleRate));
 
   int truncatedImpulseLength = 256;
   double sampleRateRatio = sampleRate / 44100;
   double resampledLength = truncatedImpulseLength * sampleRateRatio;
 
   return 2 * (1 << static_cast<unsigned>(log2(resampledLength)));
 }
 
 void HRTFPanner::reset() {
   m_convolverL1.reset();
@@ skipping 29 matching lines @@
 
 void HRTFPanner::pan(double desiredAzimuth,
                      double elevation,
                      const AudioBus* inputBus,
                      AudioBus* outputBus,
                      size_t framesToProcess,
                      AudioBus::ChannelInterpretation channelInterpretation) {
   unsigned numInputChannels = inputBus ? inputBus->numberOfChannels() : 0;
 
   bool isInputGood = inputBus && numInputChannels >= 1 && numInputChannels <= 2;
-  ASSERT(isInputGood);
+  DCHECK(isInputGood);
 
   bool isOutputGood = outputBus && outputBus->numberOfChannels() == 2 &&
                       framesToProcess <= outputBus->length();
-  ASSERT(isOutputGood);
+  DCHECK(isOutputGood);
 
   if (!isInputGood || !isOutputGood) {
     if (outputBus)
       outputBus->zero();
     return;
   }
 
   HRTFDatabase* database = m_databaseLoader->database();
   if (!database) {
     outputBus->copyFrom(*inputBus, channelInterpretation);
     return;
   }
 
   // IRCAM HRTF azimuths values from the loaded database is reversed from the
   // panner's notion of azimuth.
   double azimuth = -desiredAzimuth;
 
   bool isAzimuthGood = azimuth >= -180.0 && azimuth <= 180.0;
-  ASSERT(isAzimuthGood);
+  DCHECK(isAzimuthGood);
   if (!isAzimuthGood) {
     outputBus->zero();
     return;
   }
 
   // Normally, we'll just be dealing with mono sources.
   // If we have a stereo input, implement stereo panning with left source
   // processed by left HRTF, and right source by right HRTF.
   const AudioChannel* inputChannelL =
       inputBus->channelByType(AudioBus::ChannelLeft);
@@ skipping 65 matching lines @@
     double frameDelayL2;
     double frameDelayR2;
     database->getKernelsFromAzimuthElevation(azimuthBlend, m_azimuthIndex1,
                                              m_elevation1, kernelL1, kernelR1,
                                              frameDelayL1, frameDelayR1);
     database->getKernelsFromAzimuthElevation(azimuthBlend, m_azimuthIndex2,
                                              m_elevation2, kernelL2, kernelR2,
                                              frameDelayL2, frameDelayR2);
 
     bool areKernelsGood = kernelL1 && kernelR1 && kernelL2 && kernelR2;
-    ASSERT(areKernelsGood);
+    DCHECK(areKernelsGood);
     if (!areKernelsGood) {
       outputBus->zero();
       return;
     }
 
     ASSERT(frameDelayL1 / sampleRate() < MaxDelayTimeSeconds &&
            frameDelayR1 / sampleRate() < MaxDelayTimeSeconds);
     ASSERT(frameDelayL2 / sampleRate() < MaxDelayTimeSeconds &&
            frameDelayR2 / sampleRate() < MaxDelayTimeSeconds);
 
@@ skipping 105 matching lines @@
          (fftSize() / 2) / static_cast<double>(sampleRate());
 }
 
 double HRTFPanner::latencyTime() const {
   // The latency of a FFTConvolver is also fftSize() / 2, and is in addition to
   // its tailTime of the same value.
   return (fftSize() / 2) / static_cast<double>(sampleRate());
 }
 
 }  // namespace blink