Pass in media message loop to VideoRendererBase and enforce calling on the right thread.

media/filters/video_renderer_base.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/video_renderer_base.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
+#include "base/message_loop.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 VideoRendererBase::kMaxLastFrameDuration() {
   return base::TimeDelta::FromMilliseconds(250);
 }
 
-VideoRendererBase::VideoRendererBase(const base::Closure& paint_cb,
-                                     const SetOpaqueCB& set_opaque_cb,
-                                     bool drop_frames)
+VideoRendererBase::VideoRendererBase(
+    const base::Closure& paint_cb,
+    const SetOpaqueCB& set_opaque_cb,
+    bool drop_frames,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop)
     : frame_available_(&lock_),
       state_(kUninitialized),
       thread_(base::kNullThreadHandle),
       pending_read_(false),
       pending_paint_(false),
       pending_paint_with_last_available_(false),
       drop_frames_(drop_frames),
       playback_rate_(0),
       paint_cb_(paint_cb),
-      set_opaque_cb_(set_opaque_cb) {
+      set_opaque_cb_(set_opaque_cb),
+      decoder_message_loop_(message_loop) {

[Ami GONE FROM CHROMIUM, 2012/11/29 23:34:23]

Could DCHECK that this is *not* the current loop, for sanity.

   DCHECK(!paint_cb_.is_null());
 }
 
 void VideoRendererBase::Play(const base::Closure& callback) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kPrerolled, state_);
   state_ = kPlaying;
   callback.Run();
 }
 
 void VideoRendererBase::Pause(const base::Closure& callback) {
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ != kUninitialized || state_ == kError);
   state_ = kPaused;
   callback.Run();
 }
 
 void VideoRendererBase::Flush(const base::Closure& callback) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPaused);
   flush_cb_ = callback;
   state_ = kFlushingDecoder;
 
-  // We must unlock here because the callback might run within the Flush()
-  // call.
-  // TODO: Remove this line when fixing http://crbug.com/125020
-  base::AutoUnlock auto_unlock(lock_);
-  decoder_->Reset(base::Bind(&VideoRendererBase::OnDecoderFlushDone, this));
+  decoder_message_loop_->PostTask(FROM_HERE, base::Bind(
+      &VideoDecoder::Reset, decoder_, base::Bind(
+      &VideoRendererBase::OnDecoderFlushDone, this)));
 }
 
 void VideoRendererBase::Stop(const base::Closure& callback) {
   if (state_ == kStopped) {
     callback.Run();
     return;
   }
 
   base::PlatformThreadHandle thread_to_join = base::kNullThreadHandle;
   {
@@ skipping 10 matching lines @@
       // Signal the thread since it's possible to get stopped with the video
       // thread waiting for a read to complete.
       frame_available_.Signal();
       thread_to_join = thread_;
       thread_ = base::kNullThreadHandle;
     }
   }
   if (thread_to_join != base::kNullThreadHandle)
     base::PlatformThread::Join(thread_to_join);
 
-  decoder_->Stop(callback);
+  decoder_message_loop_->PostTask(FROM_HERE, base::Bind(
+      &VideoDecoder::Stop, decoder_, callback));
 }
 
 void VideoRendererBase::SetPlaybackRate(float playback_rate) {
   base::AutoLock auto_lock(lock_);
   playback_rate_ = playback_rate;
 }
 
 void VideoRendererBase::Preroll(base::TimeDelta time,
                                 const PipelineStatusCB& cb) {
   base::AutoLock auto_lock(lock_);
@@ skipping 84 matching lines @@
     base::ResetAndReturn(&init_cb_).Run(status);
     return;
   }
 
   // We're all good!  Consider ourselves flushed. (ThreadMain() should never
   // see us in the kUninitialized state).
   // Since we had an initial Preroll(), we consider ourself flushed, because we
   // have not populated any buffers yet.
   state_ = kFlushed;
 
+  // XXX we're taking advantage of the fact this is already on the right thread
   set_opaque_cb_.Run(!decoder_->HasAlpha());
   set_opaque_cb_.Reset();
 
   // Create our video thread.
   if (!base::PlatformThread::Create(0, this, &thread_)) {
     NOTREACHED() << "Video thread creation failed";
     state_ = kError;
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
   }
@@ skipping 356 matching lines @@
 
   if (pending_read_ ||
       NumFrames_Locked() == limits::kMaxVideoFrames ||
       (!ready_frames_.empty() && ready_frames_.back()->IsEndOfStream()) ||
       state_ == kFlushingDecoder ||
       state_ == kFlushing) {
     return;
   }
 
   pending_read_ = true;
-  decoder_->Read(base::Bind(&VideoRendererBase::FrameReady, this));
+  decoder_message_loop_->PostTask(FROM_HERE, base::Bind(
+      &VideoDecoder::Read, decoder_, base::Bind(
+      &VideoRendererBase::FrameReady, this)));
 }
 
 void VideoRendererBase::OnDecoderFlushDone() {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kFlushingDecoder, state_);
   DCHECK(!pending_read_);
 
   state_ = kFlushing;
   AttemptFlush_Locked();
 }
@@ skipping 36 matching lines @@
 
 int VideoRendererBase::NumFrames_Locked() const {
   lock_.AssertAcquired();
   int outstanding_frames =
       (current_frame_ ? 1 : 0) + (last_available_frame_ ? 1 : 0) +
       (current_frame_ && (current_frame_ == last_available_frame_) ? -1 : 0);
   return ready_frames_.size() + outstanding_frames;
 }
 
 }  // namespace media