Fix issue with failing to call AudioBufferSource.onended in some cases

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 29 matching lines @@
 
 namespace blink {
 
 const double DefaultGrainDuration = 0.020; // 20ms
 
 // Arbitrary upper limit on playback rate.
 // Higher than expected rates can be useful when playing back oversampled buffers
 // to minimize linear interpolation aliasing.
 const double MaxRate = 1024;
 
+// Number of extra frames to use when determining if a source node can be stopped.  This should be
+// at least one rendering quantum, but we add one more quantum for good measure.  This doesn't need
+// to be extra precise, just more than one rendering quantum.  See |handleStoppableSourceNode()|.
+// FIXME: Expose the rendering quantum somehow instead of hardwiring a value here.
+const int kExtraStopFrames = 256;
+
 AudioBufferSourceHandler::AudioBufferSourceHandler(AudioNode& node, float sampleRate, AudioParamHandler& playbackRate, AudioParamHandler& detune)
     : AudioScheduledSourceHandler(NodeTypeAudioBufferSource, node, sampleRate)
     , m_buffer(nullptr)
     , m_playbackRate(playbackRate)
     , m_detune(detune)
     , m_isLooping(false)
     , m_loopStart(0)
     , m_loopEnd(0)
     , m_virtualReadIndex(0)
     , m_isGrain(false)
@@ skipping 423 matching lines @@
 double AudioBufferSourceHandler::computePlaybackRate()
 {
     double dopplerRate = 1;
     if (m_pannerNode)
         dopplerRate = m_pannerNode->dopplerRate();
 
     // Incorporate buffer's sample-rate versus AudioContext's sample-rate.
     // Normally it's not an issue because buffers are loaded at the
     // AudioContext's sample-rate, but we can handle it in any case.
     double sampleRateFactor = 1.0;
-    if (buffer())
-        sampleRateFactor = buffer()->sampleRate() / sampleRate();
+    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;
 
     // Take the detune value into account for the final playback rate.
     finalPlaybackRate *= pow(2, m_detune->finalValue() / 1200);
 
@@ skipping 30 matching lines @@
 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.
+    // 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 (!loop() && buffer() && isPlayingOrScheduled()) {
-        double stopTime = m_startTime + buffer()->duration();
+        // See crbug.com/478301. If a source node is started via start(), the source may not start
+        // at that time but one quantum (128 frames) later.  But we compute the stop time based on
+        // the start time and the duration, so we end up stopping one quantum early.  Thus, add a
+        // little extra time; we just need to stop the source sometime after it should have stopped
+        // if it hadn't already.  We don't need to be super precise on when to stop.
+        double extraStopTime = kExtraStopFrames / static_cast<double>(context()->sampleRate());
+        double stopTime = m_startTime + buffer()->duration() + 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()
@@ skipping 95 matching lines @@
 }
 
 void AudioBufferSourceNode::start(double when, double grainOffset, double grainDuration, ExceptionState& exceptionState)
 {
     audioBufferSourceHandler().start(when, grainOffset, grainDuration, exceptionState);
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)