Remove reference counting from media::VideoDecoder and friends.

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 "base/task_runner_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 {
 
+// Proxies calls to a VideoDecodeAccelerator::Client from the calling thread to
+// a thread of the client's choice.

[Ami GONE FROM CHROMIUM, 2013/04/05 21:05:48]

Crazy Question Time(tm):
What would happen if you made GVD *not* be a VDA::Client, and instead implement
VDA::Client in a single class here (GpuVDAClient), made it refcounted, stored a
ref in GVD itself, and gave GpuVDAClient a Detach() method that would turn all
future calls on it into no-ops.  GpuVDAClient would live on the VDA (render)
thread.

When GVD::Stop() was called (on the media thread) it would post to the VDA
thread the tasks:
- GpuVDAClient::Detach()
- VDA::Destroy()
- GpuVDAClient::DoNothing() (just as a way of keeping the GVC alive)
and immediately clear its ref to the GVC.

I think the result would be easier to understand since:
1) only one class would be impl'ing VDA::Client; and 
2) each of the classes will live on a single thread.

It'll also allow us to get rid of some craxy, such as the current thread-hopping
when textures are requested:
render thread calls ProvidePictureBuffers
ProvidePictureBuffers posts itself to media thread
ProvidePictureBuffers calls factories_->CreateTextures
CreateTextures calls CreateTexturesAsync on the compositor thread and waits
ProvidePictureBuffers posts AssignPictureBuffers back to the render thread.
That's 2 unnecessary thread hops!  It's not really an efficiency concern (since
texture assignment is one-off) but it's a lot of needless complexity.

[scherkus (not reviewing), 2013/04/05 21:16:12]

I don't think it's too crazy but let's make sure I better understand what you're
proposing.

- GpuVDAClient holds onto factories_ and take care of some of the work that is
current done in GVD
- GpuVDAClient exposes a subset/simpler set of APIs for GVD (including Detach(),
etc...)
- GVD holds a ref to GpuVDAClient instead of a VDA

My one question/concern is whether GpuVDAClient will ever call out to GVD. If
so, then while the task to Detach() is queued, we can still race with the media
thread destroying GVD before Detach() is run. I guess one way to get around that
is to have GpuVDAClient accept base::Bind()s so GVD can use weak_this_

+class VDAClientProxy
+    : public base::RefCountedThreadSafe<VDAClientProxy>,
+      public VideoDecodeAccelerator::Client {
+ public:
+  VDAClientProxy(const scoped_refptr<base::MessageLoopProxy>& client_loop,

[Ami GONE FROM CHROMIUM, 2013/04/05 21:05:48]

This is always MessageLoopProxy::current() so I'd drop it.

[scherkus (not reviewing), 2013/04/17 16:54:54]

Done.

+                 VideoDecodeAccelerator::Client* client);
+
+  // Detaches the proxy. |client| will no longer be called and can be safely
+  // deleted. Any pending/future calls will be discarded.
+  //
+  // Must be called on |client_loop|.
+  void Detach();
+
+  // VideoDecodeAccelerator::Client implementation.
+  virtual void NotifyInitializeDone() OVERRIDE;
+  virtual void ProvidePictureBuffers(uint32 count,
+                                     const gfx::Size& size,
+                                     uint32 texture_target) OVERRIDE;
+  virtual void DismissPictureBuffer(int32 id) OVERRIDE;
+  virtual void PictureReady(const media::Picture& picture) OVERRIDE;
+  virtual void NotifyEndOfBitstreamBuffer(int32 id) OVERRIDE;
+  virtual void NotifyFlushDone() OVERRIDE;
+  virtual void NotifyResetDone() OVERRIDE;
+  virtual void NotifyError(media::VideoDecodeAccelerator::Error error) OVERRIDE;
+
+ private:
+  friend class base::RefCountedThreadSafe<VDAClientProxy>;
+  virtual ~VDAClientProxy();
+
+  scoped_refptr<base::MessageLoopProxy> client_loop_;
+
+  // Weak pointers are used to invalidate tasks posted to |client_loop_| that
+  // Detach() has been called.
+  base::WeakPtrFactory<VideoDecodeAccelerator::Client> weak_client_factory_;
+  base::WeakPtr<VideoDecodeAccelerator::Client> weak_client_;
+
+  DISALLOW_COPY_AND_ASSIGN(VDAClientProxy);
+};
+
+VDAClientProxy::VDAClientProxy(
+    const scoped_refptr<base::MessageLoopProxy>& client_loop,
+    VideoDecodeAccelerator::Client* client)
+    : client_loop_(client_loop),
+      weak_client_factory_(client),
+      weak_client_(weak_client_factory_.GetWeakPtr()) {
+}
+
+VDAClientProxy::~VDAClientProxy() {}

[Ami GONE FROM CHROMIUM, 2013/04/05 21:05:48]

DCHECK already Detach()d

[scherkus (not reviewing), 2013/04/17 16:54:54]

Done.

+
+void VDAClientProxy::Detach() {
+  DCHECK(client_loop_->BelongsToCurrentThread());

[Ami GONE FROM CHROMIUM, 2013/04/05 21:05:48]

DCHECK not already detached to catch programming errors?

[scherkus (not reviewing), 2013/04/17 16:54:54]

Done.

+  weak_client_factory_.InvalidateWeakPtrs();
+  DCHECK(!weak_client_);
+}
+
+void VDAClientProxy::NotifyInitializeDone() {
+  client_loop_->PostTask(FROM_HERE, base::Bind(
+      &VideoDecodeAccelerator::Client::NotifyInitializeDone, weak_client_));
+}
+
+void VDAClientProxy::ProvidePictureBuffers(uint32 count,
+                                           const gfx::Size& size,
+                                           uint32 texture_target) {
+  client_loop_->PostTask(FROM_HERE, base::Bind(
+      &VideoDecodeAccelerator::Client::ProvidePictureBuffers, weak_client_,
+      count, size, texture_target));
+}
+
+void VDAClientProxy::DismissPictureBuffer(int32 id) {
+  client_loop_->PostTask(FROM_HERE, base::Bind(
+      &VideoDecodeAccelerator::Client::DismissPictureBuffer, weak_client_, id));
+}
+
+void VDAClientProxy::PictureReady(const media::Picture& picture) {
+  client_loop_->PostTask(FROM_HERE, base::Bind(
+      &VideoDecodeAccelerator::Client::PictureReady, weak_client_, picture));
+}
+
+void VDAClientProxy::NotifyEndOfBitstreamBuffer(int32 id) {
+  client_loop_->PostTask(FROM_HERE, base::Bind(
+      &VideoDecodeAccelerator::Client::NotifyEndOfBitstreamBuffer, weak_client_,
+      id));
+}
+
+void VDAClientProxy::NotifyFlushDone() {
+  client_loop_->PostTask(FROM_HERE, base::Bind(
+      &VideoDecodeAccelerator::Client::NotifyFlushDone, weak_client_));
+}
+
+void VDAClientProxy::NotifyResetDone() {
+  client_loop_->PostTask(FROM_HERE, base::Bind(
+      &VideoDecodeAccelerator::Client::NotifyResetDone, weak_client_));
+}
+
+void VDAClientProxy::NotifyError(media::VideoDecodeAccelerator::Error error) {
+  client_loop_->PostTask(FROM_HERE, base::Bind(
+      &VideoDecodeAccelerator::Client::NotifyError, weak_client_, error));
+}
+
+
 // Maximum number of concurrent VDA::Decode() operations GVD will maintain.
 // Higher values allow better pipelining in the GPU, but also require more
 // resources.
 enum { kMaxInFlightDecodes = 4 };
 
 GpuVideoDecoder::Factories::~Factories() {}
 
 // Size of shared-memory segments we allocate.  Since we reuse them we let them
 // be on the beefy side.
 static const size_t kSharedMemorySegmentBytes = 100 << 10;
@@ skipping 16 matching lines @@
     : bitstream_buffer_id(bbid), timestamp(ts), visible_rect(vr),
       natural_size(ns) {
 }
 
 GpuVideoDecoder::BufferData::~BufferData() {}
 
 GpuVideoDecoder::GpuVideoDecoder(
     const scoped_refptr<base::MessageLoopProxy>& message_loop,
     const scoped_refptr<Factories>& factories)
     : gvd_loop_proxy_(message_loop),
+      weak_factory_(this),
       vda_loop_proxy_(factories->GetMessageLoop()),
       factories_(factories),
       state_(kNormal),
       demuxer_read_in_progress_(false),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0),
       error_occured_(false),
       available_pictures_(-1) {
   DCHECK(factories_);
 }
 
 void GpuVideoDecoder::Reset(const base::Closure& closure)  {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   if (state_ == kDrainingDecoder && !factories_->IsAborted()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::Reset, this, closure));
+        &GpuVideoDecoder::Reset, weak_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();
 
@@ skipping 22 matching lines @@
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
   if (!pending_reset_cb_.is_null())
     base::ResetAndReturn(&pending_reset_cb_).Run();
   BindToCurrentLoop(closure).Run();
 }
 
 void GpuVideoDecoder::Initialize(const scoped_refptr<DemuxerStream>& stream,
                                  const PipelineStatusCB& orig_status_cb,
                                  const StatisticsCB& statistics_cb) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
+  weak_this_ = weak_factory_.GetWeakPtr();
+
   PipelineStatusCB status_cb = CreateUMAReportingPipelineCB(
       "Media.GpuVideoDecoderInitializeStatus",
       BindToCurrentLoop(orig_status_cb));
   DCHECK(!demuxer_stream_);
 
   if (!stream) {
     status_cb.Run(PIPELINE_ERROR_DECODE);
     return;
   }
 
@@ skipping 17 matching lines @@
     bool os_large_video_support = true;
 #if defined(OS_WIN)
     os_large_video_support = false;
 #endif
     if (!(os_large_video_support && hw_large_video_support)) {
       status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
       return;
     }
   }
 
+  client_proxy_ = new VDAClientProxy(gvd_loop_proxy_, this);
   VideoDecodeAccelerator* vda =
-      factories_->CreateVideoDecodeAccelerator(config.profile(), this);
+      factories_->CreateVideoDecodeAccelerator(config.profile(), client_proxy_);
   if (!vda) {
     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   if (config.codec() == kCodecH264)
     stream->EnableBitstreamConverter();
 
   demuxer_stream_ = stream;
   statistics_cb_ = statistics_cb;
 
   DVLOG(1) << "GpuVideoDecoder::Initialize() succeeded.";
-  vda_loop_proxy_->PostTaskAndReply(
-      FROM_HERE,
-      base::Bind(&GpuVideoDecoder::SetVDA, this, vda),
-      base::Bind(status_cb, PIPELINE_OK));
+  PostTaskAndReplyWithResult(
+      vda_loop_proxy_, FROM_HERE,
+      base::Bind(&VideoDecodeAccelerator::AsWeakPtr, base::Unretained(vda)),
+      base::Bind(&GpuVideoDecoder::SetVDA, weak_this_, status_cb, vda));
 }
 
-void GpuVideoDecoder::SetVDA(VideoDecodeAccelerator* vda) {
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+void GpuVideoDecoder::SetVDA(
+    const PipelineStatusCB& status_cb,
+    VideoDecodeAccelerator* vda,
+    base::WeakPtr<VideoDecodeAccelerator> weak_vda) {
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!vda_.get());
   vda_.reset(vda);
-  weak_vda_ = vda->AsWeakPtr();
+  weak_vda_ = weak_vda;
+  status_cb.Run(PIPELINE_OK);
 }
 
 void GpuVideoDecoder::DestroyTextures() {
   for (std::map<int32, PictureBuffer>::iterator it =
           picture_buffers_in_decoder_.begin();
           it != picture_buffers_in_decoder_.end(); ++it) {
     factories_->DeleteTexture(it->second.texture_id());
   }
   picture_buffers_in_decoder_.clear();
 }
 
+static void DestroyVDAWithClientProxy(
+    const scoped_refptr<VDAClientProxy>& client_proxy,

[Ami GONE FROM CHROMIUM, 2013/04/05 21:05:48]

so this is only here to keep the proxy alive until this exits?
DCHECK(client_proxy->HasOneRef());
?

[scherkus (not reviewing), 2013/04/17 16:54:54]

Done.

+    base::WeakPtr<VideoDecodeAccelerator> weak_vda) {
+  if (weak_vda)
+    weak_vda->Destroy();
+}
+
 void GpuVideoDecoder::DestroyVDA() {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
+
+  // |client_proxy| must stay alive until |weak_vda_| has been destroyed.
+  vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+      &DestroyVDAWithClientProxy, client_proxy_, weak_vda_));
+
   VideoDecodeAccelerator* vda ALLOW_UNUSED = vda_.release();
-  // Tricky: |this| needs to stay alive until after VDA::Destroy is actually
-  // called, not just posted, so we take an artificial ref to |this| and release
-  // it as |reply| after VDA::Destroy() returns.
-  AddRef();
-  vda_loop_proxy_->PostTaskAndReply(
-      FROM_HERE,
-      base::Bind(&VideoDecodeAccelerator::Destroy, weak_vda_),
-      base::Bind(&GpuVideoDecoder::Release, this));
+  client_proxy_->Detach();
+  client_proxy_ = NULL;
 
   DestroyTextures();
 }
 
 void GpuVideoDecoder::Read(const ReadCB& read_cb) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   DCHECK(pending_reset_cb_.is_null());
   DCHECK(pending_read_cb_.is_null());
   pending_read_cb_ = BindToCurrentLoop(read_cb);
 
@@ skipping 27 matching lines @@
   }
 }
 
 bool GpuVideoDecoder::CanMoreDecodeWorkBeDone() {
   return bitstream_buffers_in_decoder_.size() < kMaxInFlightDecodes;
 }
 
 void GpuVideoDecoder::RequestBufferDecode(
     DemuxerStream::Status status,
     const scoped_refptr<DecoderBuffer>& buffer) {
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   DCHECK_EQ(status != DemuxerStream::kOk, !buffer) << status;
 
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
-    gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::RequestBufferDecode, this, status, buffer));
-    return;
-  }
   demuxer_read_in_progress_ = false;
 
   if (status != DemuxerStream::kOk) {
     if (pending_read_cb_.is_null())
       return;
 
     // TODO(acolwell): Add support for reinitializing the decoder when
     // |status| == kConfigChanged. For now we just trigger a decode error.
     Status decoder_status =
         (status == DemuxerStream::kAborted) ? kOk : kDecodeError;
@@ skipping 84 matching lines @@
   return available_pictures_ > 0;
 }
 
 void GpuVideoDecoder::NotifyInitializeDone() {
   NOTREACHED() << "GpuVideoDecodeAcceleratorHost::Initialize is synchronous!";
 }
 
 void GpuVideoDecoder::ProvidePictureBuffers(uint32 count,
                                             const gfx::Size& size,
                                             uint32 texture_target) {
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
-    gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::ProvidePictureBuffers, this, count, size,
-        texture_target));
-    return;
-  }
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   std::vector<uint32> texture_ids;
   decoder_texture_target_ = texture_target;
   if (!factories_->CreateTextures(
       count, size, &texture_ids, decoder_texture_target_)) {
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
 
   if (!vda_.get())
     return;
 
   CHECK_EQ(available_pictures_, -1);
   available_pictures_ = count;
 
   std::vector<PictureBuffer> picture_buffers;
   for (size_t i = 0; i < texture_ids.size(); ++i) {
     picture_buffers.push_back(PictureBuffer(
         next_picture_buffer_id_++, size, texture_ids[i]));
     bool inserted = picture_buffers_in_decoder_.insert(std::make_pair(
         picture_buffers.back().id(), picture_buffers.back())).second;
     DCHECK(inserted);
   }
   vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::AssignPictureBuffers, weak_vda_,
       picture_buffers));
 }
 
 void GpuVideoDecoder::DismissPictureBuffer(int32 id) {
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
-    gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::DismissPictureBuffer, this, id));
-    return;
-  }
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
+
   std::map<int32, PictureBuffer>::iterator it =
       picture_buffers_in_decoder_.find(id);
   if (it == picture_buffers_in_decoder_.end()) {
     NOTREACHED() << "Missing picture buffer: " << id;
     return;
   }
   factories_->DeleteTexture(it->second.texture_id());
   picture_buffers_in_decoder_.erase(it);
 }
 
 void GpuVideoDecoder::PictureReady(const media::Picture& picture) {
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
-    gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::PictureReady, this, picture));
-    return;
-  }
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
+
   std::map<int32, PictureBuffer>::iterator it =
       picture_buffers_in_decoder_.find(picture.picture_buffer_id());
   if (it == picture_buffers_in_decoder_.end()) {
     NOTREACHED() << "Missing picture buffer: " << picture.picture_buffer_id();
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   const PictureBuffer& pb = it->second;
 
   // Update frame's timestamp.
   base::TimeDelta timestamp;
   gfx::Rect visible_rect;
   gfx::Size natural_size;
   GetBufferData(picture.bitstream_buffer_id(), &timestamp, &visible_rect,
                 &natural_size);
   DCHECK(decoder_texture_target_);
   scoped_refptr<VideoFrame> frame(
       VideoFrame::WrapNativeTexture(
           pb.texture_id(), decoder_texture_target_, pb.size(), visible_rect,
           natural_size, timestamp,
           base::Bind(&Factories::ReadPixels, factories_, pb.texture_id(),
                      decoder_texture_target_,
                      gfx::Size(visible_rect.width(), visible_rect.height())),
-          base::Bind(&GpuVideoDecoder::ReusePictureBuffer, this,
-                     picture.picture_buffer_id())));
+          BindToCurrentLoop(base::Bind(
+              &GpuVideoDecoder::ReusePictureBuffer, weak_this_,
+              picture.picture_buffer_id()))));
   CHECK_GT(available_pictures_, 0);
   available_pictures_--;
 
   EnqueueFrameAndTriggerFrameDelivery(frame);
 }
 
 void GpuVideoDecoder::EnqueueFrameAndTriggerFrameDelivery(
     const scoped_refptr<VideoFrame>& frame) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   // During a pending vda->Reset(), we don't accumulate frames.  Drop it on the
   // floor and return.
   if (!pending_reset_cb_.is_null())
     return;
 
   if (frame)
     ready_video_frames_.push_back(frame);
   else
     DCHECK(!ready_video_frames_.empty());
 
   if (pending_read_cb_.is_null())
     return;
 
   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;
-  }
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   CHECK_GE(available_pictures_, 0);
   available_pictures_++;
 
   if (!vda_.get())
     return;
   vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::ReusePictureBuffer, weak_vda_,
       picture_buffer_id));
 }
 
@@ skipping 12 matching lines @@
   available_shm_segments_.pop_back();
   return ret;
 }
 
 void GpuVideoDecoder::PutSHM(SHMBuffer* shm_buffer) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   available_shm_segments_.push_back(shm_buffer);
 }
 
 void GpuVideoDecoder::NotifyEndOfBitstreamBuffer(int32 id) {
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
-    gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::NotifyEndOfBitstreamBuffer, this, id));
-    return;
-  }
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   std::map<int32, BufferPair>::iterator it =
       bitstream_buffers_in_decoder_.find(id);
   if (it == bitstream_buffers_in_decoder_.end()) {
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     NOTREACHED() << "Missing bitstream buffer: " << id;
     return;
   }
 
   PutSHM(it->second.shm_buffer);
@@ skipping 29 matching lines @@
   DestroyTextures();
 }
 
 void GpuVideoDecoder::EnsureDemuxOrDecode() {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   if (demuxer_read_in_progress_)
     return;
   demuxer_read_in_progress_ = true;
   gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &DemuxerStream::Read, demuxer_stream_.get(),
-      base::Bind(&GpuVideoDecoder::RequestBufferDecode, this)));
+      base::Bind(&GpuVideoDecoder::RequestBufferDecode, weak_this_)));
 }
 
 void GpuVideoDecoder::NotifyFlushDone() {
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
-    gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::NotifyFlushDone, this));
-    return;
-  }
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kDrainingDecoder);
   state_ = kDecoderDrained;
   EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
 }
 
 void GpuVideoDecoder::NotifyResetDone() {
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
-    gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::NotifyResetDone, this));
-    return;
-  }
-
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   DCHECK(ready_video_frames_.empty());
 
   // This needs to happen after the Reset() on vda_ is done to ensure pictures
   // delivered during the reset can find their time data.
   input_buffer_data_.clear();
 
   if (!pending_reset_cb_.is_null())
     base::ResetAndReturn(&pending_reset_cb_).Run();
 
   if (!pending_read_cb_.is_null())
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
 }
 
 void GpuVideoDecoder::NotifyError(media::VideoDecodeAccelerator::Error error) {
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
-    gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::NotifyError, this, error));
-    return;
-  }
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   if (!vda_.get())
     return;
 
   DLOG(ERROR) << "VDA Error: " << error;
   DestroyVDA();
 
   error_occured_ = true;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media