Replace the guts of AudioRendererBase with calls to scaling algorithm.

chrome/renderer/media/audio_renderer_impl.cc

 // Copyright (c) 2009 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 "chrome/common/render_messages.h"
 #include "chrome/renderer/audio_message_filter.h"
 #include "chrome/renderer/media/audio_renderer_impl.h"
 #include "chrome/renderer/render_view.h"
 #include "chrome/renderer/render_thread.h"
 #include "media/base/filter_host.h"
 
 namespace {
 
 // We will try to fill 200 ms worth of audio samples in each packet. A round
 // trip latency for IPC messages are typically 10 ms, this should give us
 // plenty of time to avoid clicks.
 const int kMillisecondsPerPacket = 200;
 
 // We have at most 3 packets in browser, i.e. 600 ms. This is a reasonable
 // amount to avoid clicks.
 const int kPacketsInBuffer = 3;
 
 // We want to preroll 400 milliseconds before starting to play. Again, 400 ms
 // of audio data should give us enough time to get more from the renderer.
 const int kMillisecondsPreroll = 400;
 
 }  // namespace
 
 AudioRendererImpl::AudioRendererImpl(AudioMessageFilter* filter)
-    : AudioRendererBase(kDefaultMaxQueueSize),
+    : AudioRendererBase(),
       channels_(0),
       sample_rate_(0),
       sample_bits_(0),
       bytes_per_second_(0),
       filter_(filter),
       stream_id_(0),
       shared_memory_(NULL),
       shared_memory_size_(0),
       io_loop_(filter->message_loop()),
       stopped_(false),
-      playback_rate_(0.0f),
       pending_request_(false),
       prerolling_(true),
       preroll_bytes_(0) {
   DCHECK(io_loop_);
 }
 
 AudioRendererImpl::~AudioRendererImpl() {
 }
 
 base::TimeDelta AudioRendererImpl::ConvertToDuration(int bytes) {
@@ skipping 58 matching lines @@
 
   // Post a task to render thread to notify a packet reception.
   io_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &AudioRendererImpl::OnNotifyPacketReady));
 }
 
 void AudioRendererImpl::SetPlaybackRate(float rate) {
   DCHECK(rate >= 0.0f);
 
   // We have two cases here:
-  // Play: playback_rate_ == 0.0 && rate != 0.0
-  // Pause: playback_rate_ != 0.0 && rate == 0.0
+  // Play: GetPlaybackRate() == 0.0 && rate != 0.0
+  // Pause: GetPlaybackRate() != 0.0 && rate == 0.0
   AutoLock auto_lock(lock_);
-  if (playback_rate_ == 0.0f && rate != 0.0f) {
+  if (GetPlaybackRate() == 0.0f && rate != 0.0f) {
     // Play is a bit tricky, we can only play if we have done prerolling.
     // TODO(hclam): I should check for end of streams status here.
     if (!prerolling_)
       io_loop_->PostTask(FROM_HERE,
                          NewRunnableMethod(this, &AudioRendererImpl::OnPlay));
-  } else if (playback_rate_ != 0.0f && rate == 0.0f) {
+  } else if (GetPlaybackRate() != 0.0f && rate == 0.0f) {
     // Pause is easy, we can always pause.
     io_loop_->PostTask(FROM_HERE,
                        NewRunnableMethod(this, &AudioRendererImpl::OnPause));
   }
-  playback_rate_ = rate;
+  AudioRendererBase::SetPlaybackRate(rate);
 
   // If we are playing, give a kick to try fulfilling the packet request as
   // the previous packet request may be stalled by a pause.
   if (rate > 0.0f) {
     io_loop_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this, &AudioRendererImpl::OnNotifyPacketReady));
   }
 }
 
@@ skipping 121 matching lines @@
     return;
   filter_->Send(new ViewHostMsg_SetAudioVolume(0, stream_id_, left, right));
 }
 
 void AudioRendererImpl::OnNotifyPacketReady() {
   DCHECK(MessageLoop::current() == io_loop_);
 
   AutoLock auto_lock(lock_);
   if (stopped_)
     return;
-  if (pending_request_ && playback_rate_ > 0.0f) {
+  if (pending_request_ && GetPlaybackRate() > 0.0f) {
     DCHECK(shared_memory_.get());
 
     // Adjust the playback delay.
     base::Time current_time = base::Time::Now();
 
     // Save a local copy of the request delay.
     base::TimeDelta request_delay = request_delay_;
     if (current_time > request_timestamp_) {
       base::TimeDelta receive_latency = current_time - request_timestamp_;
 
       // If the receive latency is too much it may offset all the delay.
       if (receive_latency >= request_delay) {
         request_delay = base::TimeDelta();
       } else {
         request_delay -= receive_latency;
       }
     }
 
     size_t filled = FillBuffer(static_cast<uint8*>(shared_memory_->memory()),
                                shared_memory_size_,
-                               playback_rate_,
                                request_delay);
     // TODO(hclam): we should try to fill in the buffer as much as possible.
     if (filled > 0) {
       pending_request_ = false;
       request_delay_ = base::TimeDelta();
       request_timestamp_ = base::Time();
       // Then tell browser process we are done filling into the buffer.
       filter_->Send(
           new ViewHostMsg_NotifyAudioPacketReady(0, stream_id_, filled));
 
       if (prerolling_) {
         // We have completed prerolling.
         if (filled > preroll_bytes_) {
           prerolling_ = false;
           preroll_bytes_ = 0;
           filter_->Send(new ViewHostMsg_StartAudioStream(0, stream_id_));
         } else {
           preroll_bytes_ -= filled;
         }
       }
     }
   }
 }