Remove threading from RendererGpuVideoAcceleratorFactories

content/renderer/media/rtc_video_decoder.cc

 // Copyright 2013 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 "content/renderer/media/rtc_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/safe_numerics.h"
 #include "base/stl_util.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/task_runner_util.h"
 #include "content/child/child_thread.h"
 #include "content/renderer/media/native_handle_impl.h"
 #include "media/base/bind_to_loop.h"
 #include "media/filters/gpu_video_accelerator_factories.h"
+#include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/webrtc/common_video/interface/texture_video_frame.h"
 #include "third_party/webrtc/system_wrappers/interface/ref_count.h"
 
 namespace content {
 
 const int32 RTCVideoDecoder::ID_LAST = 0x3FFFFFFF;
 const int32 RTCVideoDecoder::ID_HALF = 0x20000000;
 const int32 RTCVideoDecoder::ID_INVALID = -1;
 
 // Maximum number of concurrent VDA::Decode() operations RVD will maintain.
@@ skipping 47 matching lines @@
     : weak_factory_(this),
       weak_this_(weak_factory_.GetWeakPtr()),
       factories_(factories),
       vda_loop_proxy_(factories->GetMessageLoop()),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       state_(UNINITIALIZED),
       decode_complete_callback_(NULL),
       num_shm_buffers_(0),
       next_bitstream_buffer_id_(0),
-      reset_bitstream_buffer_id_(ID_INVALID) {
-  DCHECK(!vda_loop_proxy_->BelongsToCurrentThread());
-  base::WaitableEvent message_loop_async_waiter(false, false);
-  // Waiting here is safe. The media thread is stopped in the child thread and
-  // the child thread is blocked when VideoDecoderFactory::CreateVideoDecoder
-  // runs.
-  vda_loop_proxy_->PostTask(FROM_HERE,
-                            base::Bind(&RTCVideoDecoder::Initialize,
-                                       base::Unretained(this),
-                                       &message_loop_async_waiter));
-  message_loop_async_waiter.Wait();
-}
+      reset_bitstream_buffer_id_(ID_INVALID) {}
 
 RTCVideoDecoder::~RTCVideoDecoder() {
   DVLOG(2) << "~RTCVideoDecoder";
-  // Destroy VDA and remove |this| from the observer if this is vda thread.
-  if (vda_loop_proxy_->BelongsToCurrentThread()) {
-    base::MessageLoop::current()->RemoveDestructionObserver(this);
-    DestroyVDA();
-  } else {
-    // VDA should have been destroyed in WillDestroyCurrentMessageLoop.
-    DCHECK(!vda_);
-  }
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DestroyVDA();
 
   // Delete all shared memories.
   STLDeleteElements(&available_shm_segments_);
   STLDeleteValues(&bitstream_buffers_in_decoder_);
   STLDeleteContainerPairFirstPointers(decode_buffers_.begin(),
                                       decode_buffers_.end());
   decode_buffers_.clear();
 
   // Delete WebRTC input buffers.
   for (std::deque<std::pair<webrtc::EncodedImage, BufferData> >::iterator it =
            pending_buffers_.begin();
        it != pending_buffers_.end();
        ++it) {
     delete[] it->first._buffer;
   }
 }
 
+// static
 scoped_ptr<RTCVideoDecoder> RTCVideoDecoder::Create(
     webrtc::VideoCodecType type,
     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories) {
   scoped_ptr<RTCVideoDecoder> decoder;
   // Convert WebRTC codec type to media codec profile.
   media::VideoCodecProfile profile;
   switch (type) {
     case webrtc::kVideoCodecVP8:
       profile = media::VP8PROFILE_MAIN;
       break;
     default:
       DVLOG(2) << "Video codec not supported:" << type;
       return decoder.Pass();
   }
 
+  base::WaitableEvent waiter(true, false);
   decoder.reset(new RTCVideoDecoder(factories));
-  decoder->vda_ =
-      factories->CreateVideoDecodeAccelerator(profile, decoder.get()).Pass();
+  decoder->vda_loop_proxy_->PostTask(FROM_HERE,
+                                     base::Bind(&RTCVideoDecoder::CreateVDA,
+                                                base::Unretained(decoder.get()),
+                                                profile,
+                                                &waiter));
+  waiter.Wait();

[jam, 2013/10/28 20:11:08]

is this running on the main thread?

[sheu, 2013/10/28 20:32:58]

It's running on WebRtc's main thread, which I believe is the same as the main
thread.  To fix this would require fixing WebRtc's threading model -- which is a
nontrivial change and not in the scope here.

For what it's worth it's not introducing new blocking -- it's just moving the
blocking out from
RendererGpuVideoAcceleratorFactories::CreateVideoDecodeAccelerator(), where it
was previously being done.

[Ami GONE FROM CHROMIUM, 2013/10/28 20:38:22]

No, it's not.  RTCVideoDecoder::Create() is called on
Chrome_libJingle_WorkerThread
(https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/m...)
which is a background thread dedicated to libjingle.

[jam, 2013/10/28 20:43:25]

ah ok, good to hear, thanks

   // vda can be NULL if VP8 is not supported.
   if (decoder->vda_ != NULL) {
     decoder->state_ = INITIALIZED;
   } else {
     factories->GetMessageLoop()->DeleteSoon(FROM_HERE, decoder.release());
   }
   return decoder.Pass();
 }
 
 int32_t RTCVideoDecoder::InitDecode(const webrtc::VideoCodec* codecSettings,
@@ skipping 245 matching lines @@
           0,  // sync_point
           media::BindToCurrentLoop(
               base::Bind(&RTCVideoDecoder::ReusePictureBuffer,
                          weak_this_,
                          picture.picture_buffer_id()))),
       decoder_texture_target_,
       pb.size(),
       visible_rect,
       natural_size,
       timestamp_ms,
-      base::Bind(&media::GpuVideoAcceleratorFactories::ReadPixels,
-                 factories_,
-                 pb.texture_id(),
-                 natural_size),
+      media::BindToLoopSync(
+          factories_->GetMessageLoop(),
+          base::Bind(&media::GpuVideoAcceleratorFactories::ReadPixels,
+                     factories_,
+                     pb.texture_id(),
+                     natural_size)),
       base::Closure());
 }
 
 void RTCVideoDecoder::NotifyEndOfBitstreamBuffer(int32 id) {
   DVLOG(3) << "NotifyEndOfBitstreamBuffer. id=" << id;
   DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
 
   std::map<int32, SHMBuffer*>::iterator it =
       bitstream_buffers_in_decoder_.find(id);
   if (it == bitstream_buffers_in_decoder_.end()) {
@@ skipping 40 matching lines @@
   LOG(ERROR) << "VDA Error:" << error;
   UMA_HISTOGRAM_ENUMERATION("Media.RTCVideoDecoderError",
                             error,
                             media::VideoDecodeAccelerator::LARGEST_ERROR_ENUM);
   DestroyVDA();
 
   base::AutoLock auto_lock(lock_);
   state_ = DECODE_ERROR;
 }
 
-void RTCVideoDecoder::WillDestroyCurrentMessageLoop() {
-  DVLOG(2) << "WillDestroyCurrentMessageLoop";
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
-  factories_->Abort();
-  weak_factory_.InvalidateWeakPtrs();
-  DestroyVDA();
-}
-
-void RTCVideoDecoder::Initialize(base::WaitableEvent* waiter) {
-  DVLOG(2) << "Initialize";
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
-  base::MessageLoop::current()->AddDestructionObserver(this);
-  waiter->Signal();
-}
-
 void RTCVideoDecoder::RequestBufferDecode() {
   DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
   if (!vda_)
     return;
 
   MovePendingBuffersToDecodeBuffers();
 
   while (CanMoreDecodeWorkBeDone()) {
     // Get a buffer and data from the queue.
     SHMBuffer* shm_buffer = NULL;
@@ skipping 139 matching lines @@
     factories_->DeleteTexture(it->second.texture_id());
     dismissed_picture_buffers_.erase(it);
     return;
   }
 
   factories_->WaitSyncPoint(sync_point);
 
   vda_->ReusePictureBuffer(picture_buffer_id);
 }
 
+void RTCVideoDecoder::CreateVDA(media::VideoCodecProfile profile,
+                                base::WaitableEvent* waiter) {
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  vda_ = factories_->CreateVideoDecodeAccelerator(profile, this);
+  waiter->Signal();
+}
+
 void RTCVideoDecoder::DestroyTextures() {
   DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
   std::map<int32, media::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();
@@ skipping 95 matching lines @@
 
 int32_t RTCVideoDecoder::RecordInitDecodeUMA(int32_t status) {
   // Logging boolean is enough to know if HW decoding has been used. Also,
   // InitDecode is less likely to return an error so enum is not used here.
   bool sample = (status == WEBRTC_VIDEO_CODEC_OK) ? true : false;
   UMA_HISTOGRAM_BOOLEAN("Media.RTCVideoDecoderInitDecodeSuccess", sample);
   return status;
 }
 
 }  // namespace content