Remove calls to MessageLoop::current() in media.

media/gpu/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 "media/gpu/v4l2_video_encode_accelerator.h"
 
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/gpu/shared_memory_region.h"
 
 #define NOTIFY_ERROR(x)                        \
   do {                                         \
     LOG(ERROR) << "Setting error state:" << x; \
     SetErrorState(x);                          \
@@ skipping 367 matching lines @@
     ImageProcessorInputRecord record = image_processor_input_queue_.front();
     image_processor_input_queue_.pop();
     Encode(record.frame, record.force_keyframe);
   }
 }
 
 void V4L2VideoEncodeAccelerator::EncodeTask(
     const scoped_refptr<VideoFrame>& frame,
     bool force_keyframe) {
   DVLOG(3) << "EncodeTask(): force_keyframe=" << force_keyframe;
-  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(encoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_NE(encoder_state_, kUninitialized);
 
   if (encoder_state_ == kError) {
     DVLOG(2) << "EncodeTask(): early out: kError state";
     return;
   }
 
   encoder_input_queue_.push(frame);
   Enqueue();
 
@@ skipping 22 matching lines @@
         NOTIFY_ERROR(kPlatformFailureError);
         return;
       }
     }
   }
 }
 
 void V4L2VideoEncodeAccelerator::UseOutputBitstreamBufferTask(
     std::unique_ptr<BitstreamBufferRef> buffer_ref) {
   DVLOG(3) << "UseOutputBitstreamBufferTask(): id=" << buffer_ref->id;
-  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(encoder_thread_.task_runner()->BelongsToCurrentThread());
 
   encoder_output_queue_.push_back(
       linked_ptr<BitstreamBufferRef>(buffer_ref.release()));
   Enqueue();
 
   if (encoder_state_ == kInitialized) {
     // Finish setting up our OUTPUT queue.  See: Initialize().
     // VIDIOC_REQBUFS on OUTPUT queue.
     if (!CreateInputBuffers())
       return;
@@ skipping 10 matching lines @@
 
   // Stop streaming and the device_poll_thread_.
   StopDevicePoll();
 
   // Set our state to kError, and early-out all tasks.
   encoder_state_ = kError;
 }
 
 void V4L2VideoEncodeAccelerator::ServiceDeviceTask() {
   DVLOG(3) << "ServiceDeviceTask()";
-  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(encoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_NE(encoder_state_, kUninitialized);
   DCHECK_NE(encoder_state_, kInitialized);
 
   if (encoder_state_ == kError) {
     DVLOG(2) << "ServiceDeviceTask(): early out: kError state";
     return;
   }
 
   Dequeue();
   Enqueue();
@@ skipping 23 matching lines @@
            << free_input_buffers_.size() << "+"
            << input_buffer_queued_count_ << "/"
            << input_buffer_map_.size() << "->"
            << free_output_buffers_.size() << "+"
            << output_buffer_queued_count_ << "/"
            << output_buffer_map_.size() << "] => OUT["
            << encoder_output_queue_.size() << "]";
 }
 
 void V4L2VideoEncodeAccelerator::Enqueue() {
-  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(encoder_thread_.task_runner()->BelongsToCurrentThread());
 
   DVLOG(3) << "Enqueue() "
            << "free_input_buffers: " << free_input_buffers_.size()
            << "input_queue: " << encoder_input_queue_.size();
 
   // Enqueue all the inputs we can.
   const int old_inputs_queued = input_buffer_queued_count_;
   // while (!ready_input_buffers_.empty()) {
   while (!encoder_input_queue_.empty() && !free_input_buffers_.empty()) {
     if (!EnqueueInputRecord())
@@ skipping 27 matching lines @@
     if (!output_streamon_) {
       __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
       IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMON, &type);
       output_streamon_ = true;
     }
   }
 }
 
 void V4L2VideoEncodeAccelerator::Dequeue() {
   DVLOG(3) << "Dequeue()";
-  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(encoder_thread_.task_runner()->BelongsToCurrentThread());
 
   // Dequeue completed input (VIDEO_OUTPUT) buffers, and recycle to the free
   // list.
   struct v4l2_buffer dqbuf;
   struct v4l2_plane planes[VIDEO_MAX_PLANES];
   while (input_buffer_queued_count_ > 0) {
     DVLOG(4) << "inputs queued: " << input_buffer_queued_count_;
     DCHECK(input_streamon_);
     memset(&dqbuf, 0, sizeof(dqbuf));
     memset(&planes, 0, sizeof(planes));
@@ skipping 174 matching lines @@
   output_record.at_device = true;
   output_record.buffer_ref = output_buffer;
   encoder_output_queue_.pop_back();
   free_output_buffers_.pop_back();
   output_buffer_queued_count_++;
   return true;
 }
 
 bool V4L2VideoEncodeAccelerator::StartDevicePoll() {
   DVLOG(3) << "StartDevicePoll()";
-  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(encoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK(!device_poll_thread_.IsRunning());
 
   // Start up the device poll thread and schedule its first DevicePollTask().
   if (!device_poll_thread_.Start()) {
     LOG(ERROR) << "StartDevicePoll(): Device thread failed to start";
     NOTIFY_ERROR(kPlatformFailureError);
     return false;
   }
   // Enqueue a poll task with no devices to poll on -- it will wait only on the
   // interrupt fd.
@@ skipping 49 matching lines @@
   output_buffer_queued_count_ = 0;
 
   encoder_output_queue_.clear();
 
   DVLOG(3) << "StopDevicePoll(): device poll stopped";
   return true;
 }
 
 void V4L2VideoEncodeAccelerator::DevicePollTask(bool poll_device) {
   DVLOG(3) << "DevicePollTask()";
-  DCHECK_EQ(device_poll_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(device_poll_thread_.task_runner()->BelongsToCurrentThread());
 
   bool event_pending;
   if (!device_->Poll(poll_device, &event_pending)) {
     NOTIFY_ERROR(kPlatformFailureError);
     return;
   }
 
   // All processing should happen on ServiceDeviceTask(), since we shouldn't
   // touch encoder state from this thread.
   encoder_thread_.message_loop()->PostTask(
@@ skipping 34 matching lines @@
     NotifyError(error);
 
   encoder_state_ = kError;
 }
 
 void V4L2VideoEncodeAccelerator::RequestEncodingParametersChangeTask(
     uint32_t bitrate,
     uint32_t framerate) {
   DVLOG(3) << "RequestEncodingParametersChangeTask(): bitrate=" << bitrate
            << ", framerate=" << framerate;
-  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(encoder_thread_.task_runner()->BelongsToCurrentThread());
 
   if (bitrate < 1)
     bitrate = 1;
   if (framerate < 1)
     framerate = 1;
 
   std::vector<struct v4l2_ext_control> ctrls;
   struct v4l2_ext_control ctrl;
   memset(&ctrl, 0, sizeof(ctrl));
   ctrl.id = V4L2_CID_MPEG_VIDEO_BITRATE;
@@ skipping 234 matching lines @@
   // Ignore return value as these controls are optional.
   SetExtCtrls(ctrls);
 
   return true;
 }
 
 bool V4L2VideoEncodeAccelerator::CreateInputBuffers() {
   DVLOG(3) << "CreateInputBuffers()";
   // This function runs on encoder_thread_ after output buffers have been
   // provided by the client.
-  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(encoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   // Driver will modify to the appropriate number of buffers.
   reqbufs.count = 1;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   // TODO(posciak): Once we start doing zero-copy, we should decide based on
   // the current pipeline setup which memory type to use. This should probably
   // be decided based on an argument to Initialize().
@@ skipping 87 matching lines @@
   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 media