Convert RELEASE_ASSERT()/ASSERT(...) to CHECK()/DCHECK_op(...) in platform/audio

third_party/WebKit/Source/platform/audio/AudioResamplerKernel.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 28 matching lines @@
           2 + static_cast<int>(MaxFramesToProcess * AudioResampler::MaxRate)),
       m_virtualReadIndex(0.0),
       m_fillIndex(0) {
   m_lastValues[0] = 0.0f;
   m_lastValues[1] = 0.0f;
 }
 
 float* AudioResamplerKernel::getSourcePointer(
     size_t framesToProcess,
     size_t* numberOfSourceFramesNeededP) {
-  ASSERT(framesToProcess <= MaxFramesToProcess);
+  DCHECK_LE(framesToProcess, MaxFramesToProcess);
 
   // Calculate the next "virtual" index.  After process() is called,
   // m_virtualReadIndex will equal this value.
   double nextFractionalIndex = m_virtualReadIndex + framesToProcess * rate();
 
   // Because we're linearly interpolating between the previous and next sample
   // we need to round up so we include the next sample.
   int endIndex = static_cast<int>(nextFractionalIndex +
                                   1.0);  // round up to next integer index
 
   // Determine how many input frames we'll need.
   // We need to fill the buffer up to and including endIndex (so add 1) but
   // we've already buffered m_fillIndex frames from last time.
   size_t framesNeeded = 1 + endIndex - m_fillIndex;
   if (numberOfSourceFramesNeededP)
     *numberOfSourceFramesNeededP = framesNeeded;
 
   // Do bounds checking for the source buffer.
   bool isGood = m_fillIndex < m_sourceBuffer.size() &&
                 m_fillIndex + framesNeeded <= m_sourceBuffer.size();
   DCHECK(isGood);
   if (!isGood)
     return 0;
 
   return m_sourceBuffer.data() + m_fillIndex;
 }
 
 void AudioResamplerKernel::process(float* destination, size_t framesToProcess) {
-  ASSERT(framesToProcess <= MaxFramesToProcess);
+  DCHECK_LE(framesToProcess, MaxFramesToProcess);
 
   float* source = m_sourceBuffer.data();
 
   double rate = this->rate();
   rate = clampTo(rate, 0.0, AudioResampler::MaxRate);
 
   // Start out with the previous saved values (if any).
   if (m_fillIndex > 0) {
     source[0] = m_lastValues[0];
     source[1] = m_lastValues[1];
   }
 
   // Make a local copy.
   double virtualReadIndex = m_virtualReadIndex;
 
   // Sanity check source buffer access.
-  ASSERT(framesToProcess > 0);
-  ASSERT(virtualReadIndex >= 0 &&
-         1 + static_cast<unsigned>(virtualReadIndex +
-                                   (framesToProcess - 1) * rate) <
-             m_sourceBuffer.size());
+  DCHECK_GT(framesToProcess, 0u);
+  DCHECK_GE(virtualReadIndex, 0);
+  DCHECK_LT(1 + static_cast<unsigned>(virtualReadIndex +
+                                      (framesToProcess - 1) * rate),
+            m_sourceBuffer.size());
 
   // Do the linear interpolation.
   int n = framesToProcess;
   while (n--) {
     unsigned readIndex = static_cast<unsigned>(virtualReadIndex);
     double interpolationFactor = virtualReadIndex - readIndex;
 
     double sample1 = source[readIndex];
     double sample2 = source[readIndex + 1];
 
@@ skipping 24 matching lines @@
   m_fillIndex = 0;
   m_lastValues[0] = 0.0f;
   m_lastValues[1] = 0.0f;
 }
 
 double AudioResamplerKernel::rate() const {
   return m_resampler->rate();
 }
 
 }  // namespace blink