Remove calls to deprecated MessageLoop methods on Windows and Linux.

media/gpu/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 <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
 #include <sys/eventfd.h>
@@ skipping 132 matching lines @@
 
   if (!CreateInputBuffers() || !CreateOutputBuffers())
     return false;
 
   if (!device_thread_.Start()) {
     LOG(ERROR) << "Initialize(): encoder thread failed to start";
     return false;
   }
 
   // StartDevicePoll will NotifyError on failure, so IgnoreResult is fine here.
-  device_thread_.message_loop()->PostTask(
+  device_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(&V4L2ImageProcessor::StartDevicePoll),
                  base::Unretained(this)));
 
   DVLOG(1) << "V4L2ImageProcessor initialized for "
            << " input_format:" << VideoPixelFormatToString(input_format)
            << ", output_format:" << VideoPixelFormatToString(output_format)
            << ", input_visible_size: " << input_visible_size.ToString()
            << ", input_allocated_size: " << input_allocated_size_.ToString()
            << ", input_planes_count: " << input_planes_count_
@@ skipping 57 matching lines @@
 void V4L2ImageProcessor::Process(const scoped_refptr<VideoFrame>& frame,
                                  int output_buffer_index,
                                  const FrameReadyCB& cb) {
   DVLOG(3) << __func__ << ": ts=" << frame->timestamp().InMilliseconds();
 
   std::unique_ptr<JobRecord> job_record(new JobRecord());
   job_record->frame = frame;
   job_record->output_buffer_index = output_buffer_index;
   job_record->ready_cb = cb;
 
-  device_thread_.message_loop()->PostTask(
+  device_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&V4L2ImageProcessor::ProcessTask,
                             base::Unretained(this), base::Passed(&job_record)));
 }
 
 void V4L2ImageProcessor::ProcessTask(std::unique_ptr<JobRecord> job_record) {
   int index = job_record->output_buffer_index;
   DVLOG(3) << __func__ << ": Reusing output buffer, index=" << index;
   DCHECK(device_thread_.task_runner()->BelongsToCurrentThread());
 
   EnqueueOutput(index);
   input_queue_.push(make_linked_ptr(job_record.release()));
   EnqueueInput();
 }
 
 void V4L2ImageProcessor::Destroy() {
   DVLOG(3) << __func__;
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   weak_this_factory_.InvalidateWeakPtrs();
 
   // If the device thread is running, destroy using posted task.
   if (device_thread_.IsRunning()) {
-    device_thread_.message_loop()->PostTask(
+    device_thread_.task_runner()->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());
   }
 
   delete this;
@@ skipping 157 matching lines @@
   DCHECK(device_poll_thread_.task_runner()->BelongsToCurrentThread());
 
   bool event_pending;
   if (!device_->Poll(poll_device, &event_pending)) {
     NotifyError();
     return;
   }
 
   // All processing should happen on ServiceDeviceTask(), since we shouldn't
   // touch encoder state from this thread.
-  device_thread_.message_loop()->PostTask(
+  device_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&V4L2ImageProcessor::ServiceDeviceTask,
                             base::Unretained(this)));
 }
 
 void V4L2ImageProcessor::ServiceDeviceTask() {
   DCHECK(device_thread_.task_runner()->BelongsToCurrentThread());
   // 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 should early-out.
   if (!device_poll_thread_.message_loop())
     return;
 
   Dequeue();
   EnqueueInput();
 
   if (!device_->ClearDevicePollInterrupt())
     return;
 
   bool poll_device =
       (input_buffer_queued_count_ > 0 || output_buffer_queued_count_ > 0);
 
-  device_poll_thread_.message_loop()->PostTask(
+  device_poll_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&V4L2ImageProcessor::DevicePollTask,
                             base::Unretained(this), poll_device));
 
   DVLOG(2) << __func__ << ": buffer counts: INPUT[" << input_queue_.size()
            << "] => DEVICE[" << free_input_buffers_.size() << "+"
            << input_buffer_queued_count_ << "/" << input_buffer_map_.size()
            << "->" << output_buffer_map_.size() - output_buffer_queued_count_
            << "+" << output_buffer_queued_count_ << "/"
            << output_buffer_map_.size() << "]";
 }
@@ skipping 182 matching lines @@
   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";
     NotifyError();
     return false;
   }
   // Enqueue a poll task with no devices to poll on - will wait only for the
   // poll interrupt
-  device_poll_thread_.message_loop()->PostTask(
+  device_poll_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&V4L2ImageProcessor::DevicePollTask,
                             base::Unretained(this), false));
 
   return true;
 }
 
 bool V4L2ImageProcessor::StopDevicePoll() {
   DVLOG(3) << __func__ << ": stopping device poll";
   if (device_thread_.IsRunning())
     DCHECK(device_thread_.task_runner()->BelongsToCurrentThread());
@@ skipping 42 matching lines @@
   return true;
 }
 
 void V4L2ImageProcessor::FrameReady(const FrameReadyCB& cb,
                                     int output_buffer_index) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   cb.Run(output_buffer_index);
 }
 
 }  // namespace media