Avoid slow AudioParam automation path when possible

third_party/WebKit/Source/modules/webaudio/AudioParam.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 29 matching lines @@
 const double AudioParamHandler::DefaultSmoothingConstant = 0.05;
 const double AudioParamHandler::SnapThreshold = 0.001;
 
 AudioParamHandler::AudioParamHandler(AbstractAudioContext& context, AudioParamType paramType, double defaultValue, float minValue, float maxValue)
     : AudioSummingJunction(context.deferredTaskHandler())
     , m_paramType(paramType)
     , m_intrinsicValue(defaultValue)
     , m_defaultValue(defaultValue)
     , m_minValue(minValue)
     , m_maxValue(maxValue)
-    , m_smoothedValue(defaultValue)
 {
     // The destination MUST exist because we need the destination handler for the AudioParam.
     RELEASE_ASSERT(context.destination());
 
     m_destinationHandler = &context.destination()->audioDestinationHandler();
+    m_timeline.setSmoothedValue(defaultValue);
 }
 
 AudioDestinationHandler& AudioParamHandler::destinationHandler() const
 {
     return *m_destinationHandler;
 }
 
 void AudioParamHandler::setParamType(AudioParamType paramType)
 {
     m_paramType = paramType;
@@ skipping 99 matching lines @@
 }
 
 void AudioParamHandler::setValue(float value)
 {
     setIntrinsicValue(value);
     updateHistograms(value);
 }
 
 float AudioParamHandler::smoothedValue()
 {
-    return m_smoothedValue;
+    return m_timeline.smoothedValue();
 }
 
 bool AudioParamHandler::smooth()
 {
     // If values have been explicitly scheduled on the timeline, then use the exact value.
     // Smoothing effectively is performed by the timeline.
     bool useTimelineValue = false;
     float value = m_timeline.valueForContextTime(destinationHandler(), intrinsicValue(), useTimelineValue, minValue(), maxValue());
 
-    if (m_smoothedValue == value) {
+
+    float smoothedValue = m_timeline.smoothedValue();
+    if (smoothedValue == value) {
         // Smoothed value has already approached and snapped to value.
         setIntrinsicValue(value);
         return true;
     }
 
     if (useTimelineValue) {
-        m_smoothedValue = value;
+        m_timeline.setSmoothedValue(value);
     } else {
         // Dezipper - exponential approach.
-        m_smoothedValue += (value - m_smoothedValue) * DefaultSmoothingConstant;
+        smoothedValue += (value - smoothedValue) * DefaultSmoothingConstant;
 
         // If we get close enough then snap to actual value.
         // FIXME: the threshold needs to be adjustable depending on range - but
         // this is OK general purpose value.
-        if (fabs(m_smoothedValue - value) < SnapThreshold)
-            m_smoothedValue = value;
+        if (fabs(smoothedValue - value) < SnapThreshold)
+            smoothedValue = value;
+        m_timeline.setSmoothedValue(smoothedValue);
     }
 
     setIntrinsicValue(value);
     return false;
 }
 
 float AudioParamHandler::finalValue()
 {
     float value = intrinsicValue();
     calculateFinalValues(&value, 1, false);
@@ skipping 284 matching lines @@
 }
 
 AudioParam* AudioParam::cancelScheduledValues(double startTime, ExceptionState& exceptionState)
 {
     handler().timeline().cancelScheduledValues(startTime, exceptionState);
     return this;
 }
 
 } // namespace blink