Replace MessageLoopProxy with SingleThreadTaskRunner for the rest of media/.

media/audio/audio_input_controller.cc

Index: media/audio/audio_input_controller.cc
diff --git a/media/audio/audio_input_controller.cc b/media/audio/audio_input_controller.cc
index ef94d1274d66d8ab843b26255b904b5f4960b32d..168ee87b3506815fff82e3787c215123a7577e05 100644
--- a/media/audio/audio_input_controller.cc
+++ b/media/audio/audio_input_controller.cc
@@ -33,7 +33,7 @@ AudioInputController::Factory* AudioInputController::factory_ = NULL;
 AudioInputController::AudioInputController(EventHandler* handler,
                                            SyncWriter* sync_writer,
                                            UserInputMonitor* user_input_monitor)
-    : creator_loop_(base::MessageLoopProxy::current()),
+    : creator_task_runner_(base::MessageLoopProxy::current()),
       handler_(handler),
       stream_(NULL),
       data_is_active_(false),
@@ -42,7 +42,7 @@ AudioInputController::AudioInputController(EventHandler* handler,
       max_volume_(0.0),
       user_input_monitor_(user_input_monitor),
       prev_key_down_count_(0) {
-  DCHECK(creator_loop_.get());
+  DCHECK(creator_task_runner_.get());
 }
 
 AudioInputController::~AudioInputController() {
@@ -68,11 +68,11 @@ scoped_refptr<AudioInputController> AudioInputController::Create(
   scoped_refptr<AudioInputController> controller(
       new AudioInputController(event_handler, NULL, user_input_monitor));
 
-  controller->message_loop_ = audio_manager->GetMessageLoop();
+  controller->task_runner_ = audio_manager->GetTaskRunner();
 
   // Create and open a new audio input stream from the existing
   // audio-device thread.
-  if (!controller->message_loop_->PostTask(FROM_HERE,
+  if (!controller->task_runner_->PostTask(FROM_HERE,
           base::Bind(&AudioInputController::DoCreate, controller,
                      base::Unretained(audio_manager), params, device_id))) {
     controller = NULL;
@@ -99,11 +99,11 @@ scoped_refptr<AudioInputController> AudioInputController::CreateLowLatency(
   // the audio-manager thread.
   scoped_refptr<AudioInputController> controller(
       new AudioInputController(event_handler, sync_writer, user_input_monitor));
-  controller->message_loop_ = audio_manager->GetMessageLoop();
+  controller->task_runner_ = audio_manager->GetTaskRunner();
 
   // Create and open a new audio input stream from the existing
   // audio-device thread. Use the provided audio-input device.
-  if (!controller->message_loop_->PostTask(FROM_HERE,
+  if (!controller->task_runner_->PostTask(FROM_HERE,
           base::Bind(&AudioInputController::DoCreate, controller,
                      base::Unretained(audio_manager), params, device_id))) {
     controller = NULL;
@@ -114,7 +114,7 @@ scoped_refptr<AudioInputController> AudioInputController::CreateLowLatency(
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::CreateForStream(
-    const scoped_refptr<base::MessageLoopProxy>& message_loop,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     EventHandler* event_handler,
     AudioInputStream* stream,
     SyncWriter* sync_writer,
@@ -126,14 +126,14 @@ scoped_refptr<AudioInputController> AudioInputController::CreateForStream(
   // the audio-manager thread.
   scoped_refptr<AudioInputController> controller(
       new AudioInputController(event_handler, sync_writer, user_input_monitor));
-  controller->message_loop_ = message_loop;
+  controller->task_runner_ = task_runner;
 
   // TODO(miu): See TODO at top of file.  Until that's resolved, we need to
   // disable the error auto-detection here (since the audio mirroring
   // implementation will reliably report error and close events).  Note, of
   // course, that we're assuming CreateForStream() has been called for the audio
   // mirroring use case only.
-  if (!controller->message_loop_->PostTask(
+  if (!controller->task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&AudioInputController::DoCreateForStream, controller,
                      stream, false))) {
@@ -144,32 +144,32 @@ scoped_refptr<AudioInputController> AudioInputController::CreateForStream(
 }
 
 void AudioInputController::Record() {
-  message_loop_->PostTask(FROM_HERE, base::Bind(
+  task_runner_->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoRecord, this));
 }
 
 void AudioInputController::Close(const base::Closure& closed_task) {
   DCHECK(!closed_task.is_null());
-  DCHECK(creator_loop_->BelongsToCurrentThread());
+  DCHECK(creator_task_runner_->BelongsToCurrentThread());
 
-  message_loop_->PostTaskAndReply(
+  task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(&AudioInputController::DoClose, this), closed_task);
 }
 
 void AudioInputController::SetVolume(double volume) {
-  message_loop_->PostTask(FROM_HERE, base::Bind(
+  task_runner_->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoSetVolume, this, volume));
 }
 
 void AudioInputController::SetAutomaticGainControl(bool enabled) {
-  message_loop_->PostTask(FROM_HERE, base::Bind(
+  task_runner_->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoSetAutomaticGainControl, this, enabled));
 }
 
 void AudioInputController::DoCreate(AudioManager* audio_manager,
                                     const AudioParameters& params,
                                     const std::string& device_id) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.CreateTime");
   // TODO(miu): See TODO at top of file.  Until that's resolved, assume all
   // platform audio input requires the |no_data_timer_| be used to auto-detect
@@ -181,7 +181,7 @@ void AudioInputController::DoCreate(AudioManager* audio_manager,
 
 void AudioInputController::DoCreateForStream(
     AudioInputStream* stream_to_control, bool enable_nodata_timer) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
 
   DCHECK(!stream_);
   stream_ = stream_to_control;
@@ -221,7 +221,7 @@ void AudioInputController::DoCreateForStream(
 }
 
 void AudioInputController::DoRecord() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.RecordTime");
 
   if (state_ != kCreated)
@@ -243,7 +243,7 @@ void AudioInputController::DoRecord() {
 }
 
 void AudioInputController::DoClose() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.CloseTime");
 
   // Delete the timer on the same thread that created it.
@@ -265,12 +265,12 @@ void AudioInputController::DoClose() {
 }
 
 void AudioInputController::DoReportError() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   handler_->OnError(this);
 }
 
 void AudioInputController::DoSetVolume(double volume) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_GE(volume, 0);
   DCHECK_LE(volume, 1.0);
 
@@ -293,7 +293,7 @@ void AudioInputController::DoSetVolume(double volume) {
 }
 
 void AudioInputController::DoSetAutomaticGainControl(bool enabled) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_NE(state_, kRecording);
 
   // Ensure that the AGC state only can be modified before streaming starts.
@@ -304,7 +304,7 @@ void AudioInputController::DoSetAutomaticGainControl(bool enabled) {
 }
 
 void AudioInputController::DoCheckForNoData() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!GetDataIsActive()) {
     // The data-is-active marker will be false only if it has been more than
@@ -369,13 +369,13 @@ void AudioInputController::OnClose(AudioInputStream* stream) {
 
 void AudioInputController::OnError(AudioInputStream* stream) {
   // Handle error on the audio-manager thread.
-  message_loop_->PostTask(FROM_HERE, base::Bind(
+  task_runner_->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoReportError, this));
 }
 
 void AudioInputController::DoStopCloseAndClearStream(
     base::WaitableEvent* done) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Allow calling unconditionally and bail if we don't have a stream to close.
   if (stream_ != NULL) {