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

media/filters/gpu_video_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/gpu_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/cpu.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
+#include "media/base/bind_to_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/pipeline.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/video_decoder_config.h"
 
 namespace media {
 
 // Maximum number of concurrent VDA::Decode() operations GVD will maintain.
 // Higher values allow better pipelining in the GPU, but also require more
@@ skipping 37 matching lines @@
       state_(kNormal),
       demuxer_read_in_progress_(false),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0),
       error_occured_(false) {
   DCHECK(factories_);
 }
 
 void GpuVideoDecoder::Reset(const base::Closure& closure)  {
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
-    gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::Reset, this, closure));
-    return;
-  }
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   if (state_ == kDrainingDecoder) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Reset, this, closure));
     // NOTE: if we're deferring Reset() until a Flush() completes, return
     // queued pictures to the VDA so they can be used to finish that Flush().
     if (pending_read_cb_.is_null())
       ready_video_frames_.clear();
     return;
   }
 
   // Throw away any already-decoded, not-yet-delivered frames.
   ready_video_frames_.clear();
 
+  DCHECK(pending_reset_cb_.is_null());
+  pending_reset_cb_ = BindToCurrentLoop(closure);
+
   if (!vda_.get()) {
-    closure.Run();
+    base::ResetAndReturn(&pending_reset_cb_).Run();
     return;
   }
 
-  DCHECK(pending_reset_cb_.is_null());
-  DCHECK(!closure.is_null());
-
   // VideoRendererBase::Flush() can't complete while it has a pending read to
   // us, so we fulfill such a read here.
   if (!pending_read_cb_.is_null())
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
 
-  pending_reset_cb_ = closure;
   vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::Reset, weak_vda_));
 }
 
 void GpuVideoDecoder::Stop(const base::Closure& closure) {
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
-    gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::Stop, this, closure));
-    return;
-  }
-  if (!vda_.get()) {
-    closure.Run();
-    return;
-  }
-  DestroyVDA();
-  closure.Run();
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
+  if (vda_.get())
+    DestroyVDA();
+  BindToCurrentLoop(closure).Run();
 }
 
 void GpuVideoDecoder::Initialize(const scoped_refptr<DemuxerStream>& stream,
                                  const PipelineStatusCB& orig_status_cb,
                                  const StatisticsCB& statistics_cb) {
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
-    gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::Initialize,
-        this, stream, orig_status_cb, statistics_cb));
-    return;
-  }
-
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   PipelineStatusCB status_cb = CreateUMAReportingPipelineCB(
-      "Media.GpuVideoDecoderInitializeStatus", orig_status_cb);
+      "Media.GpuVideoDecoderInitializeStatus",
+      BindToCurrentLoop(orig_status_cb));
+  DCHECK(!demuxer_stream_);
 
-  DCHECK(!demuxer_stream_);
   if (!stream) {
     status_cb.Run(PIPELINE_ERROR_DECODE);
     return;
   }
 
   // TODO(scherkus): this check should go in Pipeline prior to creating
   // decoder objects.
   const VideoDecoderConfig& config = stream->video_decoder_config();
   if (!config.IsValidConfig() || config.is_encrypted()) {
     DLOG(ERROR) << "Unsupported video stream - "
@@ skipping 64 matching lines @@
   AddRef();
   vda_loop_proxy_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&VideoDecodeAccelerator::Destroy, weak_vda_),
       base::Bind(&GpuVideoDecoder::Release, this));
 
   DestroyTextures();
 }
 
 void GpuVideoDecoder::Read(const ReadCB& read_cb) {
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
-    gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::Read, this, read_cb));
-    return;
-  }
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(pending_reset_cb_.is_null());
+  DCHECK(pending_read_cb_.is_null());
+  pending_read_cb_ = BindToCurrentLoop(read_cb);
 
   if (error_occured_) {
-    read_cb.Run(kDecodeError, NULL);
+    base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 
   if (!vda_.get()) {
-    read_cb.Run(kOk, VideoFrame::CreateEmptyFrame());
+    base::ResetAndReturn(&pending_read_cb_).Run(
+        kOk, VideoFrame::CreateEmptyFrame());
     return;
   }
 
-  DCHECK(pending_reset_cb_.is_null());
-  DCHECK(pending_read_cb_.is_null());
-  pending_read_cb_ = read_cb;
-
   if (!ready_video_frames_.empty()) {
     EnqueueFrameAndTriggerFrameDelivery(NULL);
     return;
   }
 
   switch (state_) {
     case kDecoderDrained:
       state_ = kNormal;
       // Fall-through.
     case kNormal:
@@ skipping 96 matching lines @@
       continue;
     *timestamp = it->timestamp;
     *visible_rect = it->visible_rect;
     *natural_size = it->natural_size;
     return;
   }
   NOTREACHED() << "Missing bitstreambuffer id: " << id;
 }
 
 bool GpuVideoDecoder::HasAlpha() const {
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   return true;
 }
 
 void GpuVideoDecoder::NotifyInitializeDone() {
   NOTREACHED() << "GpuVideoDecodeAcceleratorHost::Initialize is synchronous!";
 }
 
 void GpuVideoDecoder::ProvidePictureBuffers(uint32 count,
                                             const gfx::Size& size,
                                             uint32 texture_target) {
@@ skipping 88 matching lines @@
     return;
 
   if (frame)
     ready_video_frames_.push_back(frame);
   else
     DCHECK(!ready_video_frames_.empty());
 
   if (pending_read_cb_.is_null())
     return;
 
-  gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-      pending_read_cb_, kOk, ready_video_frames_.front()));
-  pending_read_cb_.Reset();
+  base::ResetAndReturn(&pending_read_cb_).Run(kOk, ready_video_frames_.front());
   ready_video_frames_.pop_front();
 }
 
 void GpuVideoDecoder::ReusePictureBuffer(int64 picture_buffer_id) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::ReusePictureBuffer, this, picture_buffer_id));
     return;
   }
   if (!vda_.get())
@@ skipping 128 matching lines @@
 
   error_occured_ = true;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media