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

content/common/gpu/media/v4l2_image_processor.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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/numerics/safe_conversions.h"
 #include "content/common/gpu/media/v4l2_image_processor.h"
 #include "media/base/bind_to_current_loop.h"
 
 #define NOTIFY_ERROR()                      \
   do {                                      \
     LOG(ERROR) << "calling NotifyError()";  \
     NotifyError();                          \
   } while (0)
 
@@ skipping 38 matching lines @@
 V4L2ImageProcessor::JobRecord::~JobRecord() {
 }
 
 V4L2ImageProcessor::V4L2ImageProcessor(const scoped_refptr<V4L2Device>& device)
     : input_format_(media::VideoFrame::UNKNOWN),
       output_format_(media::VideoFrame::UNKNOWN),
       input_format_fourcc_(0),
       output_format_fourcc_(0),
       input_planes_count_(0),
       output_planes_count_(0),
-      child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      child_message_loop_proxy_(base::MessageLoopProxy::current()),
       device_(device),
       device_thread_("V4L2ImageProcessorThread"),
       device_poll_thread_("V4L2ImageProcessorDevicePollThread"),
       input_streamon_(false),
       input_buffer_queued_count_(0),
       output_streamon_(false),
       output_buffer_queued_count_(0),
       device_weak_factory_(this) {
 }
 
 V4L2ImageProcessor::~V4L2ImageProcessor() {
-  DCHECK(child_task_runner_->BelongsToCurrentThread());
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!device_thread_.IsRunning());
   DCHECK(!device_poll_thread_.IsRunning());
 
   DestroyInputBuffers();
   DestroyOutputBuffers();
 }
 
 void V4L2ImageProcessor::NotifyError() {
-  if (!child_task_runner_->BelongsToCurrentThread())
-    child_task_runner_->PostTask(FROM_HERE, error_cb_);
+  if (!child_message_loop_proxy_->BelongsToCurrentThread())
+    child_message_loop_proxy_->PostTask(FROM_HERE, error_cb_);
   else
     error_cb_.Run();
 }
 
 bool V4L2ImageProcessor::Initialize(media::VideoFrame::Format input_format,
                                     media::VideoFrame::Format output_format,
                                     gfx::Size input_visible_size,
                                     gfx::Size output_visible_size,
                                     gfx::Size output_allocated_size,
                                     const base::Closure& error_cb) {
@@ skipping 81 matching lines @@
 
 void V4L2ImageProcessor::ProcessTask(scoped_ptr<JobRecord> job_record) {
   DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
 
   input_queue_.push(make_linked_ptr(job_record.release()));
   Enqueue();
 }
 
 void V4L2ImageProcessor::Destroy() {
   DVLOG(3) << __func__;
-  DCHECK(child_task_runner_->BelongsToCurrentThread());
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
 
   // If the device thread is running, destroy using posted task.
   if (device_thread_.IsRunning()) {
     device_thread_.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&V4L2ImageProcessor::DestroyTask, base::Unretained(this)));
     // Wait for tasks to finish/early-exit.
     device_thread_.Stop();
   } else {
     // Otherwise DestroyTask() is not needed.
     DCHECK(!device_poll_thread_.IsRunning());
     DCHECK(!device_weak_factory_.HasWeakPtrs());
   }
 
   delete this;
 }
 
 void V4L2ImageProcessor::DestroyTask() {
   DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
 
   device_weak_factory_.InvalidateWeakPtrs();
 
   // Stop streaming and the device_poll_thread_.
   StopDevicePoll();
 }
 
 bool V4L2ImageProcessor::CreateInputBuffers() {
   DVLOG(3) << __func__;
-  DCHECK(child_task_runner_->BelongsToCurrentThread());
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
 
   struct v4l2_control control;
   memset(&control, 0, sizeof(control));
   control.id = V4L2_CID_ROTATE;
   control.value = 0;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CTRL, &control);
 
   memset(&control, 0, sizeof(control));
   control.id = V4L2_CID_HFLIP;
@@ skipping 50 matching lines @@
   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 V4L2ImageProcessor::CreateOutputBuffers() {
   DVLOG(3) << __func__;
-  DCHECK(child_task_runner_->BelongsToCurrentThread());
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!output_streamon_);
 
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   format.fmt.pix_mp.width = output_allocated_size_.width();
   format.fmt.pix_mp.height = output_allocated_size_.height();
   format.fmt.pix_mp.pixelformat = output_format_fourcc_;
   format.fmt.pix_mp.num_planes = output_planes_count_;
   for (size_t i = 0; i < output_planes_count_; ++i) {
@@ skipping 42 matching lines @@
       IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_EXPBUF, &expbuf);
       output_record.fds[j] = expbuf.fd;
     }
     free_output_buffers_.push_back(i);
   }
 
   return true;
 }
 
 void V4L2ImageProcessor::DestroyInputBuffers() {
-  DCHECK(child_task_runner_->BelongsToCurrentThread());
+  DCHECK(child_message_loop_proxy_->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 = V4L2_MEMORY_USERPTR;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   input_buffer_map_.clear();
   free_input_buffers_.clear();
 }
 
 void V4L2ImageProcessor::DestroyOutputBuffers() {
-  DCHECK(child_task_runner_->BelongsToCurrentThread());
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!output_streamon_);
 
   for (size_t buf = 0; buf < output_buffer_map_.size(); ++buf) {
     OutputRecord& output_record = output_buffer_map_[buf];
     for (size_t plane = 0; plane < output_record.fds.size(); ++plane)
       close(output_record.fds[plane]);
     output_record.fds.clear();
   }
 
   struct v4l2_requestbuffers reqbufs;
@@ skipping 176 matching lines @@
             output_record.fds,
             job_record->frame->timestamp(),
             media::BindToCurrentLoop(
                 base::Bind(&V4L2ImageProcessor::ReuseOutputBuffer,
                            device_weak_factory_.GetWeakPtr(),
                            dqbuf.index)));
 
     DVLOG(3) << "Processing finished, returning frame, ts="
              << output_frame->timestamp().InMilliseconds();
 
-    child_task_runner_->PostTask(
+    child_message_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(job_record->ready_cb, output_frame));
   }
 }
 
 void V4L2ImageProcessor::ReuseOutputBuffer(int index) {
   DVLOG(3) << "Reusing output buffer, index=" << index;
   DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
 
   OutputRecord& output_record = output_buffer_map_[index];
   DCHECK(output_record.at_client);
@@ skipping 135 matching lines @@
     output_record.at_device = false;
     if (!output_record.at_client)
       free_output_buffers_.push_back(i);
   }
   output_buffer_queued_count_ = 0;
 
   return true;
 }
 
 }  // namespace content