Reland: 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
+// the client's thread.
+//
+// TODO(scherkus): VDAClientProxy should hold onto GpuVideoDecoder::Factories
+// and take care of some of the work that GpuVideoDecoder does to minimize
+// thread hopping. See following for discussion:
+//
+// https://codereview.chromium.org/12989009/diff/27035/media/filters/gpu_video_decoder.cc#newcode23
+class VDAClientProxy
+    : public base::RefCountedThreadSafe<VDAClientProxy>,
+      public VideoDecodeAccelerator::Client {
+ public:
+  explicit VDAClientProxy(VideoDecodeAccelerator::Client* client);
+
+  // Detaches the proxy. |weak_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_| after
+  // Detach() has been called.
+  base::WeakPtrFactory<VideoDecodeAccelerator::Client> weak_client_factory_;
+  base::WeakPtr<VideoDecodeAccelerator::Client> weak_client_;
+
+  DISALLOW_COPY_AND_ASSIGN(VDAClientProxy);
+};
+
+VDAClientProxy::VDAClientProxy(VideoDecodeAccelerator::Client* client)
+    : client_loop_(base::MessageLoopProxy::current()),
+      weak_client_factory_(client),
+      weak_client_(weak_client_factory_.GetWeakPtr()) {
+  DCHECK(weak_client_);
+}
+
+VDAClientProxy::~VDAClientProxy() {}
+
+void VDAClientProxy::Detach() {
+  DCHECK(client_loop_->BelongsToCurrentThread());
+  DCHECK(weak_client_) << "Detach() already called";
+  weak_client_factory_.InvalidateWeakPtrs();
+}
+
+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 21 matching lines @@
   if (!pending_reset_cb_.is_null())
     base::ResetAndReturn(&pending_reset_cb_).Run();
   demuxer_stream_ = NULL;
   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(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,
+    base::WeakPtr<VideoDecodeAccelerator> weak_vda) {
+  if (weak_vda) {
+    weak_vda->Destroy();
+    DCHECK(!weak_vda);  // Check VDA::Destroy() contract.
+  }
+}
+
 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 34 matching lines @@
       bitstream_buffer.id(), BufferPair(shm_buffer, buffer))).second;
   DCHECK(inserted);
   RecordBufferData(bitstream_buffer, *buffer);
 
   vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::Decode, weak_vda_, bitstream_buffer));
 
   if (CanMoreDecodeWorkBeDone()) {
     // Force post here to prevent reentrancy into DemuxerStream.
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::EnsureDemuxOrDecode, this));
+        &GpuVideoDecoder::EnsureDemuxOrDecode, weak_this_));
   }
 }
 
 void GpuVideoDecoder::RecordBufferData(
     const BitstreamBuffer& bitstream_buffer, const DecoderBuffer& buffer) {
   input_buffer_data_.push_front(BufferData(
       bitstream_buffer.id(), buffer.GetTimestamp(),
       demuxer_stream_->video_decoder_config().visible_rect(),
       demuxer_stream_->video_decoder_config().natural_size()));
   // Why this value?  Because why not.  avformat.h:MAX_REORDER_DELAY is 16, but
@@ skipping 32 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 34 matching lines @@
 
   // The second condition can happen during the tear-down process.
   // GpuVideoDecoder::Stop() returns the |pending_read_cb_| immediately without
   // waiting for the demuxer read to be returned. Therefore, this function could
   // be called even after the decoder has been stopped.
   if (demuxer_read_in_progress_ || !demuxer_stream_)
     return;
 
   demuxer_read_in_progress_ = true;
   demuxer_stream_->Read(base::Bind(
-      &GpuVideoDecoder::RequestBufferDecode, this));
+      &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