Remove dead code related to Web Audio doppler effects

third_party/WebKit/Source/modules/webaudio/AudioBufferSourceNode.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 61 matching lines @@
     initialize();
 }
 
 PassRefPtr<AudioBufferSourceHandler> AudioBufferSourceHandler::create(AudioNode& node, float sampleRate, AudioParamHandler& playbackRate, AudioParamHandler& detune)
 {
     return adoptRef(new AudioBufferSourceHandler(node, sampleRate, playbackRate, detune));
 }
 
 AudioBufferSourceHandler::~AudioBufferSourceHandler()
 {
-    clearPannerNode();
     uninitialize();
 }
 
 void AudioBufferSourceHandler::process(size_t framesToProcess)
 {
     AudioBus* outputBus = output(0).bus();
 
     if (!isInitialized()) {
         outputBus->zero();
         return;
@@ skipping 407 matching lines @@
     m_startTime = std::max(when, context()->currentTime());
 
     if (buffer())
         clampGrainParameters(buffer());
 
     setPlaybackState(SCHEDULED_STATE);
 }
 
 double AudioBufferSourceHandler::computePlaybackRate()
 {
-    double dopplerRate = 1;
-    if (m_pannerNode)
-        dopplerRate = m_pannerNode->dopplerRate();
-
     // Incorporate buffer's sample-rate versus AbstractAudioContext's sample-rate.
     // Normally it's not an issue because buffers are loaded at the
     // AbstractAudioContext's sample-rate, but we can handle it in any case.
     double sampleRateFactor = 1.0;
     if (buffer()) {
         // Use doubles to compute this to full accuracy.
         sampleRateFactor = buffer()->sampleRate() / static_cast<double>(sampleRate());
     }
 
     // Use finalValue() to incorporate changes of AudioParamTimeline and
     // AudioSummingJunction from m_playbackRate AudioParam.
     double basePlaybackRate = m_playbackRate->finalValue();
 
-    double finalPlaybackRate = dopplerRate * sampleRateFactor * basePlaybackRate;
+    double finalPlaybackRate = sampleRateFactor * basePlaybackRate;
 
     // Take the detune value into account for the final playback rate.
     finalPlaybackRate *= pow(2, m_detune->finalValue() / 1200);
 
     // Sanity check the total rate.  It's very important that the resampler not
     // get any bad rate values.
     finalPlaybackRate = clampTo(finalPlaybackRate, 0.0, MaxRate);
 
     bool isPlaybackRateValid = !std::isnan(finalPlaybackRate) && !std::isinf(finalPlaybackRate);
     ASSERT(isPlaybackRateValid);
 
     if (!isPlaybackRateValid)
         finalPlaybackRate = 1.0;
 
     // Record the minimum playback rate for use by handleStoppableSourceNode.
     m_minPlaybackRate = std::min(finalPlaybackRate, m_minPlaybackRate);
 
     return finalPlaybackRate;
 }
 
 bool AudioBufferSourceHandler::propagatesSilence() const
 {
     return !isPlayingOrScheduled() || hasFinished() || !m_buffer;
 }
 
-void AudioBufferSourceHandler::setPannerNode(PannerHandler* pannerNode)
-{
-    if (m_pannerNode != pannerNode && !hasFinished()) {
-        RefPtr<PannerHandler> oldPannerNode(m_pannerNode.release());
-        m_pannerNode = pannerNode;
-        if (pannerNode)
-            pannerNode->makeConnection();
-        if (oldPannerNode)
-            oldPannerNode->breakConnection();
-    }
-}
-
-void AudioBufferSourceHandler::clearPannerNode()
-{
-    if (m_pannerNode) {
-        m_pannerNode->breakConnection();
-        m_pannerNode.clear();
-    }
-}
-
 void AudioBufferSourceHandler::handleStoppableSourceNode()
 {
     // If the source node is not looping, and we have a buffer, we can determine when the source
     // would stop playing.  This is intended to handle the (uncommon) scenario where start() has
     // been called but is never connected to the destination (directly or indirectly).  By stopping
     // the node, the node can be collected.  Otherwise, the node will never get collected, leaking
     // memory.
     //
     // If looping was ever done (m_didSetLooping = true), give up.  We can't easily determine how
     // long we looped so we don't know the actual duration thus far, so don't try to do anything
@@ skipping 16 matching lines @@
         stopTime += extraStopTime;
         if (context()->currentTime() > stopTime) {
             // The context time has passed the time when the source nodes should have stopped
             // playing. Stop the node now and deref it. (But don't run the onEnded event because the
             // source never actually played.)
             finishWithoutOnEnded();
         }
     }
 }
 
-void AudioBufferSourceHandler::finish()
-{
-    clearPannerNode();
-    ASSERT(!m_pannerNode);
-    AudioScheduledSourceHandler::finish();
-}
-
 // ----------------------------------------------------------------
 AudioBufferSourceNode::AudioBufferSourceNode(AbstractAudioContext& context, float sampleRate)
     : AudioScheduledSourceNode(context)
     , m_playbackRate(AudioParam::create(context, 1.0))
     , m_detune(AudioParam::create(context, 0.0))
 {
     setHandler(AudioBufferSourceHandler::create(*this, sampleRate, m_playbackRate->handler(), m_detune->handler()));
 }
 
 AudioBufferSourceNode* AudioBufferSourceNode::create(AbstractAudioContext& context, float sampleRate)
@@ skipping 77 matching lines @@
 {
     audioBufferSourceHandler().start(when, grainOffset, exceptionState);
 }
 
 void AudioBufferSourceNode::start(double when, double grainOffset, double grainDuration, ExceptionState& exceptionState)
 {
     audioBufferSourceHandler().start(when, grainOffset, grainDuration, exceptionState);
 }
 
 } // namespace blink
-