Remove connection from AudioParamHandler to AudioContext.

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 17 matching lines @@
 #include "modules/webaudio/AudioNodeOutput.h"
 #include "platform/FloatConversion.h"
 #include "platform/audio/AudioUtilities.h"
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
 const double AudioParamHandler::DefaultSmoothingConstant = 0.05;
 const double AudioParamHandler::SnapThreshold = 0.001;
 
-AbstractAudioContext* AudioParamHandler::context() const
+AudioDestinationHandler& AudioParamHandler::audioDestination() const
 {
-    // TODO(tkent): We can remove this dangerous function by removing
-    // AbstractAudioContext dependency from AudioParamTimeline.
-    ASSERT_WITH_SECURITY_IMPLICATION(deferredTaskHandler().isAudioThread());
-    return m_context;
+    return *m_destination;

[hongchan, 2016/04/26 17:04:00]

Perhaps:
audioDestination() => destinationHandler();
m_destination => m_destinationHandler;

Here and on.

 }
 
 float AudioParamHandler::value()
 {
     // Update value for timeline.
     float v = intrinsicValue();
     if (deferredTaskHandler().isAudioThread()) {
         bool hasValue;
-        float timelineValue = m_timeline.valueForContextTime(context(), v, hasValue);
+        float timelineValue = m_timeline.valueForContextTime(audioDestination(), v, hasValue);
 
         if (hasValue)
             v = timelineValue;
     }
 
     setIntrinsicValue(v);
     return v;
 }
 
 void AudioParamHandler::setValue(float value)
 {
     setIntrinsicValue(value);
 }
 
 float AudioParamHandler::smoothedValue()
 {
     return m_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 = intrinsicValue();
-    if (context())
-        value = m_timeline.valueForContextTime(context(), value, useTimelineValue);
+    float value = m_timeline.valueForContextTime(audioDestination(), intrinsicValue(), useTimelineValue);
 
     if (m_smoothedValue == value) {
         // Smoothed value has already approached and snapped to value.
         setIntrinsicValue(value);
         return true;
     }
 
     if (useTimelineValue) {
         m_smoothedValue = value;
     } else {
@@ skipping 37 matching lines @@
 
     // The calculated result will be the "intrinsic" value summed with all audio-rate connections.
 
     if (sampleAccurate) {
         // Calculate sample-accurate (a-rate) intrinsic values.
         calculateTimelineValues(values, numberOfValues);
     } else {
         // Calculate control-rate (k-rate) intrinsic value.
         bool hasValue;
         float value = intrinsicValue();
-        float timelineValue = m_timeline.valueForContextTime(context(), value, hasValue);
+        float timelineValue = m_timeline.valueForContextTime(audioDestination(), value, hasValue);
 
         if (hasValue)
             value = timelineValue;
 
         values[0] = value;
         setIntrinsicValue(value);
     }
 
     // Now sum all of the audio-rate connections together (unity-gain summing junction).
     // Note that connections would normally be mono, but we mix down to mono if necessary.
     RefPtr<AudioBus> summingBus = AudioBus::create(1, numberOfValues, false);
     summingBus->setChannelMemory(0, values, numberOfValues);
 
     for (unsigned i = 0; i < numberOfRenderingConnections(); ++i) {
         AudioNodeOutput* output = renderingOutput(i);
         ASSERT(output);
 
         // Render audio from this output.
         AudioBus* connectionBus = output->pull(0, AudioHandler::ProcessingSizeInFrames);
 
         // Sum, with unity-gain.
         summingBus->sumFrom(*connectionBus);
     }
 }
 
 void AudioParamHandler::calculateTimelineValues(float* values, unsigned numberOfValues)
 {
     // Calculate values for this render quantum.  Normally numberOfValues will
     // equal to AudioHandler::ProcessingSizeInFrames (the render quantum size).
-    double sampleRate = context()->sampleRate();
-    size_t startFrame = context()->currentSampleFrame();
+    double sampleRate = audioDestination().sampleRate();
+    size_t startFrame = audioDestination().currentSampleFrame();
     size_t endFrame = startFrame + numberOfValues;
 
     // Note we're running control rate at the sample-rate.
     // Pass in the current value as default value.
     setIntrinsicValue(m_timeline.valuesForFrameRange(startFrame, endFrame, intrinsicValue(), values, numberOfValues, sampleRate, sampleRate));
 }
 
 void AudioParamHandler::connect(AudioNodeOutput& output)
 {
     ASSERT(deferredTaskHandler().isGraphOwner());
@@ skipping 82 matching lines @@
 }
 
 AudioParam* AudioParam::cancelScheduledValues(double startTime, ExceptionState& exceptionState)
 {
     handler().timeline().cancelScheduledValues(startTime, exceptionState);
     return this;
 }
 
 } // namespace blink