Replace MessageLoopProxy with SingleThreadTaskRunner for media/filters/ + associated code.

media/filters/ffmpeg_audio_decoder.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/filters/ffmpeg_audio_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer.h"
 #include "media/base/limits.h"
 #include "media/base/pipeline.h"
 #include "media/base/sample_format.h"
@@ skipping 42 matching lines @@
 }
 
 // Called by FFmpeg's allocation routine to free a buffer. |opaque| is the
 // AudioBuffer allocated, so unref it.
 static void ReleaseAudioBufferImpl(void* opaque, uint8* data) {
   scoped_refptr<AudioBuffer> buffer;
   buffer.swap(reinterpret_cast<AudioBuffer**>(&opaque));
 }
 
 FFmpegAudioDecoder::FFmpegAudioDecoder(
-    const scoped_refptr<base::MessageLoopProxy>& message_loop)
-    : message_loop_(message_loop),
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
+    : task_runner_(task_runner),
       weak_factory_(this),
       demuxer_stream_(NULL),
       bytes_per_channel_(0),
       channel_layout_(CHANNEL_LAYOUT_NONE),
       channels_(0),
       samples_per_second_(0),
       av_sample_format_(0),
       last_input_timestamp_(kNoTimestamp()),
       output_frames_to_drop_(0) {
 }
 
 void FFmpegAudioDecoder::Initialize(
     DemuxerStream* stream,
     const PipelineStatusCB& status_cb,
     const StatisticsCB& statistics_cb) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   PipelineStatusCB initialize_cb = BindToCurrentLoop(status_cb);
 
   FFmpegGlue::InitializeFFmpeg();
 
   if (demuxer_stream_) {
     // TODO(scherkus): initialization currently happens more than once in
     // PipelineIntegrationTest.BasicPlayback.
     LOG(ERROR) << "Initialize has already been called.";
     CHECK(false);
   }
 
   weak_this_ = weak_factory_.GetWeakPtr();
   demuxer_stream_ = stream;
 
   if (!ConfigureDecoder()) {
     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   statistics_cb_ = statistics_cb;
   initialize_cb.Run(PIPELINE_OK);
 }
 
 void FFmpegAudioDecoder::Read(const ReadCB& read_cb) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!read_cb.is_null());
   CHECK(read_cb_.is_null()) << "Overlapping decodes are not supported.";
 
   read_cb_ = BindToCurrentLoop(read_cb);
 
   // If we don't have any queued audio from the last packet we decoded, ask for
   // more data from the demuxer to satisfy this read.
   if (queued_audio_.empty()) {
     ReadFromDemuxerStream();
     return;
   }
 
   base::ResetAndReturn(&read_cb_).Run(
       queued_audio_.front().status, queued_audio_.front().buffer);
   queued_audio_.pop_front();
 }
 
 int FFmpegAudioDecoder::bits_per_channel() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   return bytes_per_channel_ * 8;
 }
 
 ChannelLayout FFmpegAudioDecoder::channel_layout() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   return channel_layout_;
 }
 
 int FFmpegAudioDecoder::samples_per_second() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   return samples_per_second_;
 }
 
 void FFmpegAudioDecoder::Reset(const base::Closure& closure) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   base::Closure reset_cb = BindToCurrentLoop(closure);
 
   avcodec_flush_buffers(codec_context_.get());
   ResetTimestampState();
   queued_audio_.clear();
   reset_cb.Run();
 }
 
 FFmpegAudioDecoder::~FFmpegAudioDecoder() {
   // TODO(scherkus): should we require Stop() to be called? this might end up
@@ skipping 65 matching lines @@
 
 void FFmpegAudioDecoder::ReadFromDemuxerStream() {
   DCHECK(!read_cb_.is_null());
   demuxer_stream_->Read(base::Bind(
       &FFmpegAudioDecoder::BufferReady, weak_this_));
 }
 
 void FFmpegAudioDecoder::BufferReady(
     DemuxerStream::Status status,
     const scoped_refptr<DecoderBuffer>& input) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!read_cb_.is_null());
   DCHECK(queued_audio_.empty());
   DCHECK_EQ(status != DemuxerStream::kOk, !input.get()) << status;
 
   if (status == DemuxerStream::kAborted) {
     DCHECK(!input.get());
     base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
     return;
   }
 
@@ skipping 283 matching lines @@
     // Decoding finished successfully, update statistics.
     if (result > 0) {
       PipelineStatistics statistics;
       statistics.audio_bytes_decoded = result;
       statistics_cb_.Run(statistics);
     }
   } while (packet.size > 0);
 }
 
 }  // namespace media