Replace MessageLoopProxy with SingleThreadTaskRunner for the rest of media/.

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"
-#include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "media/audio/virtual_audio_output_stream.h"
 
 namespace media {
 
 // LoopbackAudioConverter works similar to AudioConverter and converts input
 // streams to different audio parameters. Then, the LoopbackAudioConverter can
 // be used as an input to another AudioConverter. This allows us to
 // use converted audio from AudioOutputStreams as input to an AudioConverter.
 // For example, this allows converting multiple streams into a common format and
 // using the converted audio as input to another AudioConverter (i.e. a mixer).
@@ skipping 20 matching lines @@
     return 1.0;
   }
 
   AudioConverter audio_converter_;
 
   DISALLOW_COPY_AND_ASSIGN(LoopbackAudioConverter);
 };
 
 VirtualAudioInputStream::VirtualAudioInputStream(
     const AudioParameters& params,
-    const scoped_refptr<base::MessageLoopProxy>& worker_loop,
+    const scoped_refptr<base::SingleThreadTaskRunner>& worker_task_runner,
     const AfterCloseCallback& after_close_cb)
-    : worker_loop_(worker_loop),
+    : 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_loop_, params_) {
+      fake_consumer_(worker_task_runner_, params_) {
   DCHECK(params_.IsValid());
-  DCHECK(worker_loop_.get());
+  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_);
 
   // Sanity-check: Contract for Add/RemoveOutputStream() requires that all
@@ skipping 51 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) {
-  DCHECK(worker_loop_->BelongsToCurrentThread());
+  DCHECK(worker_task_runner_->BelongsToCurrentThread());
   DCHECK(callback_);
 
   {
     base::AutoLock scoped_lock(converter_network_lock_);
     mixer_.Convert(audio_bus);
   }
   audio_bus->ToInterleaved(params_.frames_per_buffer(),
                            params_.bits_per_sample() / 8,
                            buffer_.get());
   callback_->OnData(this,
@@ skipping 32 matching lines @@
   return 1.0;
 }
 
 void VirtualAudioInputStream::SetAutomaticGainControl(bool enabled) {}
 
 bool VirtualAudioInputStream::GetAutomaticGainControl() {
   return false;
 }
 
 }  // namespace media