Make RendererGpuVideoDecoderFactories live on arbitrary threads.

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 <algorithm>
 
 #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/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_.get());
-}
-
-VDAClientProxy::~VDAClientProxy() {}
-
-void VDAClientProxy::Detach() {
-  DCHECK(client_loop_->BelongsToCurrentThread());
-  DCHECK(weak_client_.get()) << "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 18 matching lines @@
 }
 
 GpuVideoDecoder::BufferData::~BufferData() {}
 
 GpuVideoDecoder::GpuVideoDecoder(
     const scoped_refptr<base::MessageLoopProxy>& message_loop,
     const scoped_refptr<Factories>& factories)
     : needs_bitstream_conversion_(false),
       gvd_loop_proxy_(message_loop),
       weak_factory_(this),
-      vda_loop_proxy_(factories->GetMessageLoop()),
       factories_(factories),
       state_(kNormal),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0),
       available_pictures_(0) {
   DCHECK(factories_.get());
+  DCHECK_EQ(message_loop.get(), factories->GetMessageLoop().get());
 }
 
 void GpuVideoDecoder::Reset(const base::Closure& closure)  {
   DVLOG(3) << "Reset()";
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   if (state_ == kDrainingDecoder && !factories_->IsAborted()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Reset, weak_this_, closure));
     // NOTE: if we're deferring Reset() until a Flush() completes, return
@@ skipping 10 matching lines @@
     gvd_loop_proxy_->PostTask(FROM_HERE, closure);
     return;
   }
 
   if (!pending_read_cb_.is_null())
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
 
   DCHECK(pending_reset_cb_.is_null());
   pending_reset_cb_ = BindToCurrentLoop(closure);
 
-  vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-      &VideoDecodeAccelerator::Reset, weak_vda_));
+  vda_->Reset();
 }
 
 void GpuVideoDecoder::Stop(const base::Closure& closure) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   if (vda_)
     DestroyVDA();
   if (!pending_read_cb_.is_null())
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
   if (!pending_reset_cb_.is_null())
     base::ResetAndReturn(&pending_reset_cb_).Run();
@@ skipping 35 matching lines @@
     DVLOG(1) << "GpuVideoDecoder reinitialization not supported.";
     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   if (!IsCodedSizeSupported(config.coded_size())) {
     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
-  client_proxy_ = new VDAClientProxy(this);
-  VideoDecodeAccelerator* vda = factories_->CreateVideoDecodeAccelerator(
-      config.profile(), client_proxy_.get());
+  VideoDecodeAccelerator* vda =
+      factories_->CreateVideoDecodeAccelerator(config.profile(), this);
   if (!vda) {
     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   config_ = config;
   needs_bitstream_conversion_ = (config.codec() == kCodecH264);
 
   DVLOG(3) << "GpuVideoDecoder::Initialize() succeeded.";
-  PostTaskAndReplyWithResult(
-      vda_loop_proxy_.get(),
-      FROM_HERE,
-      base::Bind(&VideoDecodeAccelerator::AsWeakPtr, base::Unretained(vda)),
-      base::Bind(&GpuVideoDecoder::SetVDA, weak_this_, status_cb, vda));
-}
-
-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_ = weak_vda;
   status_cb.Run(PIPELINE_OK);
 }
 
 void GpuVideoDecoder::DestroyTextures() {
   std::map<int32, PictureBuffer>::iterator it;
 
   for (it = assigned_picture_buffers_.begin();
        it != assigned_picture_buffers_.end(); ++it) {
     factories_->DeleteTexture(it->second.texture_id());
   }
   assigned_picture_buffers_.clear();
 
   for (it = dismissed_picture_buffers_.begin();
        it != dismissed_picture_buffers_.end(); ++it) {
     factories_->DeleteTexture(it->second.texture_id());
   }
   dismissed_picture_buffers_.clear();
 }
 
-static void DestroyVDAWithClientProxy(
-    const scoped_refptr<VDAClientProxy>& client_proxy,
-    base::WeakPtr<VideoDecodeAccelerator> weak_vda) {
-  if (weak_vda.get()) {
-    weak_vda->Destroy();
-    DCHECK(!weak_vda.get());  // 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();
-  client_proxy_->Detach();
-  client_proxy_ = NULL;
+  if (vda_)
+    vda_.release()->Destroy();
 
   DestroyTextures();
 }
 
 void GpuVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
                              const ReadCB& read_cb) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   DCHECK(pending_reset_cb_.is_null());
   DCHECK(pending_read_cb_.is_null());
 
@@ skipping 20 matching lines @@
       // NotifyFlushDone below.
       return;
     case kError:
       NOTREACHED();
       return;
   }
 
   if (buffer->IsEndOfStream()) {
     if (state_ == kNormal) {
       state_ = kDrainingDecoder;
-      vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-          &VideoDecodeAccelerator::Flush, weak_vda_));
+      vda_->Flush();
     }
     return;
   }
 
   size_t size = buffer->GetDataSize();
   SHMBuffer* shm_buffer = GetSHM(size);
   if (!shm_buffer) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 
   memcpy(shm_buffer->shm->memory(), buffer->GetData(), size);
   BitstreamBuffer bitstream_buffer(
       next_bitstream_buffer_id_, shm_buffer->shm->handle(), size);
   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
   next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x3FFFFFFF;
   bool inserted = bitstream_buffers_in_decoder_.insert(std::make_pair(
       bitstream_buffer.id(), BufferPair(shm_buffer, buffer))).second;
   DCHECK(inserted);
   RecordBufferData(bitstream_buffer, *buffer.get());
 
-  vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-      &VideoDecodeAccelerator::Decode, weak_vda_, bitstream_buffer));
+  vda_->Decode(bitstream_buffer);
 
   if (!ready_video_frames_.empty()) {
     EnqueueFrameAndTriggerFrameDelivery(NULL);
     return;
   }
 
   if (CanMoreDecodeWorkBeDone())
     base::ResetAndReturn(&pending_read_cb_).Run(kNotEnoughData, NULL);
 }
 
@@ skipping 82 matching lines @@
   for (size_t i = 0; i < texture_ids.size(); ++i) {
     picture_buffers.push_back(PictureBuffer(
         next_picture_buffer_id_++, size, texture_ids[i], texture_mailboxes[i]));
     bool inserted = assigned_picture_buffers_.insert(std::make_pair(
         picture_buffers.back().id(), picture_buffers.back())).second;
     DCHECK(inserted);
   }
 
   available_pictures_ += count;
 
-  vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-      &VideoDecodeAccelerator::AssignPictureBuffers, weak_vda_,
-      picture_buffers));
+  vda_->AssignPictureBuffers(picture_buffers);
 }
 
 void GpuVideoDecoder::DismissPictureBuffer(int32 id) {
   DVLOG(3) << "DismissPictureBuffer(" << id << ")";
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   std::map<int32, PictureBuffer>::iterator it =
       assigned_picture_buffers_.find(id);
   if (it == assigned_picture_buffers_.end()) {
     NOTREACHED() << "Missing picture buffer: " << id;
@@ skipping 106 matching lines @@
     it = dismissed_picture_buffers_.find(picture_buffer_id);
     DCHECK(it != dismissed_picture_buffers_.end());
     factories_->DeleteTexture(it->second.texture_id());
     dismissed_picture_buffers_.erase(it);
     return;
   }
 
   factories_->WaitSyncPoint(sync_point);
   ++available_pictures_;
 
-  vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-      &VideoDecodeAccelerator::ReusePictureBuffer, weak_vda_,
-      picture_buffer_id));
+  vda_->ReusePictureBuffer(picture_buffer_id);
 }
 
 GpuVideoDecoder::SHMBuffer* GpuVideoDecoder::GetSHM(size_t min_size) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   if (available_shm_segments_.empty() ||
       available_shm_segments_.back()->size < min_size) {
     size_t size_to_allocate = std::max(min_size, kSharedMemorySegmentBytes);
     base::SharedMemory* shm = factories_->CreateSharedMemory(size_to_allocate);
     // CreateSharedMemory() can return NULL during Shutdown.
     if (!shm)
@@ skipping 83 matching lines @@
 
   state_ = kError;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media