Replace MessageLoopProxy with SingleThreadTaskRunner for media/filters/ + associated code.

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"
@@ skipping 58 matching lines @@
 
 RTCVideoDecoder::BufferData::BufferData() {}
 
 RTCVideoDecoder::BufferData::~BufferData() {}
 
 RTCVideoDecoder::RTCVideoDecoder(
     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories)
     : weak_factory_(this),
       weak_this_(weak_factory_.GetWeakPtr()),
       factories_(factories),
-      vda_loop_proxy_(factories->GetMessageLoop()),
+      vda_task_runner_(factories->GetTaskRunner()),
       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());
+  DCHECK(!vda_task_runner_->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));
+  vda_task_runner_->PostTask(FROM_HERE,
+                             base::Bind(&RTCVideoDecoder::Initialize,
+                                        base::Unretained(this),
+                                        &message_loop_async_waiter));
   message_loop_async_waiter.Wait();
 }
 
 RTCVideoDecoder::~RTCVideoDecoder() {
   DVLOG(2) << "~RTCVideoDecoder";
   // Destroy VDA and remove |this| from the observer if this is vda thread.
-  if (vda_loop_proxy_->BelongsToCurrentThread()) {
+  if (vda_task_runner_->BelongsToCurrentThread()) {
     base::MessageLoop::current()->RemoveDestructionObserver(this);
     DestroyVDA();
   } else {
     // VDA should have been destroyed in WillDestroyCurrentMessageLoop.
     DCHECK(!vda_);
   }
 
   // Delete all shared memories.
   STLDeleteElements(&available_shm_segments_);
   STLDeleteValues(&bitstream_buffers_in_decoder_);
@@ skipping 25 matching lines @@
       return decoder.Pass();
   }
 
   decoder.reset(new RTCVideoDecoder(factories));
   decoder->vda_ =
       factories->CreateVideoDecodeAccelerator(profile, decoder.get()).Pass();
   // vda can be NULL if VP8 is not supported.
   if (decoder->vda_ != NULL) {
     decoder->state_ = INITIALIZED;
   } else {
-    factories->GetMessageLoop()->DeleteSoon(FROM_HERE, decoder.release());
+    factories->GetTaskRunner()->DeleteSoon(FROM_HERE, decoder.release());
   }
   return decoder.Pass();
 }
 
 int32_t RTCVideoDecoder::InitDecode(const webrtc::VideoCodec* codecSettings,
                                     int32_t /*numberOfCores*/) {
   DVLOG(2) << "InitDecode";
   DCHECK_EQ(codecSettings->codecType, webrtc::kVideoCodecVP8);
   if (codecSettings->codecSpecific.VP8.feedbackModeOn) {
     LOG(ERROR) << "Feedback mode not supported";
     return RecordInitDecodeUMA(WEBRTC_VIDEO_CODEC_ERROR);
   }
 
   base::AutoLock auto_lock(lock_);
   if (state_ == UNINITIALIZED || state_ == DECODE_ERROR) {
     LOG(ERROR) << "VDA is not initialized. state=" << state_;
     return RecordInitDecodeUMA(WEBRTC_VIDEO_CODEC_UNINITIALIZED);
   }
   // Create some shared memory if the queue is empty.
   if (available_shm_segments_.size() == 0) {
-    vda_loop_proxy_->PostTask(FROM_HERE,
-                              base::Bind(&RTCVideoDecoder::CreateSHM,
-                                         weak_this_,
-                                         kMaxInFlightDecodes,
-                                         kSharedMemorySegmentBytes));
+    vda_task_runner_->PostTask(FROM_HERE,
+                               base::Bind(&RTCVideoDecoder::CreateSHM,
+                                          weak_this_,
+                                          kMaxInFlightDecodes,
+                                          kSharedMemorySegmentBytes));
   }
   return RecordInitDecodeUMA(WEBRTC_VIDEO_CODEC_OK);
 }
 
 int32_t RTCVideoDecoder::Decode(
     const webrtc::EncodedImage& inputImage,
     bool missingFrames,
     const webrtc::RTPFragmentationHeader* /*fragmentation*/,
     const webrtc::CodecSpecificInfo* /*codecSpecificInfo*/,
     int64_t /*renderTimeMs*/) {
@@ skipping 65 matching lines @@
     if (!SaveToPendingBuffers_Locked(inputImage, buffer_data))
       return WEBRTC_VIDEO_CODEC_ERROR;
     if (need_to_reset_for_midstream_resize) {
       base::AutoUnlock auto_unlock(lock_);
       Reset();
     }
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
   SaveToDecodeBuffers_Locked(inputImage, shm_buffer.Pass(), buffer_data);
-  vda_loop_proxy_->PostTask(
+  vda_task_runner_->PostTask(
       FROM_HERE, base::Bind(&RTCVideoDecoder::RequestBufferDecode, weak_this_));
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t RTCVideoDecoder::RegisterDecodeCompleteCallback(
     webrtc::DecodedImageCallback* callback) {
   DVLOG(2) << "RegisterDecodeCompleteCallback";
   base::AutoLock auto_lock(lock_);
   decode_complete_callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
@@ skipping 13 matching lines @@
     LOG(ERROR) << "Decoder not initialized.";
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
   if (next_bitstream_buffer_id_ != 0)
     reset_bitstream_buffer_id_ = next_bitstream_buffer_id_ - 1;
   else
     reset_bitstream_buffer_id_ = ID_LAST;
   // If VDA is already resetting, no need to request the reset again.
   if (state_ != RESETTING) {
     state_ = RESETTING;
-    vda_loop_proxy_->PostTask(
+    vda_task_runner_->PostTask(
         FROM_HERE, base::Bind(&RTCVideoDecoder::ResetInternal, weak_this_));
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void RTCVideoDecoder::NotifyInitializeDone() {
   DVLOG(2) << "NotifyInitializeDone";
   NOTREACHED();
 }
 
 void RTCVideoDecoder::ProvidePictureBuffers(uint32 count,
                                             const gfx::Size& size,
                                             uint32 texture_target) {
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(vda_task_runner_->BelongsToCurrentThread());
   DVLOG(3) << "ProvidePictureBuffers. texture_target=" << texture_target;
 
   if (!vda_)
     return;
 
   std::vector<uint32> texture_ids;
   std::vector<gpu::Mailbox> texture_mailboxes;
   decoder_texture_target_ = texture_target;
   // Discards the sync point returned here since PictureReady will imply that
   // the produce has already happened, and the texture is ready for use.
@@ skipping 14 matching lines @@
         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);
   }
   vda_->AssignPictureBuffers(picture_buffers);
 }
 
 void RTCVideoDecoder::DismissPictureBuffer(int32 id) {
   DVLOG(3) << "DismissPictureBuffer. id=" << id;
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(vda_task_runner_->BelongsToCurrentThread());
 
   std::map<int32, media::PictureBuffer>::iterator it =
       assigned_picture_buffers_.find(id);
   if (it == assigned_picture_buffers_.end()) {
     NOTREACHED() << "Missing picture buffer: " << id;
     return;
   }
 
   media::PictureBuffer buffer_to_dismiss = it->second;
   assigned_picture_buffers_.erase(it);
 
   std::set<int32>::iterator at_display_it =
       picture_buffers_at_display_.find(id);
 
   if (at_display_it == picture_buffers_at_display_.end()) {
     // We can delete the texture immediately as it's not being displayed.
     factories_->DeleteTexture(buffer_to_dismiss.texture_id());
   } else {
     // Texture in display. Postpone deletion until after it's returned to us.
     bool inserted = dismissed_picture_buffers_
         .insert(std::make_pair(id, buffer_to_dismiss)).second;
     DCHECK(inserted);
   }
 }
 
 void RTCVideoDecoder::PictureReady(const media::Picture& picture) {
   DVLOG(3) << "PictureReady";
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(vda_task_runner_->BelongsToCurrentThread());
 
   std::map<int32, media::PictureBuffer>::iterator it =
       assigned_picture_buffers_.find(picture.picture_buffer_id());
   if (it == assigned_picture_buffers_.end()) {
     NOTREACHED() << "Missing picture buffer: " << picture.picture_buffer_id();
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   const media::PictureBuffer& pb = it->second;
 
@@ skipping 52 matching lines @@
       timestamp_ms,
       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());
+  DCHECK(vda_task_runner_->BelongsToCurrentThread());
 
   std::map<int32, SHMBuffer*>::iterator it =
       bitstream_buffers_in_decoder_.find(id);
   if (it == bitstream_buffers_in_decoder_.end()) {
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     NOTREACHED() << "Missing bitstream buffer: " << id;
     return;
   }
 
   {
     base::AutoLock auto_lock(lock_);
     PutSHM_Locked(scoped_ptr<SHMBuffer>(it->second));
   }
   bitstream_buffers_in_decoder_.erase(it);
 
   RequestBufferDecode();
 }
 
 void RTCVideoDecoder::NotifyFlushDone() {
   DVLOG(3) << "NotifyFlushDone";
   NOTREACHED() << "Unexpected flush done notification.";
 }
 
 void RTCVideoDecoder::NotifyResetDone() {
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(vda_task_runner_->BelongsToCurrentThread());
   DVLOG(3) << "NotifyResetDone";
 
   if (!vda_)
     return;
 
   input_buffer_data_.clear();
   {
     base::AutoLock auto_lock(lock_);
     state_ = INITIALIZED;
   }
   // Send the pending buffers for decoding.
   RequestBufferDecode();
 }
 
 void RTCVideoDecoder::NotifyError(media::VideoDecodeAccelerator::Error error) {
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(vda_task_runner_->BelongsToCurrentThread());
   if (!vda_)
     return;
 
   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());
+  DCHECK(vda_task_runner_->BelongsToCurrentThread());
   factories_->Abort();
   weak_factory_.InvalidateWeakPtrs();
   DestroyVDA();
 }
 
 void RTCVideoDecoder::Initialize(base::WaitableEvent* waiter) {
   DVLOG(2) << "Initialize";
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(vda_task_runner_->BelongsToCurrentThread());
   base::MessageLoop::current()->AddDestructionObserver(this);
   waiter->Signal();
 }
 
 void RTCVideoDecoder::RequestBufferDecode() {
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(vda_task_runner_->BelongsToCurrentThread());
   if (!vda_)
     return;
 
   MovePendingBuffersToDecodeBuffers();
 
   while (CanMoreDecodeWorkBeDone()) {
     // Get a buffer and data from the queue.
     SHMBuffer* shm_buffer = NULL;
     BufferData buffer_data;
     {
@@ skipping 101 matching lines @@
     scoped_ptr<SHMBuffer> shm_buffer = GetSHM_Locked(input_image._length);
     if (!shm_buffer)
       return;
     SaveToDecodeBuffers_Locked(input_image, shm_buffer.Pass(), buffer_data);
     delete[] input_image._buffer;
     pending_buffers_.pop_front();
   }
 }
 
 void RTCVideoDecoder::ResetInternal() {
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(vda_task_runner_->BelongsToCurrentThread());
   DVLOG(2) << "ResetInternal";
   if (vda_)
     vda_->Reset();
 }
 
 void RTCVideoDecoder::ReusePictureBuffer(int64 picture_buffer_id,
                                          uint32 sync_point) {
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(vda_task_runner_->BelongsToCurrentThread());
   DVLOG(3) << "ReusePictureBuffer. id=" << picture_buffer_id;
 
   if (!vda_)
     return;
 
   CHECK(!picture_buffers_at_display_.empty());
 
   size_t num_erased = picture_buffers_at_display_.erase(picture_buffer_id);
   DCHECK(num_erased);
 
   std::map<int32, media::PictureBuffer>::iterator it =
       assigned_picture_buffers_.find(picture_buffer_id);
 
   if (it == assigned_picture_buffers_.end()) {
     // This picture was dismissed while in display, so we postponed deletion.
     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);
 
   vda_->ReusePictureBuffer(picture_buffer_id);
 }
 
 void RTCVideoDecoder::DestroyTextures() {
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(vda_task_runner_->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();
 
   for (it = dismissed_picture_buffers_.begin();
        it != dismissed_picture_buffers_.end();
        ++it) {
     factories_->DeleteTexture(it->second.texture_id());
   }
   dismissed_picture_buffers_.clear();
 }
 
 void RTCVideoDecoder::DestroyVDA() {
   DVLOG(2) << "DestroyVDA";
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(vda_task_runner_->BelongsToCurrentThread());
   if (vda_)
     vda_.release()->Destroy();
   DestroyTextures();
   base::AutoLock auto_lock(lock_);
   state_ = UNINITIALIZED;
 }
 
 scoped_ptr<RTCVideoDecoder::SHMBuffer> RTCVideoDecoder::GetSHM_Locked(
     size_t min_size) {
   // Reuse a SHM if possible.
   SHMBuffer* ret = NULL;
   if (!available_shm_segments_.empty() &&
       available_shm_segments_.back()->size >= min_size) {
     ret = available_shm_segments_.back();
     available_shm_segments_.pop_back();
   }
   // Post to vda thread to create shared memory if SHM cannot be reused or the
   // queue is almost empty.
   if (num_shm_buffers_ < kMaxNumSharedMemorySegments &&
       (ret == NULL || available_shm_segments_.size() <= 1)) {
-    vda_loop_proxy_->PostTask(
+    vda_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&RTCVideoDecoder::CreateSHM, weak_this_, 1, min_size));
   }
   return scoped_ptr<SHMBuffer>(ret);
 }
 
 void RTCVideoDecoder::PutSHM_Locked(scoped_ptr<SHMBuffer> shm_buffer) {
   available_shm_segments_.push_back(shm_buffer.release());
 }
 
 void RTCVideoDecoder::CreateSHM(int number, size_t min_size) {
-  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(vda_task_runner_->BelongsToCurrentThread());
   DVLOG(2) << "CreateSHM. size=" << min_size;
   int number_to_allocate;
   {
     base::AutoLock auto_lock(lock_);
     number_to_allocate =
         std::min(kMaxNumSharedMemorySegments - num_shm_buffers_, number);
   }
   size_t size_to_allocate = std::max(min_size, kSharedMemorySegmentBytes);
   for (int i = 0; i < number_to_allocate; i++) {
     base::SharedMemory* shm = factories_->CreateSharedMemory(size_to_allocate);
@@ skipping 40 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