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

media/filters/video_renderer_impl.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/filters/video_renderer_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
-#include "base/message_loop/message_loop.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "media/base/buffers.h"
 #include "media/base/limits.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_frame.h"
 
 namespace media {
 
 base::TimeDelta VideoRendererImpl::kMaxLastFrameDuration() {
   return base::TimeDelta::FromMilliseconds(250);
 }
 
 VideoRendererImpl::VideoRendererImpl(
-    const scoped_refptr<base::MessageLoopProxy>& message_loop,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     ScopedVector<VideoDecoder> decoders,
     const SetDecryptorReadyCB& set_decryptor_ready_cb,
     const PaintCB& paint_cb,
     const SetOpaqueCB& set_opaque_cb,
     bool drop_frames)
-    : message_loop_(message_loop),
+    : task_runner_(task_runner),
       weak_factory_(this),
       video_frame_stream_(
-          message_loop, decoders.Pass(), set_decryptor_ready_cb),
+          task_runner, decoders.Pass(), set_decryptor_ready_cb),
       received_end_of_stream_(false),
       frame_available_(&lock_),
       state_(kUninitialized),
       thread_(),
       pending_read_(false),
       drop_frames_(drop_frames),
       playback_rate_(0),
       paint_cb_(paint_cb),
       set_opaque_cb_(set_opaque_cb),
       last_timestamp_(kNoTimestamp()),
       frames_decoded_(0),
       frames_dropped_(0) {
   DCHECK(!paint_cb_.is_null());
 }
 
 VideoRendererImpl::~VideoRendererImpl() {
   base::AutoLock auto_lock(lock_);
   CHECK(state_ == kStopped || state_ == kUninitialized) << state_;
   CHECK(thread_.is_null());
 }
 
 void VideoRendererImpl::Play(const base::Closure& callback) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kPrerolled, state_);
   state_ = kPlaying;
   callback.Run();
 }
 
 void VideoRendererImpl::Pause(const base::Closure& callback) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ != kUninitialized || state_ == kError);
   state_ = kPaused;
   callback.Run();
 }
 
 void VideoRendererImpl::Flush(const base::Closure& callback) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPaused);
   flush_cb_ = callback;
   state_ = kFlushing;
 
   // This is necessary if the |video_frame_stream_| has already seen an end of
   // stream and needs to drain it before flushing it.
   ready_frames_.clear();
   received_end_of_stream_ = false;
   video_frame_stream_.Reset(base::Bind(
       &VideoRendererImpl::OnVideoFrameStreamResetDone, weak_this_));
 }
 
 void VideoRendererImpl::Stop(const base::Closure& callback) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   if (state_ == kUninitialized || state_ == kStopped) {
     callback.Run();
     return;
   }
 
   // TODO(scherkus): Consider invalidating |weak_factory_| and replacing
   // task-running guards that check |state_| with DCHECK().
 
   state_ = kStopped;
@@ skipping 13 matching lines @@
 
   if (!thread_to_join.is_null()) {
     base::AutoUnlock auto_unlock(lock_);
     base::PlatformThread::Join(thread_to_join);
   }
 
   video_frame_stream_.Stop(callback);
 }
 
 void VideoRendererImpl::SetPlaybackRate(float playback_rate) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   playback_rate_ = playback_rate;
 }
 
 void VideoRendererImpl::Preroll(base::TimeDelta time,
                                 const PipelineStatusCB& cb) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK(!cb.is_null());
   DCHECK(preroll_cb_.is_null());
   DCHECK(state_ == kFlushed || state_== kPaused) << "state_ " << state_;
 
   if (state_ == kFlushed) {
     DCHECK(time != kNoTimestamp());
     DCHECK(!pending_read_);
     DCHECK(ready_frames_.empty());
   } else {
@@ skipping 14 matching lines @@
 
 void VideoRendererImpl::Initialize(DemuxerStream* stream,
                                    const PipelineStatusCB& init_cb,
                                    const StatisticsCB& statistics_cb,
                                    const TimeCB& max_time_cb,
                                    const NaturalSizeChangedCB& size_changed_cb,
                                    const base::Closure& ended_cb,
                                    const PipelineStatusCB& error_cb,
                                    const TimeDeltaCB& get_time_cb,
                                    const TimeDeltaCB& get_duration_cb) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK(stream);
   DCHECK_EQ(stream->type(), DemuxerStream::VIDEO);
   DCHECK(!init_cb.is_null());
   DCHECK(!statistics_cb.is_null());
   DCHECK(!max_time_cb.is_null());
   DCHECK(!size_changed_cb.is_null());
   DCHECK(!ended_cb.is_null());
   DCHECK(!get_time_cb.is_null());
   DCHECK(!get_duration_cb.is_null());
@@ skipping 12 matching lines @@
 
   video_frame_stream_.Initialize(
       stream,
       statistics_cb,
       base::Bind(&VideoRendererImpl::OnVideoFrameStreamInitialized,
                  weak_this_));
 }
 
 void VideoRendererImpl::OnVideoFrameStreamInitialized(bool success,
                                                       bool has_alpha) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
 
   if (state_ == kStopped)
     return;
 
   DCHECK_EQ(state_, kInitializing);
 
   if (!success) {
     state_ = kUninitialized;
     base::ResetAndReturn(&init_cb_).Run(DECODER_ERROR_NOT_SUPPORTED);
@@ skipping 116 matching lines @@
   last_timestamp_ = next_frame->GetTimestamp();
 
   const gfx::Size& natural_size = next_frame->natural_size();
   if (natural_size != last_natural_size_) {
     last_natural_size_ = natural_size;
     size_changed_cb_.Run(natural_size);
   }
 
   paint_cb_.Run(next_frame);
 
-  message_loop_->PostTask(FROM_HERE, base::Bind(
+  task_runner_->PostTask(FROM_HERE, base::Bind(
       &VideoRendererImpl::AttemptRead, weak_this_));
 }
 
 void VideoRendererImpl::DropNextReadyFrame_Locked() {
   TRACE_EVENT0("media", "VideoRendererImpl:frameDropped");
 
   lock_.AssertAcquired();
 
   last_timestamp_ = ready_frames_.front()->GetTimestamp();
   ready_frames_.pop_front();
   frames_decoded_++;
   frames_dropped_++;
 
-  message_loop_->PostTask(FROM_HERE, base::Bind(
+  task_runner_->PostTask(FROM_HERE, base::Bind(
       &VideoRendererImpl::AttemptRead, weak_this_));
 }
 
 void VideoRendererImpl::FrameReady(VideoFrameStream::Status status,
                                    const scoped_refptr<VideoFrame>& frame) {
   base::AutoLock auto_lock(lock_);
   DCHECK_NE(state_, kUninitialized);
   DCHECK_NE(state_, kFlushed);
 
   CHECK(pending_read_);
@@ skipping 91 matching lines @@
   if (state_ == kPlaying)
     frame_available_.Signal();
 }
 
 void VideoRendererImpl::AttemptRead() {
   base::AutoLock auto_lock(lock_);
   AttemptRead_Locked();
 }
 
 void VideoRendererImpl::AttemptRead_Locked() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
 
   if (pending_read_ || received_end_of_stream_ ||
       ready_frames_.size() == static_cast<size_t>(limits::kMaxVideoFrames)) {
     return;
   }
 
   switch (state_) {
     case kPaused:
     case kPrerolling:
@@ skipping 77 matching lines @@
     statistics_cb_.Run(statistics);
 
     frames_decoded_ = 0;
     frames_dropped_ = 0;
   }
 
   frame_available_.TimedWait(wait_duration);
 }
 
 }  // namespace media