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 204 matching lines @@
           base::Bind(&V4L2VideoEncodeAccelerator::FrameProcessed,
                      base::Unretained(this), force_keyframe,
                      frame->timestamp()));
     } else {
       ImageProcessorInputRecord record;
       record.frame = frame;
       record.force_keyframe = force_keyframe;
       image_processor_input_queue_.push(record);
     }
   } else {
-    encoder_thread_.message_loop()->PostTask(
+    encoder_thread_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::EncodeTask,
                               base::Unretained(this), frame, force_keyframe));
   }
 }
 
 void V4L2VideoEncodeAccelerator::UseOutputBitstreamBuffer(
     const BitstreamBuffer& buffer) {
   DVLOG(3) << "UseOutputBitstreamBuffer(): id=" << buffer.id();
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (buffer.size() < output_buffer_byte_size_) {
     NOTIFY_ERROR(kInvalidArgumentError);
     return;
   }
 
   std::unique_ptr<SharedMemoryRegion> shm(
       new SharedMemoryRegion(buffer, false));
   if (!shm->Map()) {
     NOTIFY_ERROR(kPlatformFailureError);
     return;
   }
 
   std::unique_ptr<BitstreamBufferRef> buffer_ref(
       new BitstreamBufferRef(buffer.id(), std::move(shm)));
-  encoder_thread_.message_loop()->PostTask(
+  encoder_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&V4L2VideoEncodeAccelerator::UseOutputBitstreamBufferTask,
                  base::Unretained(this), base::Passed(&buffer_ref)));
 }
 
 void V4L2VideoEncodeAccelerator::RequestEncodingParametersChange(
     uint32_t bitrate,
     uint32_t framerate) {
   DVLOG(3) << "RequestEncodingParametersChange(): bitrate=" << bitrate
            << ", framerate=" << framerate;
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
-  encoder_thread_.message_loop()->PostTask(
+  encoder_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(
           &V4L2VideoEncodeAccelerator::RequestEncodingParametersChangeTask,
           base::Unretained(this), bitrate, framerate));
 }
 
 void V4L2VideoEncodeAccelerator::Destroy() {
   DVLOG(3) << "Destroy()";
   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()) {
-    encoder_thread_.message_loop()->PostTask(
+    encoder_thread_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::DestroyTask,
                               base::Unretained(this)));
     // DestroyTask() will put the encoder into kError state and cause all tasks
     // to no-op.
     encoder_thread_.Stop();
   } else {
     // Otherwise, call the destroy task directly.
     DestroyTask();
   }
 
@@ skipping 62 matching lines @@
       device_input_format_, image_processor_->output_allocated_size(),
       gfx::Rect(visible_size_), visible_size_, fds, timestamp);
   if (!output_frame) {
     NOTIFY_ERROR(kPlatformFailureError);
     return;
   }
   output_frame->AddDestructionObserver(BindToCurrentLoop(
       base::Bind(&V4L2VideoEncodeAccelerator::ReuseImageProcessorOutputBuffer,
                  weak_this_, output_buffer_index)));
 
-  encoder_thread_.message_loop()->PostTask(
+  encoder_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&V4L2VideoEncodeAccelerator::EncodeTask,
                  base::Unretained(this), output_frame, force_keyframe));
 }
 
 void V4L2VideoEncodeAccelerator::ReuseImageProcessorOutputBuffer(
     int output_buffer_index) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DVLOG(3) << __func__ << ": output_buffer_index=" << output_buffer_index;
   free_image_processor_output_buffers_.push_back(output_buffer_index);
   if (!image_processor_input_queue_.empty()) {
     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();
 
   // Clear the interrupt fd.
   if (!device_->ClearDevicePollInterrupt())
     return;
 
   // Device can be polled as soon as either input or output buffers are queued.
   bool poll_device =
       (input_buffer_queued_count_ + output_buffer_queued_count_ > 0);
 
   // ServiceDeviceTask() should only ever be scheduled from DevicePollTask(),
   // so either:
   // * device_poll_thread_ is running normally
   // * device_poll_thread_ scheduled us, but then a DestroyTask() shut it down,
   //   in which case we're in kError state, and we should have early-outed
   //   already.
   DCHECK(device_poll_thread_.message_loop());
   // Queue the DevicePollTask() now.
-  device_poll_thread_.message_loop()->PostTask(
+  device_poll_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::DevicePollTask,
                             base::Unretained(this), poll_device));
 
   DVLOG(2) << __func__ << ": buffer counts: ENC["
            << encoder_input_queue_.size() << "] => DEVICE["
            << 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.
-  device_poll_thread_.message_loop()->PostTask(
+  device_poll_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::DevicePollTask,
                             base::Unretained(this), false));
 
   return true;
 }
 
 bool V4L2VideoEncodeAccelerator::StopDevicePoll() {
   DVLOG(3) << "StopDevicePoll()";
 
   // Signal the DevicePollTask() to stop, and stop the device poll thread.
@@ skipping 38 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(
+  encoder_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::ServiceDeviceTask,
                             base::Unretained(this)));
 }
 
 void V4L2VideoEncodeAccelerator::NotifyError(Error error) {
   DVLOG(1) << "NotifyError(): error=" << 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) {
   // We can touch encoder_state_ only if this is the encoder thread or the
   // encoder thread isn't running.
-  if (encoder_thread_.message_loop() != NULL &&
-      encoder_thread_.message_loop() != base::MessageLoop::current()) {
-    encoder_thread_.message_loop()->PostTask(
-        FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::SetErrorState,
-                              base::Unretained(this), error));
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner =
+      encoder_thread_.task_runner();
+  if (task_runner && !task_runner->BelongsToCurrentThread()) {
+    task_runner->PostTask(FROM_HERE,
+                          base::Bind(&V4L2VideoEncodeAccelerator::SetErrorState,
+                                     base::Unretained(this), error));
     return;
   }
 
   // Post NotifyError only if we are already initialized, as the API does
   // not allow doing so before that.
   if (encoder_state_ != kError && encoder_state_ != kUninitialized)
     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