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

content/common/gpu/media/v4l2_video_encode_accelerator.cc

 // Copyright 2014 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/callback.h"
 #include "base/command_line.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/media/v4l2_video_encode_accelerator.h"
 #include "content/public/common/content_switches.h"
 #include "media/base/bitstream_buffer.h"
 
 #define NOTIFY_ERROR(x)                        \
   do {                                         \
     LOG(ERROR) << "Setting error state:" << x; \
     SetErrorState(x);                          \
@@ skipping 38 matching lines @@
 
 V4L2VideoEncodeAccelerator::OutputRecord::OutputRecord()
     : at_device(false), address(NULL), length(0) {
 }
 
 V4L2VideoEncodeAccelerator::OutputRecord::~OutputRecord() {
 }
 
 V4L2VideoEncodeAccelerator::V4L2VideoEncodeAccelerator(
     const scoped_refptr<V4L2Device>& device)
-    : child_message_loop_proxy_(base::MessageLoopProxy::current()),
+    : child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       output_buffer_byte_size_(0),
       device_input_format_(media::VideoFrame::UNKNOWN),
       input_planes_count_(0),
       output_format_fourcc_(0),
       encoder_state_(kUninitialized),
       stream_header_size_(0),
       device_(device),
       input_streamon_(false),
       input_buffer_queued_count_(0),
       input_memory_type_(V4L2_MEMORY_USERPTR),
@@ skipping 24 matching lines @@
            << media::VideoFrame::FormatToString(input_format)
            << ", input_visible_size=" << input_visible_size.ToString()
            << ", output_profile=" << output_profile
            << ", initial_bitrate=" << initial_bitrate;
 
   visible_size_ = input_visible_size;
 
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
 
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(encoder_state_, kUninitialized);
 
   struct v4l2_capability caps;
   memset(&caps, 0, sizeof(caps));
   const __u32 kCapsRequired = V4L2_CAP_VIDEO_CAPTURE_MPLANE |
                               V4L2_CAP_VIDEO_OUTPUT_MPLANE | V4L2_CAP_STREAMING;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYCAP, &caps);
   if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
     LOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP: "
                   "caps check failed: 0x" << std::hex << caps.capabilities;
@@ skipping 37 matching lines @@
 
   if (!encoder_thread_.Start()) {
     LOG(ERROR) << "Initialize(): encoder thread failed to start";
     return false;
   }
 
   RequestEncodingParametersChange(initial_bitrate, kInitialFramerate);
 
   encoder_state_ = kInitialized;
 
-  child_message_loop_proxy_->PostTask(
+  child_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&Client::RequireBitstreamBuffers,
-                 client_,
-                 kInputBufferCount,
-                 image_processor_.get() ?
-                     image_processor_->input_allocated_size() :
-                     input_allocated_size_,
+      base::Bind(&Client::RequireBitstreamBuffers, client_, kInputBufferCount,
+                 image_processor_.get()
+                     ? image_processor_->input_allocated_size()
+                     : input_allocated_size_,
                  output_buffer_byte_size_));
   return true;
 }
 
 void V4L2VideoEncodeAccelerator::ImageProcessorError() {
   LOG(ERROR) << "Image processor error";
   NOTIFY_ERROR(kPlatformFailureError);
 }
 
 void V4L2VideoEncodeAccelerator::Encode(
     const scoped_refptr<media::VideoFrame>& frame,
     bool force_keyframe) {
   DVLOG(3) << "Encode(): force_keyframe=" << force_keyframe;
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (image_processor_) {
     image_processor_->Process(
         frame,
         base::Bind(&V4L2VideoEncodeAccelerator::FrameProcessed,
                    weak_this_,
                    force_keyframe));
   } else {
     encoder_thread_.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&V4L2VideoEncodeAccelerator::EncodeTask,
                    base::Unretained(this),
                    frame,
                    force_keyframe));
   }
 }
 
 void V4L2VideoEncodeAccelerator::UseOutputBitstreamBuffer(
     const media::BitstreamBuffer& buffer) {
   DVLOG(3) << "UseOutputBitstreamBuffer(): id=" << buffer.id();
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (buffer.size() < output_buffer_byte_size_) {
     NOTIFY_ERROR(kInvalidArgumentError);
     return;
   }
 
   scoped_ptr<base::SharedMemory> shm(
       new base::SharedMemory(buffer.handle(), false));
   if (!shm->Map(buffer.size())) {
     NOTIFY_ERROR(kPlatformFailureError);
     return;
   }
 
   scoped_ptr<BitstreamBufferRef> buffer_ref(
       new BitstreamBufferRef(buffer.id(), shm.Pass(), buffer.size()));
   encoder_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&V4L2VideoEncodeAccelerator::UseOutputBitstreamBufferTask,
                  base::Unretained(this),
                  base::Passed(&buffer_ref)));
 }
 
 void V4L2VideoEncodeAccelerator::RequestEncodingParametersChange(
     uint32 bitrate,
     uint32 framerate) {
   DVLOG(3) << "RequestEncodingParametersChange(): bitrate=" << bitrate
            << ", framerate=" << framerate;
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   encoder_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(
           &V4L2VideoEncodeAccelerator::RequestEncodingParametersChangeTask,
           base::Unretained(this),
           bitrate,
           framerate));
 }
 
 void V4L2VideoEncodeAccelerator::Destroy() {
   DVLOG(3) << "Destroy()";
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   // We're destroying; cancel all callbacks.
   client_ptr_factory_.reset();
   weak_this_ptr_factory_.InvalidateWeakPtrs();
 
   if (image_processor_.get())
     image_processor_.release()->Destroy();
 
   // If the encoder thread is running, destroy using posted task.
   if (encoder_thread_.IsRunning()) {
@@ skipping 44 matching lines @@
         break;
     }
   }
 
   return profiles;
 }
 
 void V4L2VideoEncodeAccelerator::FrameProcessed(
     bool force_keyframe,
     const scoped_refptr<media::VideoFrame>& frame) {
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DVLOG(3) << "FrameProcessed(): force_keyframe=" << force_keyframe;
 
   encoder_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&V4L2VideoEncodeAccelerator::EncodeTask,
                  base::Unretained(this),
                  frame,
                  force_keyframe));
 }
 
@@ skipping 242 matching lines @@
       } else {
         memcpy(target_data, output_data, output_size);
       }
     } else {
       memcpy(target_data, output_data, output_size);
     }
 
     DVLOG(3) << "Dequeue(): returning "
                 "bitstream_buffer_id=" << output_record.buffer_ref->id
              << ", size=" << output_size << ", key_frame=" << key_frame;
-    child_message_loop_proxy_->PostTask(
+    child_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&Client::BitstreamBufferReady,
-                   client_,
-                   output_record.buffer_ref->id,
-                   output_size,
-                   key_frame));
+        base::Bind(&Client::BitstreamBufferReady, client_,
+                   output_record.buffer_ref->id, output_size, key_frame));
     output_record.at_device = false;
     output_record.buffer_ref.reset();
     free_output_buffers_.push_back(dqbuf.index);
     output_buffer_queued_count_--;
   }
 }
 
 bool V4L2VideoEncodeAccelerator::EnqueueInputRecord() {
   DVLOG(3) << "EnqueueInputRecord()";
   DCHECK(!free_input_buffers_.empty());
@@ skipping 163 matching lines @@
   // touch encoder state from this thread.
   encoder_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&V4L2VideoEncodeAccelerator::ServiceDeviceTask,
                  base::Unretained(this)));
 }
 
 void V4L2VideoEncodeAccelerator::NotifyError(Error error) {
   DVLOG(1) << "NotifyError(): error=" << error;
 
-  if (!child_message_loop_proxy_->BelongsToCurrentThread()) {
-    child_message_loop_proxy_->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &V4L2VideoEncodeAccelerator::NotifyError, weak_this_, error));
+  if (!child_task_runner_->BelongsToCurrentThread()) {
+    child_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::NotifyError,
+                              weak_this_, error));
     return;
   }
 
   if (client_) {
     client_->NotifyError(error);
     client_ptr_factory_.reset();
   }
 }
 
 void V4L2VideoEncodeAccelerator::SetErrorState(Error error) {
@@ skipping 44 matching lines @@
   parms.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   // Note that we are provided "frames per second" but V4L2 expects "time per
   // frame"; hence we provide the reciprocal of the framerate here.
   parms.parm.output.timeperframe.numerator = 1;
   parms.parm.output.timeperframe.denominator = framerate;
   IOCTL_OR_ERROR_RETURN(VIDIOC_S_PARM, &parms);
 }
 
 bool V4L2VideoEncodeAccelerator::SetOutputFormat(
     media::VideoCodecProfile output_profile) {
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
   DCHECK(!output_streamon_);
 
   output_format_fourcc_ =
       V4L2Device::VideoCodecProfileToV4L2PixFmt(output_profile, false);
   if (!output_format_fourcc_) {
     LOG(ERROR) << "Initialize(): invalid output_profile=" << output_profile;
     return false;
   }
 
@@ skipping 14 matching lines @@
   size_t adjusted_output_buffer_size =
       base::checked_cast<size_t>(format.fmt.pix_mp.plane_fmt[0].sizeimage);
   output_buffer_byte_size_ = adjusted_output_buffer_size;
 
   return true;
 }
 
 bool V4L2VideoEncodeAccelerator::NegotiateInputFormat(
     media::VideoFrame::Format input_format) {
   DVLOG(3) << "NegotiateInputFormat()";
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
   DCHECK(!output_streamon_);
 
   device_input_format_ = media::VideoFrame::UNKNOWN;
   input_planes_count_ = 0;
 
   uint32 input_format_fourcc =
       V4L2Device::VideoFrameFormatToV4L2PixFmt(input_format);
   if (!input_format_fourcc) {
     LOG(ERROR) << "Unsupported input format";
@@ skipping 39 matching lines @@
 
   device_input_format_ = input_format;
   input_planes_count_ = input_planes_count;
   return true;
 }
 
 bool V4L2VideoEncodeAccelerator::SetFormats(
     media::VideoFrame::Format input_format,
     media::VideoCodecProfile output_profile) {
   DVLOG(3) << "SetFormats()";
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
   DCHECK(!output_streamon_);
 
   if (!SetOutputFormat(output_profile))
     return false;
 
   if (!NegotiateInputFormat(input_format))
     return false;
 
   struct v4l2_crop crop;
@@ skipping 119 matching lines @@
   DCHECK(input_buffer_map_.empty());
   input_buffer_map_.resize(reqbufs.count);
   for (size_t i = 0; i < input_buffer_map_.size(); ++i)
     free_input_buffers_.push_back(i);
 
   return true;
 }
 
 bool V4L2VideoEncodeAccelerator::CreateOutputBuffers() {
   DVLOG(3) << "CreateOutputBuffers()";
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!output_streamon_);
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = kOutputBufferCount;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
 
   DCHECK(output_buffer_map_.empty());
@@ skipping 21 matching lines @@
     output_buffer_map_[i].address = address;
     output_buffer_map_[i].length = buffer.m.planes[0].length;
     free_output_buffers_.push_back(i);
   }
 
   return true;
 }
 
 void V4L2VideoEncodeAccelerator::DestroyInputBuffers() {
   DVLOG(3) << "DestroyInputBuffers()";
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   reqbufs.memory = input_memory_type_;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   input_buffer_map_.clear();
   free_input_buffers_.clear();
 }
 
 void V4L2VideoEncodeAccelerator::DestroyOutputBuffers() {
   DVLOG(3) << "DestroyOutputBuffers()";
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!output_streamon_);
 
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
     if (output_buffer_map_[i].address != NULL)
       device_->Munmap(output_buffer_map_[i].address,
                       output_buffer_map_[i].length);
   }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   output_buffer_map_.clear();
   free_output_buffers_.clear();
 }
 
 }  // namespace content