Fix start/stop of html5 audio stream and race condition when pausing.

content/renderer/media/audio_renderer_impl.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include <algorithm>
 
@@ skipping 174 matching lines @@
 }
 
 void AudioRendererImpl::DoSeek() {
   earliest_end_time_ = base::Time::Now();
 
   // Pause and flush the stream when we seek to a new location.
   DCHECK(audio_device_.get());
   audio_device_->Pause(true);
 }
 
-void AudioRendererImpl::Render(const std::vector<float*>& audio_data,
-                               size_t number_of_frames,
-                               size_t audio_delay_milliseconds) {
+size_t AudioRendererImpl::Render(const std::vector<float*>& audio_data,
+                                 size_t number_of_frames,
+                                 size_t audio_delay_milliseconds) {
   if (stopped_ || GetPlaybackRate() == 0.0f) {
     // Output silence if stopped.
     for (size_t i = 0; i < audio_data.size(); ++i)
       memset(audio_data[i], 0, sizeof(float) * number_of_frames);
-    return;
+    return 0;
   }
 
   // Adjust the playback delay.
   base::Time current_time = base::Time::Now();
 
   base::TimeDelta request_delay =
       base::TimeDelta::FromMilliseconds(audio_delay_milliseconds);
 
   // Finally we need to adjust the delay according to playback rate.
   if (GetPlaybackRate() != 1.0f) {
     request_delay = base::TimeDelta::FromMicroseconds(
         static_cast<int64>(ceil(request_delay.InMicroseconds() *
                                 GetPlaybackRate())));
   }
 
   uint32 bytes_per_frame =
       audio_parameters_.bits_per_sample * audio_parameters_.channels / 8;
 
   const size_t buf_size = number_of_frames * bytes_per_frame;
   scoped_array<uint8> buf(new uint8[buf_size]);
 
   base::Time time_now = base::Time::Now();
   uint32 filled = FillBuffer(buf.get(),
                              buf_size,
                              request_delay,
                              time_now >= earliest_end_time_);
   DCHECK_LE(filled, buf_size);
+  UpdateEarliestEndTime(filled, request_delay, time_now);
 
   uint32 filled_frames = filled / bytes_per_frame;
 
   // Deinterleave each audio channel.
   int channels = audio_data.size();
   for (int channel_index = 0; channel_index < channels; ++channel_index) {
     media::DeinterleaveAudioChannel(buf.get(),
                                     audio_data[channel_index],
                                     channels,
                                     channel_index,
                                     bytes_per_frame / channels,
                                     filled_frames);
 
     // If FillBuffer() didn't give us enough data then zero out the remainder.
     if (filled_frames < number_of_frames) {
       int frames_to_zero = number_of_frames - filled_frames;
-      memset(audio_data[channel_index], 0, sizeof(float) * frames_to_zero);
+      memset(audio_data[channel_index] + filled_frames,
+             0,
+             sizeof(float) * frames_to_zero);
     }
   }
+  return filled_frames;
 }