Replace ASSERT with DCHECK in WebAudio

third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp

 /*
  * Copyright (C) 2011 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 138 matching lines @@
     return ParamEvent(ParamEvent::SetTarget, value, time, timeConstant, 0, nullptr);
 }
 
 AudioParamTimeline::ParamEvent AudioParamTimeline::ParamEvent::createSetValueCurveEvent(const DOMFloat32Array* curve, double time, double duration)
 {
     return ParamEvent(ParamEvent::SetValueCurve, 0, time, 0, duration, curve);
 }
 
 void AudioParamTimeline::setValueAtTime(float value, double time, ExceptionState& exceptionState)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
     if (!isNonNegativeAudioParamTime(time, exceptionState))
         return;
 
     insertEvent(ParamEvent::createSetValueEvent(value, time), exceptionState);
 }
 
 void AudioParamTimeline::linearRampToValueAtTime(float value, double time, float initialValue, double callTime, ExceptionState& exceptionState)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
     if (!isNonNegativeAudioParamTime(time, exceptionState))
         return;
 
     insertEvent(ParamEvent::createLinearRampEvent(value, time, initialValue, callTime), exceptionState);
 }
 
 void AudioParamTimeline::exponentialRampToValueAtTime(float value, double time, float initialValue, double callTime, ExceptionState& exceptionState)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
     if (!isNonNegativeAudioParamTime(time, exceptionState))
         return;
 
     if (!value) {
         exceptionState.throwDOMException(
             InvalidAccessError,
             "The float target value provided (" + String::number(value)
             + ") should not be in the range (" + String::number(-std::numeric_limits<float>::denorm_min())
             + ", " + String::number(std::numeric_limits<float>::denorm_min())
             + ").");
         return;
     }
 
     insertEvent(ParamEvent::createExponentialRampEvent(value, time, initialValue, callTime), exceptionState);
 }
 
 void AudioParamTimeline::setTargetAtTime(float target, double time, double timeConstant, ExceptionState& exceptionState)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
     if (!isNonNegativeAudioParamTime(time, exceptionState)
         || !isPositiveAudioParamTime(timeConstant, exceptionState, "Time constant"))
         return;
 
     insertEvent(ParamEvent::createSetTargetEvent(target, time, timeConstant), exceptionState);
 }
 
 void AudioParamTimeline::setValueCurveAtTime(DOMFloat32Array* curve, double time, double duration, ExceptionState& exceptionState)
 {
-    ASSERT(isMainThread());
-    ASSERT(curve);
+    DCHECK(isMainThread());
+    DCHECK(curve);
 
     if (!isNonNegativeAudioParamTime(time, exceptionState)
         || !isPositiveAudioParamTime(duration, exceptionState, "Duration"))
         return;
 
     if (curve->length() < 2) {
         exceptionState.throwDOMException(
             InvalidStateError,
             ExceptionMessages::indexExceedsMinimumBound(
                 "curve length",
                 curve->length(),
                 2U));
         return;
     }
 
     insertEvent(ParamEvent::createSetValueCurveEvent(curve, time, duration), exceptionState);
 
     // Insert a setValueAtTime event too to establish an event so that all
     // following events will process from the end of the curve instead of the
     // beginning.
     insertEvent(ParamEvent::createSetValueEvent(curve->data()[curve->length() - 1], time + duration), exceptionState);
 }
 
 void AudioParamTimeline::insertEvent(const ParamEvent& event, ExceptionState& exceptionState)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
     // Sanity check the event. Be super careful we're not getting infected with NaN or Inf. These
     // should have been handled by the caller.
     bool isValid = event.getType() < ParamEvent::LastType
         && std::isfinite(event.value())
         && std::isfinite(event.time())
         && std::isfinite(event.timeConstant())
         && std::isfinite(event.duration())
         && event.duration() >= 0;
 
-    ASSERT(isValid);
+    DCHECK(isValid);
     if (!isValid)
         return;
 
     MutexLocker locker(m_eventsLock);
 
     unsigned i = 0;
     double insertTime = event.time();
 
     if (!m_events.size()
         && (event.getType() == ParamEvent::LinearRampToValue
@@ skipping 58 matching lines @@
     //
     // Don't want to return false here because that would confuse the processing of the timeline
     // if previously we returned true and now suddenly return false, only to return true on the
     // next rendering quantum.  Currently, once a timeline has been introduced it is always true
     // forever because m_events never shrinks.
     return true;
 }
 
 void AudioParamTimeline::cancelScheduledValues(double startTime, ExceptionState& exceptionState)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
     MutexLocker locker(m_eventsLock);
 
     // Remove all events starting at startTime.
     for (unsigned i = 0; i < m_events.size(); ++i) {
         if (m_events[i].time() >= startTime) {
             m_events.remove(i, m_events.size() - i);
             break;
         }
     }
@@ skipping 52 matching lines @@
 
 float AudioParamTimeline::valuesForFrameRangeImpl(
     size_t startFrame,
     size_t endFrame,
     float defaultValue,
     float* values,
     unsigned numberOfValues,
     double sampleRate,
     double controlRate)
 {
-    ASSERT(values);
-    ASSERT(numberOfValues >= 1);
+    DCHECK(values);
+    DCHECK_GE(numberOfValues, 1u);
     if (!values || !(numberOfValues >= 1))
         return defaultValue;
 
     // Return default value if there are no events matching the desired time range.
     if (!m_events.size() || (endFrame / sampleRate <= m_events[0].time())) {
         for (unsigned i = 0; i < numberOfValues; ++i)
             values[i] = defaultValue;
         return defaultValue;
     }
 
@@ skipping 29 matching lines @@
     // If first event is after startFrame then fill initial part of values buffer with defaultValue
     // until we reach the first event time.
     double firstEventTime = m_events[0].time();
     if (firstEventTime > startFrame / sampleRate) {
         // |fillToFrame| is an exclusive upper bound, so use ceil() to compute the bound from the
         // firstEventTime.
         size_t fillToFrame = endFrame;
         double firstEventFrame = ceil(firstEventTime * sampleRate);
         if (endFrame > firstEventFrame)
             fillToFrame = static_cast<size_t>(firstEventFrame);
-        ASSERT(fillToFrame >= startFrame);
+        DCHECK_GE(fillToFrame, startFrame);
 
         fillToFrame -= startFrame;
         fillToFrame = std::min(fillToFrame, static_cast<size_t>(numberOfValues));
         for (; writeIndex < fillToFrame; ++writeIndex)
             values[writeIndex] = defaultValue;
 
         currentFrame += fillToFrame;
     }
 
     float value = defaultValue;
@@ skipping 99 matching lines @@
         // for frame 128.  This requires that fillToEndFrame be at least 129.  This is achieved by
         // ceil(time2).
         //
         // However, time2 can be very large, so compute this carefully in the case where time2
         // exceeds the size of a size_t.
 
         size_t fillToEndFrame = endFrame;
         if (endFrame > time2 * sampleRate)
             fillToEndFrame = static_cast<size_t>(ceil(time2 * sampleRate));
 
-        ASSERT(fillToEndFrame >= startFrame);
+        DCHECK_GE(fillToEndFrame, startFrame);
         size_t fillToFrame = fillToEndFrame - startFrame;
         fillToFrame = std::min(fillToFrame, static_cast<size_t>(numberOfValues));
 
         // First handle linear and exponential ramps which require looking ahead to the next event.
         if (nextEventType == ParamEvent::LinearRampToValue) {
             const float valueDelta = value2 - value1;
 #if CPU(X86) || CPU(X86_64)
             // Minimize in-loop operations. Calculate starting value and increment. Next step: value += inc.
             //  value = value1 + (currentFrame/sampleRate - time1) * k * (value2 - value1);
             //  inc = 4 / sampleRate * k * (value2 - value1);
@@ skipping 318 matching lines @@
                         } else {
                             curveIndex0 = numberOfCurvePoints - 1;
                         }
 
                         unsigned curveIndex1 = std::min(curveIndex0 + 1, numberOfCurvePoints - 1);
 
                         // Linearly interpolate between the two nearest curve points.  |delta| is
                         // clamped to 1 because currentVirtualIndex can exceed curveIndex0 by more
                         // than one.  This can happen when we reached the end of the curve but still
                         // need values to fill out the current rendering quantum.
-                        ASSERT(curveIndex0 < numberOfCurvePoints);
-                        ASSERT(curveIndex1 < numberOfCurvePoints);
+                        DCHECK_LT(curveIndex0, numberOfCurvePoints);
+                        DCHECK_LT(curveIndex1, numberOfCurvePoints);
                         float c0 = curveData[curveIndex0];
                         float c1 = curveData[curveIndex1];
                         double delta = std::min(currentVirtualIndex - curveIndex0, 1.0);
 
                         value = c0 + (c1 - c0) * delta;
 
                         values[writeIndex] = value;
                     }
 
                     // If there's any time left after the duration of this event and the start
@@ skipping 27 matching lines @@
     for (; writeIndex < numberOfValues; ++writeIndex)
         values[writeIndex] = value;
 
     // This value is used to set the .value attribute of the AudioParam.  it should be the last
     // computed value.
     return values[numberOfValues - 1];
 }
 
 } // namespace blink