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

media/gpu/v4l2_video_decode_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_decode_accelerator.h"
 
 #include <dlfcn.h>
 #include <errno.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.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 "build/build_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/media_switches.h"
 #include "media/filters/h264_parser.h"
 #include "media/gpu/shared_memory_region.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/scoped_binders.h"
@@ skipping 497 matching lines @@
   if (!device)
     return SupportedProfiles();
 
   return device->GetSupportedDecodeProfiles(arraysize(supported_input_fourccs_),
                                             supported_input_fourccs_);
 }
 
 void V4L2VideoDecodeAccelerator::DecodeTask(
     const BitstreamBuffer& bitstream_buffer) {
   DVLOGF(3) << "input_id=" << bitstream_buffer.id();
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_NE(decoder_state_, kUninitialized);
   TRACE_EVENT1("Video Decoder", "V4L2VDA::DecodeTask", "input_id",
                bitstream_buffer.id());
 
   std::unique_ptr<BitstreamBufferRef> bitstream_record(new BitstreamBufferRef(
       decode_client_, decode_task_runner_,
       std::unique_ptr<SharedMemoryRegion>(
           new SharedMemoryRegion(bitstream_buffer, true)),
       bitstream_buffer.id()));
 
@@ skipping 22 matching lines @@
   }
 
   decoder_input_queue_.push(
       linked_ptr<BitstreamBufferRef>(bitstream_record.release()));
   decoder_decode_buffer_tasks_scheduled_++;
   DecodeBufferTask();
 }
 
 void V4L2VideoDecodeAccelerator::DecodeBufferTask() {
   DVLOGF(3);
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_NE(decoder_state_, kUninitialized);
   TRACE_EVENT0("Video Decoder", "V4L2VDA::DecodeBufferTask");
 
   decoder_decode_buffer_tasks_scheduled_--;
 
   if (decoder_state_ == kResetting) {
     DVLOGF(2) << "early out: kResetting state";
     return;
   } else if (decoder_state_ == kError) {
     DVLOGF(2) << "early out: kError state";
@@ skipping 181 matching lines @@
     DCHECK_LE(video_profile_, VP9PROFILE_MAX);
     // For VP8/9, we can just dump the entire buffer.  No fragmentation needed,
     // and we never return a partial frame.
     *endpos = size;
     decoder_partial_frame_pending_ = false;
     return true;
   }
 }
 
 void V4L2VideoDecodeAccelerator::ScheduleDecodeBufferTaskIfNeeded() {
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   // If we're behind on tasks, schedule another one.
   int buffers_to_decode = decoder_input_queue_.size();
   if (decoder_current_bitstream_buffer_ != NULL)
     buffers_to_decode++;
   if (decoder_decode_buffer_tasks_scheduled_ < buffers_to_decode) {
     decoder_decode_buffer_tasks_scheduled_++;
     decoder_thread_.message_loop()->PostTask(
         FROM_HERE, base::Bind(&V4L2VideoDecodeAccelerator::DecodeBufferTask,
                               base::Unretained(this)));
   }
 }
 
 bool V4L2VideoDecodeAccelerator::DecodeBufferInitial(const void* data,
                                                      size_t size,
                                                      size_t* endpos) {
   DVLOGF(3) << "data=" << data << ", size=" << size;
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_NE(decoder_state_, kUninitialized);
   DCHECK_NE(decoder_state_, kDecoding);
   // Initial decode.  We haven't been able to get output stream format info yet.
   // Get it, and start decoding.
 
   // Copy in and send to HW.
   if (!AppendToInputFrame(data, size))
     return false;
 
   // If we only have a partial frame, don't flush and process yet.
@@ skipping 29 matching lines @@
   }
 
   decoder_state_ = kDecoding;
   ScheduleDecodeBufferTaskIfNeeded();
   return true;
 }
 
 bool V4L2VideoDecodeAccelerator::DecodeBufferContinue(const void* data,
                                                       size_t size) {
   DVLOGF(3) << "data=" << data << ", size=" << size;
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_EQ(decoder_state_, kDecoding);
 
   // Both of these calls will set kError state if they fail.
   // Only flush the frame if it's complete.
   return (AppendToInputFrame(data, size) &&
           (decoder_partial_frame_pending_ || FlushInputFrame()));
 }
 
 bool V4L2VideoDecodeAccelerator::AppendToInputFrame(const void* data,
                                                     size_t size) {
   DVLOGF(3);
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_NE(decoder_state_, kUninitialized);
   DCHECK_NE(decoder_state_, kResetting);
   DCHECK_NE(decoder_state_, kError);
   // This routine can handle data == NULL and size == 0, which occurs when
   // we queue an empty buffer for the purposes of flushing the pipe.
 
   // Flush if we're too big
   if (decoder_current_input_buffer_ != -1) {
     InputRecord& input_record =
         input_buffer_map_[decoder_current_input_buffer_];
@@ skipping 43 matching lines @@
   memcpy(reinterpret_cast<uint8_t*>(input_record.address) +
              input_record.bytes_used,
          data, size);
   input_record.bytes_used += size;
 
   return true;
 }
 
 bool V4L2VideoDecodeAccelerator::FlushInputFrame() {
   DVLOGF(3);
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_NE(decoder_state_, kUninitialized);
   DCHECK_NE(decoder_state_, kResetting);
   DCHECK_NE(decoder_state_, kError);
 
   if (decoder_current_input_buffer_ == -1)
     return true;
 
   InputRecord& input_record = input_buffer_map_[decoder_current_input_buffer_];
   DCHECK_NE(input_record.input_id, -1);
   DCHECK(input_record.input_id != kFlushBufferId ||
@@ skipping 15 matching lines @@
   decoder_current_input_buffer_ = -1;
   DVLOGF(3) << "submitting input_id=" << input_record.input_id;
   // Enqueue once since there's new available input for it.
   Enqueue();
 
   return (decoder_state_ != kError);
 }
 
 void V4L2VideoDecodeAccelerator::ServiceDeviceTask(bool event_pending) {
   DVLOGF(3);
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_NE(decoder_state_, kUninitialized);
   TRACE_EVENT0("Video Decoder", "V4L2VDA::ServiceDeviceTask");
 
   if (decoder_state_ == kResetting) {
     DVLOGF(2) << "early out: kResetting state";
     return;
   } else if (decoder_state_ == kError) {
     DVLOGF(2) << "early out: kError state";
     return;
   } else if (decoder_state_ == kChangingResolution) {
@@ skipping 43 matching lines @@
            << image_processor_bitstream_buffer_ids_.size() << "] => CLIENT["
            << decoder_frames_at_client_ << "]";
 
   ScheduleDecodeBufferTaskIfNeeded();
   if (resolution_change_pending)
     StartResolutionChange();
 }
 
 void V4L2VideoDecodeAccelerator::Enqueue() {
   DVLOGF(3);
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_NE(decoder_state_, kUninitialized);
   TRACE_EVENT0("Video Decoder", "V4L2VDA::Enqueue");
 
   // Drain the pipe of completed decode buffers.
   const int old_inputs_queued = input_buffer_queued_count_;
   while (!input_ready_queue_.empty()) {
     if (!EnqueueInputRecord())
       return;
   }
   if (old_inputs_queued == 0 && input_buffer_queued_count_ != 0) {
@@ skipping 29 matching lines @@
     // Start VIDIOC_STREAMON if we haven't yet.
     if (!output_streamon_) {
       __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
       IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMON, &type);
       output_streamon_ = true;
     }
   }
 }
 
 bool V4L2VideoDecodeAccelerator::DequeueResolutionChangeEvent() {
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_NE(decoder_state_, kUninitialized);
   DVLOGF(3);
 
   struct v4l2_event ev;
   memset(&ev, 0, sizeof(ev));
 
   while (device_->Ioctl(VIDIOC_DQEVENT, &ev) == 0) {
     if (ev.type == V4L2_EVENT_SOURCE_CHANGE) {
       if (ev.u.src_change.changes & V4L2_EVENT_SRC_CH_RESOLUTION) {
         DVLOGF(3) << "got resolution change event.";
         return true;
       }
     } else {
       LOGF(ERROR) << "got an event (" << ev.type
                   << ") we haven't subscribed to.";
     }
   }
   return false;
 }
 
 void V4L2VideoDecodeAccelerator::Dequeue() {
   DVLOGF(3);
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_NE(decoder_state_, kUninitialized);
   TRACE_EVENT0("Video Decoder", "V4L2VDA::Dequeue");
 
   // Dequeue completed input (VIDEO_OUTPUT) buffers, and recycle to the free
   // list.
   while (input_buffer_queued_count_ > 0) {
     DCHECK(input_streamon_);
     struct v4l2_buffer dqbuf;
     struct v4l2_plane planes[1];
     memset(&dqbuf, 0, sizeof(dqbuf));
@@ skipping 163 matching lines @@
   free_output_buffers_.pop();
   output_record.state = kAtDevice;
   output_buffer_queued_count_++;
   return true;
 }
 
 void V4L2VideoDecodeAccelerator::ReusePictureBufferTask(
     int32_t picture_buffer_id,
     std::unique_ptr<EGLSyncKHRRef> egl_sync_ref) {
   DVLOGF(3) << "picture_buffer_id=" << picture_buffer_id;
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   TRACE_EVENT0("Video Decoder", "V4L2VDA::ReusePictureBufferTask");
 
   // We run ReusePictureBufferTask even if we're in kResetting.
   if (decoder_state_ == kError) {
     DVLOGF(2) << "early out: kError state";
     return;
   }
 
   if (decoder_state_ == kChangingResolution) {
     DVLOGF(2) << "early out: kChangingResolution";
@@ skipping 29 matching lines @@
   free_output_buffers_.push(index);
   decoder_frames_at_client_--;
   // Take ownership of the EGLSync.
   egl_sync_ref->egl_sync = EGL_NO_SYNC_KHR;
   // We got a buffer back, so enqueue it back.
   Enqueue();
 }
 
 void V4L2VideoDecodeAccelerator::FlushTask() {
   DVLOGF(3);
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   TRACE_EVENT0("Video Decoder", "V4L2VDA::FlushTask");
 
   // Flush outstanding buffers.
   if (decoder_state_ == kInitialized || decoder_state_ == kAfterReset) {
     // There's nothing in the pipe, so return done immediately.
     DVLOGF(3) << "returning flush";
     child_task_runner_->PostTask(FROM_HERE,
                                  base::Bind(&Client::NotifyFlushDone, client_));
     return;
   } else if (decoder_state_ == kError) {
     DVLOGF(2) << "early out: kError state";
     return;
   }
 
   // We don't support stacked flushing.
   DCHECK(!decoder_flushing_);
 
   // Queue up an empty buffer -- this triggers the flush.
   decoder_input_queue_.push(
       linked_ptr<BitstreamBufferRef>(new BitstreamBufferRef(
           decode_client_, decode_task_runner_, nullptr, kFlushBufferId)));
   decoder_flushing_ = true;
   SendPictureReady();  // Send all pending PictureReady.
 
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 void V4L2VideoDecodeAccelerator::NotifyFlushDoneIfNeeded() {
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   if (!decoder_flushing_)
     return;
 
   // Pipeline is empty when:
   // * Decoder input queue is empty of non-delayed buffers.
   // * There is no currently filling input buffer.
   // * Input holding queue is empty.
   // * All input (VIDEO_OUTPUT) buffers are returned.
   // * All image processor buffers are returned.
   if (!decoder_input_queue_.empty()) {
@@ skipping 28 matching lines @@
   DVLOGF(3) << "returning flush";
   child_task_runner_->PostTask(FROM_HERE,
                                base::Bind(&Client::NotifyFlushDone, client_));
 
   // While we were flushing, we early-outed DecodeBufferTask()s.
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 void V4L2VideoDecodeAccelerator::ResetTask() {
   DVLOGF(3);
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   TRACE_EVENT0("Video Decoder", "V4L2VDA::ResetTask");
 
   if (decoder_state_ == kError) {
     DVLOGF(2) << "early out: kError state";
     return;
   }
 
   // If we are in the middle of switching resolutions, postpone reset until
   // it's done. We don't have to worry about timing of this wrt to decoding,
   // because output pipe is already stopped if we are changing resolution.
@@ skipping 39 matching lines @@
   // jobs will early-out in the kResetting state.
   decoder_state_ = kResetting;
   SendPictureReady();  // Send all pending PictureReady.
   decoder_thread_.message_loop()->PostTask(
       FROM_HERE, base::Bind(&V4L2VideoDecodeAccelerator::ResetDoneTask,
                             base::Unretained(this)));
 }
 
 void V4L2VideoDecodeAccelerator::ResetDoneTask() {
   DVLOGF(3);
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   TRACE_EVENT0("Video Decoder", "V4L2VDA::ResetDoneTask");
 
   if (decoder_state_ == kError) {
     DVLOGF(2) << "early out: kError state";
     return;
   }
 
   if (!StartDevicePoll())
     return;
 
@@ skipping 39 matching lines @@
     decoder_input_queue_.pop();
   decoder_flushing_ = false;
 
   // Set our state to kError.  Just in case.
   decoder_state_ = kError;
 }
 
 bool V4L2VideoDecodeAccelerator::StartDevicePoll() {
   DVLOGF(3);
   DCHECK(!device_poll_thread_.IsRunning());
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   // Start up the device poll thread and schedule its first DevicePollTask().
   if (!device_poll_thread_.Start()) {
     LOGF(ERROR) << "Device thread failed to start";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return false;
   }
   device_poll_thread_.message_loop()->PostTask(
       FROM_HERE, base::Bind(&V4L2VideoDecodeAccelerator::DevicePollTask,
                             base::Unretained(this), 0));
 
   return true;
 }
 
 bool V4L2VideoDecodeAccelerator::StopDevicePoll() {
   DVLOGF(3);
 
   if (!device_poll_thread_.IsRunning())
     return true;
 
   if (decoder_thread_.IsRunning())
-    DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+    DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   // Signal the DevicePollTask() to stop, and stop the device poll thread.
   if (!device_->SetDevicePollInterrupt()) {
     PLOGF(ERROR) << "SetDevicePollInterrupt(): failed";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return false;
   }
   device_poll_thread_.Stop();
   // Clear the interrupt now, to be sure.
   if (!device_->ClearDevicePollInterrupt()) {
@@ skipping 46 matching lines @@
     input_buffer_map_[i].at_device = false;
     input_buffer_map_[i].bytes_used = 0;
     input_buffer_map_[i].input_id = -1;
   }
   input_buffer_queued_count_ = 0;
 
   return true;
 }
 
 void V4L2VideoDecodeAccelerator::StartResolutionChange() {
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_NE(decoder_state_, kUninitialized);
   DCHECK_NE(decoder_state_, kResetting);
 
   DVLOGF(3) << "Initiate resolution change";
 
   if (!(StopDevicePoll() && StopOutputStream()))
     return;
 
   decoder_state_ = kChangingResolution;
 
   if (!image_processor_bitstream_buffer_ids_.empty()) {
     DVLOGF(3) << "Wait image processor to finish before destroying buffers.";
     return;
   }
 
   // Post a task to clean up buffers on child thread. This will also ensure
   // that we won't accept ReusePictureBuffer() anymore after that.
   child_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&V4L2VideoDecodeAccelerator::ResolutionChangeDestroyBuffers,
                  weak_this_));
 }
 
 void V4L2VideoDecodeAccelerator::FinishResolutionChange() {
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_EQ(decoder_state_, kChangingResolution);
   DVLOGF(3);
 
   if (decoder_state_ == kError) {
     DVLOGF(2) << "early out: kError state";
     return;
   }
 
   struct v4l2_format format;
   bool again;
@@ skipping 21 matching lines @@
 
   if (!StartDevicePoll())
     return;
 
   Enqueue();
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 void V4L2VideoDecodeAccelerator::DevicePollTask(bool poll_device) {
   DVLOGF(3);
-  DCHECK_EQ(device_poll_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(device_poll_thread_.task_runner()->BelongsToCurrentThread());
   TRACE_EVENT0("Video Decoder", "V4L2VDA::DevicePollTask");
 
   bool event_pending = false;
 
   if (!device_->Poll(poll_device, &event_pending)) {
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   // All processing should happen on ServiceDeviceTask(), since we shouldn't
@@ skipping 15 matching lines @@
 
   if (client_) {
     client_->NotifyError(error);
     client_ptr_factory_.reset();
   }
 }
 
 void V4L2VideoDecodeAccelerator::SetErrorState(Error error) {
   // We can touch decoder_state_ only if this is the decoder thread or the
   // decoder thread isn't running.
-  if (decoder_thread_.message_loop() != NULL &&
-      decoder_thread_.message_loop() != base::MessageLoop::current()) {
-    decoder_thread_.message_loop()->PostTask(
+  if (decoder_thread_.task_runner() &&
+      !decoder_thread_.task_runner()->BelongsToCurrentThread()) {
+    decoder_thread_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&V4L2VideoDecodeAccelerator::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 (decoder_state_ != kError && decoder_state_ != kUninitialized)
     NotifyError(error);
 
   decoder_state_ = kError;
 }
 
 bool V4L2VideoDecodeAccelerator::GetFormatInfo(struct v4l2_format* format,
                                                gfx::Size* visible_size,
                                                bool* again) {
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   *again = false;
   memset(format, 0, sizeof(*format));
   format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   if (device_->Ioctl(VIDIOC_G_FMT, format) != 0) {
     if (errno == EINVAL) {
       // EINVAL means we haven't seen sufficient stream to decode the format.
       *again = true;
       return true;
     } else {
@@ skipping 12 matching lines @@
   gfx::Size coded_size(format->fmt.pix_mp.width, format->fmt.pix_mp.height);
   if (visible_size != nullptr)
     *visible_size = GetVisibleSize(coded_size);
 
   return true;
 }
 
 bool V4L2VideoDecodeAccelerator::CreateBuffersForFormat(
     const struct v4l2_format& format,
     const gfx::Size& visible_size) {
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   output_planes_count_ = format.fmt.pix_mp.num_planes;
   coded_size_.SetSize(format.fmt.pix_mp.width, format.fmt.pix_mp.height);
   visible_size_ = visible_size;
   if (image_processor_device_) {
     V4L2ImageProcessor processor(image_processor_device_);
     egl_image_size_ = visible_size_;
     egl_image_planes_count_ = 0;
     if (!processor.TryOutputFormat(egl_image_format_fourcc_, &egl_image_size_,
                                    &egl_image_planes_count_)) {
       LOGF(ERROR) << "Fail to get output size and plane count of processor";
       return false;
     }
   } else {
     egl_image_size_ = coded_size_;
     egl_image_planes_count_ = output_planes_count_;
   }
   DVLOGF(3) << "new resolution: " << coded_size_.ToString()
             << ", visible size: " << visible_size_.ToString()
             << ", EGLImage size: " << egl_image_size_.ToString();
 
   return CreateOutputBuffers();
 }
 
 gfx::Size V4L2VideoDecodeAccelerator::GetVisibleSize(
     const gfx::Size& coded_size) {
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   struct v4l2_crop crop_arg;
   memset(&crop_arg, 0, sizeof(crop_arg));
   crop_arg.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
 
   if (device_->Ioctl(VIDIOC_G_CROP, &crop_arg) != 0) {
     PLOGF(ERROR) << "ioctl() VIDIOC_G_CROP failed";
     return coded_size;
   }
 
@@ skipping 325 matching lines @@
   }
 
   // Finish resolution change on decoder thread.
   decoder_thread_.message_loop()->PostTask(
       FROM_HERE, base::Bind(&V4L2VideoDecodeAccelerator::FinishResolutionChange,
                             base::Unretained(this)));
 }
 
 void V4L2VideoDecodeAccelerator::SendPictureReady() {
   DVLOGF(3);
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   bool resetting_or_flushing =
       (decoder_state_ == kResetting || decoder_flushing_);
   while (pending_picture_ready_.size() > 0) {
     bool cleared = pending_picture_ready_.front().cleared;
     const Picture& picture = pending_picture_ready_.front().picture;
     if (cleared && picture_clearing_count_ == 0) {
       // This picture is cleared. It can be posted to a thread different than
       // the main GPU thread to reduce latency. This should be the case after
       // all pictures are cleared at the beginning.
       decode_task_runner_->PostTask(
@@ skipping 21 matching lines @@
       // This picture is cleared. But some pictures are about to be cleared on
       // the child thread. To preserve the order, do not send this until those
       // pictures are cleared.
       break;
     }
   }
 }
 
 void V4L2VideoDecodeAccelerator::PictureCleared() {
   DVLOGF(3) << "clearing count=" << picture_clearing_count_;
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_GT(picture_clearing_count_, 0);
   picture_clearing_count_--;
   SendPictureReady();
 }
 
 void V4L2VideoDecodeAccelerator::FrameProcessed(int32_t bitstream_buffer_id,
                                                 int output_buffer_index) {
   DVLOGF(3) << "output_buffer_index=" << output_buffer_index
             << ", bitstream_buffer_id=" << bitstream_buffer_id;
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK_GE(output_buffer_index, 0);
   DCHECK_LT(output_buffer_index, static_cast<int>(output_buffer_map_.size()));
 
   OutputRecord& output_record = output_buffer_map_[output_buffer_index];
   DCHECK_EQ(output_record.state, kAtProcessor);
   if (!image_processor_bitstream_buffer_ids_.empty() &&
       image_processor_bitstream_buffer_ids_.front() == bitstream_buffer_id) {
     DVLOGF(3) << "picture_id=" << output_record.picture_id;
     DCHECK_NE(output_record.egl_image, EGL_NO_IMAGE_KHR);
     DCHECK_NE(output_record.picture_id, -1);
@@ skipping 20 matching lines @@
     Enqueue();
   }
 }
 
 void V4L2VideoDecodeAccelerator::ImageProcessorError() {
   LOGF(ERROR) << "Image processor error";
   NOTIFY_ERROR(PLATFORM_FAILURE);
 }
 
 }  // namespace media