media/gpu/V4L2VEA: Adapt V4L2 encode accelerator to use the V4L2 device poller.

The V4L2 encode accelerator currently has its own routines and thread to manage
polling the V4L2 device. This CL changes the encoder to make use of the V4L2
device poller that was introduced recently.

TEST=./video_encode_accelerator_unittest on hana

BUG=None

Change-Id: I7fb003ab3850c4a72b299a682a9a7f971777aa34
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1994545Reviewed-by: Alexandre Courbot <acourbot@chromium.org>
Commit-Queue: David Staessens <dstaessens@chromium.org>
Cr-Commit-Position: refs/heads/master@{#732748}

media/gpu/v4l2/v4l2_video_encode_accelerator.cc

@@ -168,8 +168,7 @@ V4L2VideoEncodeAccelerator::V4L2VideoEncodeAccelerator(
       // thread by V4L2DevicePoller.
       encoder_task_runner_(base::CreateSingleThreadTaskRunner(
           {base::ThreadPool(), base::WithBaseSyncPrimitives()},
-          base::SingleThreadTaskRunnerThreadMode::DEDICATED)),
-      device_poll_thread_("V4L2EncoderDevicePollThread") {
+          base::SingleThreadTaskRunnerThreadMode::DEDICATED)) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(child_sequence_checker_);
   DETACH_FROM_SEQUENCE(encoder_sequence_checker_);
 
@@ -178,7 +177,6 @@ V4L2VideoEncodeAccelerator::V4L2VideoEncodeAccelerator(
 
 V4L2VideoEncodeAccelerator::~V4L2VideoEncodeAccelerator() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(encoder_sequence_checker_);
-  DCHECK(!device_poll_thread_.IsRunning());
   VLOGF(2);
 }
 
@@ -816,7 +814,7 @@ void V4L2VideoEncodeAccelerator::DestroyTask() {
         FROM_HERE, base::BindOnce(std::move(flush_callback_), false));
   }
 
-  // Stop streaming and the device_poll_thread_.
+  // Stop streaming and the V4L2 device poller.
   StopDevicePoll();
 
   DestroyInputBuffers();
@@ -825,7 +823,7 @@ void V4L2VideoEncodeAccelerator::DestroyTask() {
   delete this;
 }
 
-void V4L2VideoEncodeAccelerator::ServiceDeviceTask() {
+void V4L2VideoEncodeAccelerator::ServiceDeviceTask(bool /*event*/) {
   DVLOGF(3);
   DCHECK_CALLED_ON_VALID_SEQUENCE(encoder_sequence_checker_);
   DCHECK_NE(encoder_state_, kUninitialized);
@@ -839,29 +837,6 @@ void V4L2VideoEncodeAccelerator::ServiceDeviceTask() {
   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_queue_->QueuedBuffersCount() +
-                          output_queue_->QueuedBuffersCount() >
-                      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_.task_runner());
-  // Queue the DevicePollTask() now.
-  // base::Unretained(this) is safe, because device_poll_thread_ is owned by
-  // *this and stops before *this destruction.
-  device_poll_thread_.task_runner()->PostTask(
-      FROM_HERE, base::BindOnce(&V4L2VideoEncodeAccelerator::DevicePollTask,
-                                base::Unretained(this), poll_device));
-
   DVLOGF(3) << encoder_input_queue_.size() << "] => DEVICE["
             << input_queue_->FreeBuffersCount() << "+"
             << input_queue_->QueuedBuffersCount() << "/"
@@ -918,10 +893,6 @@ void V4L2VideoEncodeAccelerator::Enqueue() {
       return;
   }
   if (old_inputs_queued == 0 && input_queue_->QueuedBuffersCount() != 0) {
-    // We just started up a previously empty queue.
-    // Queue state changed; signal interrupt.
-    if (!device_->SetDevicePollInterrupt())
-      return;
     // Shall call VIDIOC_STREAMON if we haven't yet.
     do_streamon = !input_queue_->IsStreaming();
   }
@@ -934,17 +905,10 @@ void V4L2VideoEncodeAccelerator::Enqueue() {
   }
 
   // Enqueue all the outputs we can.
-  const size_t old_outputs_queued = output_queue_->QueuedBuffersCount();
   while (auto output_buffer = output_queue_->GetFreeBuffer()) {
     if (!EnqueueOutputRecord(std::move(*output_buffer)))
       return;
   }
-  if (old_outputs_queued == 0 && output_queue_->QueuedBuffersCount() != 0) {
-    // We just started up a previously empty queue.
-    // Queue state changed; signal interrupt.
-    if (!device_->SetDevicePollInterrupt())
-      return;
-  }
 
   // STREAMON in CAPTURE queue first and then OUTPUT queue.
   // This is a workaround of a tegra driver bug that STREAMON in CAPTURE queue
@@ -1213,21 +1177,18 @@ bool V4L2VideoEncodeAccelerator::EnqueueOutputRecord(
 bool V4L2VideoEncodeAccelerator::StartDevicePoll() {
   DVLOGF(3);
   DCHECK_CALLED_ON_VALID_SEQUENCE(encoder_sequence_checker_);
-  DCHECK(!device_poll_thread_.IsRunning());
 
-  // Start up the device poll thread and schedule its first DevicePollTask().
-  if (!device_poll_thread_.Start()) {
+  // We need to make sure here not to use base::Unretained(this), as the
+  // |encoder_task_runner_| seems to outlive this class.
+  if (!device_->StartPolling(
+          base::BindRepeating(&V4L2VideoEncodeAccelerator::ServiceDeviceTask,
+                              weak_this_),
+          base::BindRepeating(&V4L2VideoEncodeAccelerator::OnPollError,
+                              weak_this_))) {
     VLOGF(1) << "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.
-  // base::Unretained(this) is safe, because device_poll_thread_ is owned by
-  // *this and stops before *this destruction.
-  device_poll_thread_.task_runner()->PostTask(
-      FROM_HERE, base::BindOnce(&V4L2VideoEncodeAccelerator::DevicePollTask,
-                                base::Unretained(this), false));
 
   return true;
 }
@@ -1236,12 +1197,7 @@ bool V4L2VideoEncodeAccelerator::StopDevicePoll() {
   DVLOGF(3);
   DCHECK_CALLED_ON_VALID_SEQUENCE(encoder_sequence_checker_);
 
-  // Signal the DevicePollTask() to stop, and stop the device poll thread.
-  if (!device_->SetDevicePollInterrupt())
-    return false;
-  device_poll_thread_.Stop();
-  // Clear the interrupt now, to be sure.
-  if (!device_->ClearDevicePollInterrupt())
+  if (!device_->StopPolling())
     return false;
 
   // Tegra driver cannot call Streamoff() when the stream is off, so we check
@@ -1267,21 +1223,8 @@ bool V4L2VideoEncodeAccelerator::StopDevicePoll() {
   return true;
 }
 
-void V4L2VideoEncodeAccelerator::DevicePollTask(bool poll_device) {
-  DVLOGF(4);
-  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_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&V4L2VideoEncodeAccelerator::ServiceDeviceTask,
-                                weak_this_));
+void V4L2VideoEncodeAccelerator::OnPollError() {
+  NOTIFY_ERROR(kPlatformFailureError);
 }
 
 void V4L2VideoEncodeAccelerator::NotifyError(Error error) {

media/gpu/v4l2/v4l2_video_encode_accelerator.h

@@ -145,9 +145,10 @@ class MEDIA_GPU_EXPORT V4L2VideoEncodeAccelerator
   // any error occurs, |flush_callback| will be called to notify client.
   void FlushTask(FlushCallback flush_callback);
 
-  // Service I/O on the V4L2 devices.  This task should only be scheduled from
-  // DevicePollTask().
-  void ServiceDeviceTask();
+  // Service I/O on the V4L2 devices, called by the V4L2 device poller on the
+  // |encoder_task_runner_|. |event| is set to true if a V4L2 event was
+  // detected.
+  void ServiceDeviceTask(bool event);
 
   // Handle the device queues.
   void Enqueue();
@@ -156,16 +157,13 @@ class MEDIA_GPU_EXPORT V4L2VideoEncodeAccelerator
   bool EnqueueInputRecord(V4L2WritableBufferRef input_buf);
   bool EnqueueOutputRecord(V4L2WritableBufferRef output_buf);
 
-  // Attempt to start/stop device_poll_thread_.
+  // Attempt to start/stop the V4L2 device poller.
   bool StartDevicePoll();
   bool StopDevicePoll();
 
-  //
-  // Device tasks, to be run on device_poll_thread_.
-  //
-
-  // The device task.
-  void DevicePollTask(bool poll_device);
+  // Called by the V4L2 device poller on the |encoder_task_runner_| whenever an
+  // error occurred.
+  void OnPollError();
 
   //
   // Safe from any thread.
@@ -338,10 +336,6 @@ class MEDIA_GPU_EXPORT V4L2VideoEncodeAccelerator
   const scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner_;
   SEQUENCE_CHECKER(encoder_sequence_checker_);
 
-  // The device polling thread handles notifications of V4L2 device changes.
-  // TODO(sheu): replace this thread with an TYPE_IO encoder_thread_.
-  base::Thread device_poll_thread_;
-
   // To expose client callbacks from VideoEncodeAccelerator.
   // NOTE: all calls to these objects *MUST* be executed on
   // |child_task_runner_|.