Replace MessageLoopProxy with SingleThreadTaskRunner for the rest of media/.

media/audio/pulse/pulse_unified.cc

 // Copyright 2013 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/pulse/pulse_unified.h"
 
-#include "base/message_loop/message_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_parameters.h"
 #include "media/audio/pulse/pulse_util.h"
 #include "media/base/seekable_buffer.h"
 
 namespace media {
 
 using pulse::AutoPulseLock;
 using pulse::WaitForOperationCompletion;
@@ skipping 29 matching lines @@
     AudioManagerBase* manager)
     : params_(params),
       input_device_id_(input_device_id),
       manager_(manager),
       pa_context_(NULL),
       pa_mainloop_(NULL),
       input_stream_(NULL),
       output_stream_(NULL),
       volume_(1.0f),
       source_callback_(NULL) {
-  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
+  DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
   CHECK(params_.IsValid());
   input_bus_ = AudioBus::Create(params_);
   output_bus_ = AudioBus::Create(params_);
 }
 
 PulseAudioUnifiedStream::~PulseAudioUnifiedStream() {
   // All internal structures should already have been freed in Close(), which
   // calls AudioManagerBase::ReleaseOutputStream() which deletes this object.
   DCHECK(!input_stream_);
   DCHECK(!output_stream_);
   DCHECK(!pa_context_);
   DCHECK(!pa_mainloop_);
 }
 
 bool PulseAudioUnifiedStream::Open() {
-  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
+  DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
   // Prepare the recording buffers for the callbacks.
   fifo_.reset(new media::SeekableBuffer(
       0, kFifoSizeInPackets * params_.GetBytesPerBuffer()));
   input_data_buffer_.reset(new uint8[params_.GetBytesPerBuffer()]);
 
   if (!pulse::CreateOutputStream(&pa_mainloop_, &pa_context_, &output_stream_,
                                  params_, &StreamNotifyCallback, NULL, this))
     return false;
 
   if (!pulse::CreateInputStream(pa_mainloop_, pa_context_, &input_stream_,
@@ skipping 47 matching lines @@
       pa_context_ = NULL;
     }
   }
 
   pa_threaded_mainloop_stop(pa_mainloop_);
   pa_threaded_mainloop_free(pa_mainloop_);
   pa_mainloop_ = NULL;
 }
 
 void PulseAudioUnifiedStream::Close() {
-  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
+  DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
   Reset();
 
   // Signal to the manager that we're closed and can be removed.
   // This should be the last call in the function as it deletes "this".
   manager_->ReleaseOutputStream(this);
 }
 
 void PulseAudioUnifiedStream::WriteData(size_t requested_bytes) {
   CHECK_EQ(requested_bytes, static_cast<size_t>(params_.GetBytesPerBuffer()));
 
@@ skipping 52 matching lines @@
     }
 
     // Checks if we still have data.
     pa_stream_drop(input_stream_);
   } while (pa_stream_readable_size(input_stream_) > 0);
 
   pa_threaded_mainloop_signal(pa_mainloop_, 0);
 }
 
 void PulseAudioUnifiedStream::Start(AudioSourceCallback* callback) {
-  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
+  DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
   CHECK(callback);
   CHECK(input_stream_);
   CHECK(output_stream_);
   AutoPulseLock auto_lock(pa_mainloop_);
 
   // Ensure the context and stream are ready.
   if (pa_context_get_state(pa_context_) != PA_CONTEXT_READY &&
       pa_stream_get_state(output_stream_) != PA_STREAM_READY &&
       pa_stream_get_state(input_stream_) != PA_STREAM_READY) {
     callback->OnError(this);
@@ skipping 12 matching lines @@
 
   // Uncork (resume) the output stream.
   // We use the recording stream to drive the playback, so we do not need to
   // register the write callback using pa_stream_set_write_callback().
   operation = pa_stream_cork(output_stream_, 0,
                              &pulse::StreamSuccessCallback, pa_mainloop_);
   WaitForOperationCompletion(pa_mainloop_, operation);
 }
 
 void PulseAudioUnifiedStream::Stop() {
-  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
+  DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
 
   // Cork (pause) the stream.  Waiting for the main loop lock will ensure
   // outstanding callbacks have completed.
   AutoPulseLock auto_lock(pa_mainloop_);
 
   // Set |source_callback_| to NULL so all FulfillWriteRequest() calls which may
   // occur while waiting on the flush and cork exit immediately.
   source_callback_ = NULL;
 
   // Set the read callback to NULL before flushing the stream, otherwise it
@@ skipping 13 matching lines @@
   operation = pa_stream_flush(
       output_stream_, &pulse::StreamSuccessCallback, pa_mainloop_);
   WaitForOperationCompletion(pa_mainloop_, operation);
 
   operation = pa_stream_cork(output_stream_, 1, &pulse::StreamSuccessCallback,
                              pa_mainloop_);
   WaitForOperationCompletion(pa_mainloop_, operation);
 }
 
 void PulseAudioUnifiedStream::SetVolume(double volume) {
-  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
+  DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
 
   volume_ = static_cast<float>(volume);
 }
 
 void PulseAudioUnifiedStream::GetVolume(double* volume) {
-  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
+  DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
 
   *volume = volume_;
 }
 
 }  // namespace media