content/common: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

content/common/gpu/media/v4l2_slice_video_decode_accelerator.cc

 // Copyright 2015 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 <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "content/common/gpu/media/v4l2_slice_video_decode_accelerator.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/media_switches.h"
 #include "ui/gl/scoped_binders.h"
 
 #define LOGF(level) LOG(level) << __FUNCTION__ << "(): "
 #define DVLOGF(level) DVLOG(level) << __FUNCTION__ << "(): "
 
@@ skipping 127 matching lines @@
       at_client(false),
       picture_id(-1),
       egl_image(EGL_NO_IMAGE_KHR),
       egl_sync(EGL_NO_SYNC_KHR),
       cleared(false) {
 }
 
 struct V4L2SliceVideoDecodeAccelerator::BitstreamBufferRef {
   BitstreamBufferRef(
       base::WeakPtr<VideoDecodeAccelerator::Client>& client,
-      const scoped_refptr<base::MessageLoopProxy>& client_message_loop_proxy,
+      const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner,
       base::SharedMemory* shm,
       size_t size,
       int32 input_id);
   ~BitstreamBufferRef();
   const base::WeakPtr<VideoDecodeAccelerator::Client> client;
-  const scoped_refptr<base::MessageLoopProxy> client_message_loop_proxy;
+  const scoped_refptr<base::SingleThreadTaskRunner> client_task_runner;
   const scoped_ptr<base::SharedMemory> shm;
   const size_t size;
   off_t bytes_used;
   const int32 input_id;
 };
 
 V4L2SliceVideoDecodeAccelerator::BitstreamBufferRef::BitstreamBufferRef(
     base::WeakPtr<VideoDecodeAccelerator::Client>& client,
-    const scoped_refptr<base::MessageLoopProxy>& client_message_loop_proxy,
+    const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner,
     base::SharedMemory* shm,
     size_t size,
     int32 input_id)
     : client(client),
-      client_message_loop_proxy(client_message_loop_proxy),
+      client_task_runner(client_task_runner),
       shm(shm),
       size(size),
       bytes_used(0),
       input_id(input_id) {
 }
 
 V4L2SliceVideoDecodeAccelerator::BitstreamBufferRef::~BitstreamBufferRef() {
   if (input_id >= 0) {
     DVLOGF(5) << "returning input_id: " << input_id;
-    client_message_loop_proxy->PostTask(
+    client_task_runner->PostTask(
         FROM_HERE,
         base::Bind(&VideoDecodeAccelerator::Client::NotifyEndOfBitstreamBuffer,
                    client, input_id));
   }
 }
 
 struct V4L2SliceVideoDecodeAccelerator::EGLSyncKHRRef {
   EGLSyncKHRRef(EGLDisplay egl_display, EGLSyncKHR egl_sync);
   ~EGLSyncKHRRef();
   EGLDisplay const egl_display;
@@ skipping 167 matching lines @@
 
 V4L2VP8Picture::~V4L2VP8Picture() {
 }
 
 V4L2SliceVideoDecodeAccelerator::V4L2SliceVideoDecodeAccelerator(
     const scoped_refptr<V4L2Device>& device,
     EGLDisplay egl_display,
     EGLContext egl_context,
     const base::WeakPtr<Client>& io_client,
     const base::Callback<bool(void)>& make_context_current,
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy)
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : input_planes_count_(0),
       output_planes_count_(0),
-      child_message_loop_proxy_(base::MessageLoopProxy::current()),
-      io_message_loop_proxy_(io_message_loop_proxy),
+      child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      io_task_runner_(io_task_runner),
       io_client_(io_client),
       device_(device),
       decoder_thread_("V4L2SliceVideoDecodeAcceleratorThread"),
       device_poll_thread_("V4L2SliceVideoDecodeAcceleratorDevicePollThread"),
       input_streamon_(false),
       input_buffer_queued_count_(0),
       output_streamon_(false),
       output_buffer_queued_count_(0),
       video_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN),
       output_format_fourcc_(0),
       state_(kUninitialized),
       decoder_flushing_(false),
       decoder_resetting_(false),
       surface_set_change_pending_(false),
       picture_clearing_count_(0),
       pictures_assigned_(false, false),
       make_context_current_(make_context_current),
       egl_display_(egl_display),
       egl_context_(egl_context),
       weak_this_factory_(this) {
   weak_this_ = weak_this_factory_.GetWeakPtr();
 }
 
 V4L2SliceVideoDecodeAccelerator::~V4L2SliceVideoDecodeAccelerator() {
   DVLOGF(2);
 
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!decoder_thread_.IsRunning());
   DCHECK(!device_poll_thread_.IsRunning());
 
   DCHECK(input_buffer_map_.empty());
   DCHECK(output_buffer_map_.empty());
 }
 
 void V4L2SliceVideoDecodeAccelerator::NotifyError(Error error) {
-  if (!child_message_loop_proxy_->BelongsToCurrentThread()) {
-    child_message_loop_proxy_->PostTask(
+  if (!child_task_runner_->BelongsToCurrentThread()) {
+    child_task_runner_->PostTask(
         FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::NotifyError,
                               weak_this_, error));
     return;
   }
 
   if (client_) {
     client_->NotifyError(error);
     client_ptr_factory_.reset();
   }
 }
 
 bool V4L2SliceVideoDecodeAccelerator::Initialize(
     media::VideoCodecProfile profile,
     VideoDecodeAccelerator::Client* client) {
   DVLOGF(3) << "profile: " << profile;
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kUninitialized);
 
   client_ptr_factory_.reset(
       new base::WeakPtrFactory<VideoDecodeAccelerator::Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
 
   video_profile_ = profile;
 
   if (video_profile_ >= media::H264PROFILE_MIN &&
       video_profile_ <= media::H264PROFILE_MAX) {
@@ skipping 41 matching lines @@
     return false;
   }
 
   if (!SetupFormats())
     return false;
 
   if (!decoder_thread_.Start()) {
     DLOG(ERROR) << "Initialize(): device thread failed to start";
     return false;
   }
-  decoder_thread_proxy_ = decoder_thread_.message_loop_proxy();
+  decoder_thread_proxy_ = decoder_thread_.task_runner();

[no sievers, 2015/05/12 18:11:30]

nit: consider renaming |decoder_thread_proxy_|

[Sami, 2015/05/13 18:17:52]

Done.

 
   state_ = kInitialized;
 
   // InitializeTask will NOTIFY_ERROR on failure.
   decoder_thread_proxy_->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::InitializeTask,
                             base::Unretained(this)));
 
   DVLOGF(1) << "V4L2SliceVideoDecodeAccelerator initialized";
   return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::InitializeTask() {
   DVLOGF(3);
   DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kInitialized);
 
   if (!CreateInputBuffers())
     NOTIFY_ERROR(PLATFORM_FAILURE);
 
   // Output buffers will be created once decoder gives us information
   // about their size and required count.
   state_ = kDecoding;
 }
 
 void V4L2SliceVideoDecodeAccelerator::Destroy() {
   DVLOGF(3);
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (decoder_thread_.IsRunning()) {
     decoder_thread_proxy_->PostTask(
         FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::DestroyTask,
                               base::Unretained(this)));
 
     // Wait for tasks to finish/early-exit.
     decoder_thread_.Stop();
   }
 
@@ skipping 176 matching lines @@
     PLOG(ERROR) << "Could not allocate enough output buffers";
     return false;
   }
 
   output_buffer_map_.resize(reqbufs.count);
 
   DVLOGF(3) << "buffer_count=" << output_buffer_map_.size()
             << ", visible size=" << visible_size_.ToString()
             << ", coded size=" << coded_size_.ToString();
 
-  child_message_loop_proxy_->PostTask(
+  child_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoDecodeAccelerator::Client::ProvidePictureBuffers,
                  client_, output_buffer_map_.size(), coded_size_,
                  device_->GetTextureTarget()));
 
   // Wait for the client to call AssignPictureBuffers() on the Child thread.
   // We do this, because if we continue decoding without finishing buffer
   // allocation, we may end up Resetting before AssignPictureBuffers arrives,
   // resulting in unnecessary complications and subtle bugs.
   pictures_assigned_.Wait();
@@ skipping 20 matching lines @@
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   input_buffer_map_.clear();
   free_input_buffers_.clear();
 }
 
 void V4L2SliceVideoDecodeAccelerator::DismissPictures(
     std::vector<int32> picture_buffer_ids,
     base::WaitableEvent* done) {
   DVLOGF(3);
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   for (auto picture_buffer_id : picture_buffer_ids) {
     DVLOGF(1) << "dismissing PictureBuffer id=" << picture_buffer_id;
     client_->DismissPictureBuffer(picture_buffer_id);
   }
 
   done->Signal();
 }
 
 void V4L2SliceVideoDecodeAccelerator::DevicePollTask(bool poll_device) {
@@ skipping 373 matching lines @@
     decoder_display_queue_.pop();
 
   DVLOGF(3) << "Device poll stopped";
   return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DVLOGF(3) << "input_id=" << bitstream_buffer.id()
             << ", size=" << bitstream_buffer.size();
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   decoder_thread_proxy_->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::DecodeTask,
                             base::Unretained(this), bitstream_buffer));
 }
 
 void V4L2SliceVideoDecodeAccelerator::DecodeTask(
     const media::BitstreamBuffer& bitstream_buffer) {
   DVLOGF(3) << "input_id=" << bitstream_buffer.id()
             << " size=" << bitstream_buffer.size();
   DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
 
   scoped_ptr<BitstreamBufferRef> bitstream_record(new BitstreamBufferRef(
-      io_client_, io_message_loop_proxy_,
+      io_client_, io_task_runner_,
       new base::SharedMemory(bitstream_buffer.handle(), true),
       bitstream_buffer.size(), bitstream_buffer.id()));
   if (!bitstream_record->shm->Map(bitstream_buffer.size())) {
     LOGF(ERROR) << "Could not map bitstream_buffer";
     NOTIFY_ERROR(UNREADABLE_INPUT);
     return;
   }
   DVLOGF(3) << "mapped at=" << bitstream_record->shm->memory();
 
   decoder_input_queue_.push(
@@ skipping 146 matching lines @@
 
   for (auto output_record : output_buffer_map_) {
     DCHECK(!output_record.at_device);
 
     if (output_record.egl_sync != EGL_NO_SYNC_KHR) {
       if (eglDestroySyncKHR(egl_display_, output_record.egl_sync) != EGL_TRUE)
         DVLOGF(1) << "eglDestroySyncKHR failed.";
     }
 
     if (output_record.egl_image != EGL_NO_IMAGE_KHR) {
-      child_message_loop_proxy_->PostTask(
+      child_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(base::IgnoreResult(&V4L2Device::DestroyEGLImage), device_,
                      egl_display_, output_record.egl_image));
     }
 
     picture_buffers_to_dismiss.push_back(output_record.picture_id);
   }
 
   if (dismiss) {
     DVLOGF(2) << "Scheduling picture dismissal";
     base::WaitableEvent done(false, false);
-    child_message_loop_proxy_->PostTask(
+    child_task_runner_->PostTask(
         FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::DismissPictures,
                               weak_this_, picture_buffers_to_dismiss, &done));
     done.Wait();
   }
 
   // At this point client can't call ReusePictureBuffer on any of the pictures
   // anymore, so it's safe to destroy.
   return DestroyOutputBuffers();
 }
 
@@ skipping 34 matching lines @@
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
 
   return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DVLOGF(3);
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (buffers.size() != output_buffer_map_.size()) {
     DLOG(ERROR) << "Failed to provide requested picture buffers. "
                 << "(Got " << buffers.size()
                 << ", requested " << output_buffer_map_.size() << ")";
     NOTIFY_ERROR(INVALID_ARGUMENT);
     return;
   }
 
   if (!make_context_current_.Run()) {
@@ skipping 38 matching lines @@
     output_record.picture_id = buffers[i].id();
     free_output_buffers_.push_back(i);
     DVLOGF(3) << "buffer[" << i << "]: picture_id=" << output_record.picture_id;
   }
 
   pictures_assigned_.Signal();
 }
 
 void V4L2SliceVideoDecodeAccelerator::ReusePictureBuffer(
     int32 picture_buffer_id) {
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DVLOGF(4) << "picture_buffer_id=" << picture_buffer_id;
 
   if (!make_context_current_.Run()) {
     LOGF(ERROR) << "could not make context current";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   EGLSyncKHR egl_sync =
       eglCreateSyncKHR(egl_display_, EGL_SYNC_FENCE_KHR, NULL);
@@ skipping 42 matching lines @@
   DCHECK(!output_record.at_device);
   output_record.at_client = false;
   output_record.egl_sync = egl_sync_ref->egl_sync;
   // Take ownership of the EGLSync.
   egl_sync_ref->egl_sync = EGL_NO_SYNC_KHR;
   surfaces_at_display_.erase(it);
 }
 
 void V4L2SliceVideoDecodeAccelerator::Flush() {
   DVLOGF(3);
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   decoder_thread_proxy_->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::FlushTask,
                             base::Unretained(this)));
 }
 
 void V4L2SliceVideoDecodeAccelerator::FlushTask() {
   DVLOGF(3);
   DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
 
   if (!decoder_input_queue_.empty()) {
     // We are not done with pending inputs, so queue an empty buffer,
     // which - when reached - will trigger flush sequence.
     decoder_input_queue_.push(
         linked_ptr<BitstreamBufferRef>(new BitstreamBufferRef(
-            io_client_, io_message_loop_proxy_, nullptr, 0, kFlushBufferId)));
+            io_client_, io_task_runner_, nullptr, 0, kFlushBufferId)));
     return;
   }
 
   // No more inputs pending, so just finish flushing here.
   InitiateFlush();
 }
 
 void V4L2SliceVideoDecodeAccelerator::InitiateFlush() {
   DVLOGF(3);
   DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
@@ skipping 38 matching lines @@
   // we will have all remaining PictureReady() posted to the client and we
   // can post NotifyFlushDone().
   DCHECK(decoder_display_queue_.empty());
 
   // Decoder should have already returned all surfaces and all surfaces are
   // out of hardware. There can be no other owners of input buffers.
   DCHECK_EQ(free_input_buffers_.size(), input_buffer_map_.size());
 
   SendPictureReady();
 
-  child_message_loop_proxy_->PostTask(
-      FROM_HERE, base::Bind(&Client::NotifyFlushDone, client_));
+  child_task_runner_->PostTask(FROM_HERE,
+                               base::Bind(&Client::NotifyFlushDone, client_));
 
   decoder_flushing_ = false;
 
   DVLOGF(3) << "Flush finished";
   state_ = kDecoding;
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 void V4L2SliceVideoDecodeAccelerator::Reset() {
   DVLOGF(3);
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   decoder_thread_proxy_->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::ResetTask,
                             base::Unretained(this)));
 }
 
 void V4L2SliceVideoDecodeAccelerator::ResetTask() {
   DVLOGF(3);
   DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
 
@@ skipping 43 matching lines @@
   // simply mark them all as available.
   DCHECK_EQ(input_buffer_queued_count_, 0);
   free_input_buffers_.clear();
   for (size_t i = 0; i < input_buffer_map_.size(); ++i) {
     DCHECK(!input_buffer_map_[i].at_device);
     ReuseInputBuffer(i);
   }
 
   decoder_resetting_ = false;
 
-  child_message_loop_proxy_->PostTask(
-      FROM_HERE, base::Bind(&Client::NotifyResetDone, client_));
+  child_task_runner_->PostTask(FROM_HERE,
+                               base::Bind(&Client::NotifyResetDone, client_));
 
   DVLOGF(3) << "Reset finished";
 
   state_ = kDecoding;
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 void V4L2SliceVideoDecodeAccelerator::SetErrorState(Error error) {
   // We can touch decoder_state_ only if this is the decoder thread or the
   // decoder thread isn't running.
@@ skipping 753 matching lines @@
   DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
   bool resetting_or_flushing = (decoder_resetting_ || decoder_flushing_);
   while (!pending_picture_ready_.empty()) {
     bool cleared = pending_picture_ready_.front().cleared;
     const media::Picture& picture = pending_picture_ready_.front().picture;
     if (cleared && picture_clearing_count_ == 0) {
       DVLOGF(4) << "Posting picture ready to IO for: "
                 << picture.picture_buffer_id();
       // This picture is cleared. Post it to IO thread to reduce latency. This
       // should be the case after all pictures are cleared at the beginning.
-      io_message_loop_proxy_->PostTask(
+      io_task_runner_->PostTask(
           FROM_HERE, base::Bind(&Client::PictureReady, io_client_, picture));
       pending_picture_ready_.pop();
     } else if (!cleared || resetting_or_flushing) {
       DVLOGF(3) << "cleared=" << pending_picture_ready_.front().cleared
                 << ", decoder_resetting_=" << decoder_resetting_
                 << ", decoder_flushing_=" << decoder_flushing_
                 << ", picture_clearing_count_=" << picture_clearing_count_;
       DVLOGF(4) << "Posting picture ready to GPU for: "
                 << picture.picture_buffer_id();
       // If the picture is not cleared, post it to the child thread because it
       // has to be cleared in the child thread. A picture only needs to be
       // cleared once. If the decoder is resetting or flushing, send all
       // pictures to ensure PictureReady arrive before reset or flush done.
-      child_message_loop_proxy_->PostTaskAndReply(
+      child_task_runner_->PostTaskAndReply(
           FROM_HERE, base::Bind(&Client::PictureReady, client_, picture),
           // Unretained is safe. If Client::PictureReady gets to run, |this| is
           // alive. Destroy() will wait the decode thread to finish.
           base::Bind(&V4L2SliceVideoDecodeAccelerator::PictureCleared,
                      base::Unretained(this)));
       picture_clearing_count_++;
       pending_picture_ready_.pop();
     } else {
       // This picture is cleared. But some pictures are about to be cleared on
       // the child thread. To preserve the order, do not send this until those
@@ skipping 50 matching lines @@
         profile.profile = media::VP8PROFILE_ANY;
         profiles.push_back(profile);
         break;
     }
   }
 
   return profiles;
 }
 
 }  // namespace content