Moved the fake input stream's processing onto the audio worker thread.

media/audio/virtual_audio_input_stream.cc

 // Copyright (c) 2012 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 "media/audio/virtual_audio_input_stream.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 40 matching lines @@
     const AudioParameters& params,
     const scoped_refptr<base::SingleThreadTaskRunner>& worker_task_runner,
     const AfterCloseCallback& after_close_cb)
     : worker_task_runner_(worker_task_runner),
       after_close_cb_(after_close_cb),
       callback_(NULL),
       buffer_(new uint8[params.GetBytesPerBuffer()]),
       params_(params),
       mixer_(params_, params_, false),
       num_attached_output_streams_(0),
-      fake_consumer_(worker_task_runner_, params_) {
+      fake_worker_(worker_task_runner_, params_),
+      audio_bus_(AudioBus::Create(params)) {
   DCHECK(params_.IsValid());
   DCHECK(worker_task_runner_.get());
 
   // VAIS can be constructed on any thread, but will DCHECK that all
   // AudioInputStream methods are called from the same thread.
   thread_checker_.DetachFromThread();
 }
 
 VirtualAudioInputStream::~VirtualAudioInputStream() {
   DCHECK(!callback_);
@@ skipping 10 matching lines @@
 
 bool VirtualAudioInputStream::Open() {
   DCHECK(thread_checker_.CalledOnValidThread());
   memset(buffer_.get(), 0, params_.GetBytesPerBuffer());
   return true;
 }
 
 void VirtualAudioInputStream::Start(AudioInputCallback* callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   callback_ = callback;
-  fake_consumer_.Start(base::Bind(
+  fake_worker_.Start(base::Bind(
       &VirtualAudioInputStream::PumpAudio, base::Unretained(this)));
 }
 
 void VirtualAudioInputStream::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  fake_consumer_.Stop();
+  fake_worker_.Stop();
   callback_ = NULL;
 }
 
 void VirtualAudioInputStream::AddOutputStream(
     VirtualAudioOutputStream* stream, const AudioParameters& output_params) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   base::AutoLock scoped_lock(converter_network_lock_);
 
   AudioConvertersMap::iterator converter = converters_.find(output_params);
@@ skipping 16 matching lines @@
 
   base::AutoLock scoped_lock(converter_network_lock_);
 
   DCHECK(converters_.find(output_params) != converters_.end());
   converters_[output_params]->RemoveInput(stream);
 
   --num_attached_output_streams_;
   DCHECK_LE(0, num_attached_output_streams_);
 }
 
-void VirtualAudioInputStream::PumpAudio(AudioBus* audio_bus) {
+void VirtualAudioInputStream::PumpAudio() {
   DCHECK(worker_task_runner_->BelongsToCurrentThread());
 
   {
     base::AutoLock scoped_lock(converter_network_lock_);
     // Because the audio is being looped-back, the delay until it will be played
     // out is zero.
-    mixer_.ConvertWithDelay(base::TimeDelta(), audio_bus);
+    mixer_.ConvertWithDelay(base::TimeDelta(), audio_bus_.get());
   }
   // Because the audio is being looped-back, the delay since since it was
   // recorded is zero.
-  callback_->OnData(this, audio_bus, 0, 1.0);
+  callback_->OnData(this, audio_bus_.get(), 0, 1.0);
 }
 
 void VirtualAudioInputStream::Close() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   Stop();  // Make sure callback_ is no longer being used.
 
   // If a non-null AfterCloseCallback was provided to the constructor, invoke it
   // here.  The callback is moved to a stack-local first since |this| could be
   // destroyed during Run().
@@ skipping 20 matching lines @@
 
 bool VirtualAudioInputStream::GetAutomaticGainControl() {
   return false;
 }
 
 bool VirtualAudioInputStream::IsMuted() {
   return false;
 }
 
 }  // namespace media