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

third_party/WebKit/Source/platform/audio/HRTFElevation.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
@@ skipping 62 matching lines @@
   DEFINE_THREAD_SAFE_STATIC_LOCAL(AudioBusMap, audioBusMap, new AudioBusMap());
   DEFINE_THREAD_SAFE_STATIC_LOCAL(Mutex, mutex, new Mutex());
 
   MutexLocker locker(mutex);
   RefPtr<AudioBus> bus;
   AudioBusMap::iterator iterator = audioBusMap.find(subjectName);
   if (iterator == audioBusMap.end()) {
     RefPtr<AudioBus> concatenatedImpulseResponses(
         AudioBus::loadPlatformResource(subjectName.utf8().data(),
                                        ResponseSampleRate));
-    ASSERT(concatenatedImpulseResponses);
+    DCHECK(concatenatedImpulseResponses);
     if (!concatenatedImpulseResponses)
       return nullptr;
 
     bus = concatenatedImpulseResponses;
     audioBusMap.set(subjectName, bus);
   } else
     bus = iterator->value;
 
   size_t responseLength = bus->length();
   size_t expectedLength =
       static_cast<size_t>(TotalNumberOfResponses * ResponseFrameSize);
 
   // Check number of channels and length. For now these are fixed and known.
   bool isBusGood =
       responseLength == expectedLength && bus->numberOfChannels() == 2;
-  ASSERT(isBusGood);
+  DCHECK(isBusGood);
   if (!isBusGood)
     return nullptr;
 
   return bus;
 }
 #endif
 
 bool HRTFElevation::calculateKernelsForAzimuthElevation(
     int azimuth,
     int elevation,
     float sampleRate,
     const String& subjectName,
     std::unique_ptr<HRTFKernel>& kernelL,
     std::unique_ptr<HRTFKernel>& kernelR) {
   // Valid values for azimuth are 0 -> 345 in 15 degree increments.
   // Valid values for elevation are -45 -> +90 in 15 degree increments.
 
   bool isAzimuthGood =
       azimuth >= 0 && azimuth <= 345 && (azimuth / 15) * 15 == azimuth;
-  ASSERT(isAzimuthGood);
+  DCHECK(isAzimuthGood);
   if (!isAzimuthGood)
     return false;
 
   bool isElevationGood =
       elevation >= -45 && elevation <= 90 && (elevation / 15) * 15 == elevation;
-  ASSERT(isElevationGood);
+  DCHECK(isElevationGood);
   if (!isElevationGood)
     return false;
 
   // Construct the resource name from the subject name, azimuth, and elevation,
   // for example:
   // "IRC_Composite_C_R0195_T015_P000"
   // Note: the passed in subjectName is not a string passed in via JavaScript or
   // the web.  It's passed in as an internal ASCII identifier and is an
   // implementation detail.
   int positiveElevation = elevation < 0 ? elevation + 360 : elevation;
 
 #if USE(CONCATENATED_IMPULSE_RESPONSES)
   RefPtr<AudioBus> bus(getConcatenatedImpulseResponsesForSubject(subjectName));
 
   if (!bus)
     return false;
 
   // Just sequentially search the table to find the correct index.
   int elevationIndex = -1;
 
   for (int k = 0; k < ElevationIndexTableSize; ++k) {
     if (ElevationIndexTable[k] == positiveElevation) {
       elevationIndex = k;
       break;
     }
   }
 
   bool isElevationIndexGood =
       (elevationIndex >= 0) && (elevationIndex < ElevationIndexTableSize);
-  ASSERT(isElevationIndexGood);
+  DCHECK(isElevationIndexGood);
   if (!isElevationIndexGood)
     return false;
 
   // The concatenated impulse response is a bus containing all
   // the elevations per azimuth, for all azimuths by increasing
   // order. So for a given azimuth and elevation we need to compute
   // the index of the wanted audio frames in the concatenated table.
   unsigned index =
       ((azimuth / AzimuthSpacing) * HRTFDatabase::NumberOfRawElevations) +
       elevationIndex;
   bool isIndexGood = index < TotalNumberOfResponses;
-  ASSERT(isIndexGood);
+  DCHECK(isIndexGood);
   if (!isIndexGood)
     return false;
 
   // Extract the individual impulse response from the concatenated
   // responses and potentially sample-rate convert it to the desired
   // (hardware) sample-rate.
   unsigned startFrame = index * ResponseFrameSize;
   unsigned stopFrame = startFrame + ResponseFrameSize;
   RefPtr<AudioBus> preSampleRateConvertedResponse(
       AudioBus::createBufferFromRange(bus.get(), startFrame, stopFrame));
   RefPtr<AudioBus> response(AudioBus::createBySampleRateConverting(
       preSampleRateConvertedResponse.get(), false, sampleRate));
   AudioChannel* leftEarImpulseResponse =
       response->channel(AudioBus::ChannelLeft);
   AudioChannel* rightEarImpulseResponse =
       response->channel(AudioBus::ChannelRight);
 #else
   String resourceName =
       String::format("IRC_%s_C_R0195_T%03d_P%03d", subjectName.utf8().data(),
                      azimuth, positiveElevation);
 
   RefPtr<AudioBus> impulseResponse(
       AudioBus::loadPlatformResource(resourceName.utf8().data(), sampleRate));
 
-  ASSERT(impulseResponse.get());
+  DCHECK(impulseResponse.get());
   if (!impulseResponse.get())
     return false;
 
   size_t responseLength = impulseResponse->length();
   size_t expectedLength = static_cast<size_t>(256 * (sampleRate / 44100.0));
 
   // Check number of channels and length.  For now these are fixed and known.
   bool isBusGood = responseLength == expectedLength &&
                    impulseResponse->numberOfChannels() == 2;
-  ASSERT(isBusGood);
+  DCHECK(isBusGood);
   if (!isBusGood)
     return false;
 
   AudioChannel* leftEarImpulseResponse =
       impulseResponse->channelByType(AudioBus::ChannelLeft);
   AudioChannel* rightEarImpulseResponse =
       impulseResponse->channelByType(AudioBus::ChannelRight);
 #endif
 
   // Note that depending on the fftSize returned by the panner, we may be
@@ skipping 37 matching lines @@
     60,  // 330
     45   //  345
 };
 
 std::unique_ptr<HRTFElevation> HRTFElevation::createForSubject(
     const String& subjectName,
     int elevation,
     float sampleRate) {
   bool isElevationGood =
       elevation >= -45 && elevation <= 90 && (elevation / 15) * 15 == elevation;
-  ASSERT(isElevationGood);
+  DCHECK(isElevationGood);
   if (!isElevationGood)
     return nullptr;
 
   std::unique_ptr<HRTFKernelList> kernelListL =
       WTF::makeUnique<HRTFKernelList>(NumberOfTotalAzimuths);
   std::unique_ptr<HRTFKernelList> kernelListR =
       WTF::makeUnique<HRTFKernelList>(NumberOfTotalAzimuths);
 
   // Load convolution kernels from HRTF files.
   int interpolatedIndex = 0;
@@ skipping 72 matching lines @@
   return hrtfElevation;
 }
 
 void HRTFElevation::getKernelsFromAzimuth(double azimuthBlend,
                                           unsigned azimuthIndex,
                                           HRTFKernel*& kernelL,
                                           HRTFKernel*& kernelR,
                                           double& frameDelayL,
                                           double& frameDelayR) {
   bool checkAzimuthBlend = azimuthBlend >= 0.0 && azimuthBlend < 1.0;
-  ASSERT(checkAzimuthBlend);
+  DCHECK(checkAzimuthBlend);
   if (!checkAzimuthBlend)
     azimuthBlend = 0.0;
 
   unsigned numKernels = m_kernelListL->size();
 
   bool isIndexGood = azimuthIndex < numKernels;
-  ASSERT(isIndexGood);
+  DCHECK(isIndexGood);
   if (!isIndexGood) {
     kernelL = 0;
     kernelR = 0;
     return;
   }
 
   // Return the left and right kernels.
   kernelL = m_kernelListL->at(azimuthIndex).get();
   kernelR = m_kernelListR->at(azimuthIndex).get();
 
   frameDelayL = m_kernelListL->at(azimuthIndex)->frameDelay();
   frameDelayR = m_kernelListR->at(azimuthIndex)->frameDelay();
 
   int azimuthIndex2 = (azimuthIndex + 1) % numKernels;
   double frameDelay2L = m_kernelListL->at(azimuthIndex2)->frameDelay();
   double frameDelay2R = m_kernelListR->at(azimuthIndex2)->frameDelay();
 
   // Linearly interpolate delays.
   frameDelayL =
       (1.0 - azimuthBlend) * frameDelayL + azimuthBlend * frameDelay2L;
   frameDelayR =
       (1.0 - azimuthBlend) * frameDelayR + azimuthBlend * frameDelay2R;
 }
 
 }  // namespace blink