content/common: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

content/common/gpu/media/v4l2_slice_video_decode_accelerator.cc

 // Copyright 2015 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 <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "content/common/gpu/media/v4l2_slice_video_decode_accelerator.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/media_switches.h"
 #include "ui/gl/scoped_binders.h"
 
 #define LOGF(level) LOG(level) << __FUNCTION__ << "(): "
 #define DVLOGF(level) DVLOG(level) << __FUNCTION__ << "(): "
 
@@ skipping 127 matching lines @@
       at_client(false),
       picture_id(-1),
       egl_image(EGL_NO_IMAGE_KHR),
       egl_sync(EGL_NO_SYNC_KHR),
       cleared(false) {
 }
 
 struct V4L2SliceVideoDecodeAccelerator::BitstreamBufferRef {
   BitstreamBufferRef(
       base::WeakPtr<VideoDecodeAccelerator::Client>& client,
-      const scoped_refptr<base::MessageLoopProxy>& client_message_loop_proxy,
+      const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner,
       base::SharedMemory* shm,
       size_t size,
       int32 input_id);
   ~BitstreamBufferRef();
   const base::WeakPtr<VideoDecodeAccelerator::Client> client;
-  const scoped_refptr<base::MessageLoopProxy> client_message_loop_proxy;
+  const scoped_refptr<base::SingleThreadTaskRunner> client_task_runner;
   const scoped_ptr<base::SharedMemory> shm;
   const size_t size;
   off_t bytes_used;
   const int32 input_id;
 };
 
 V4L2SliceVideoDecodeAccelerator::BitstreamBufferRef::BitstreamBufferRef(
     base::WeakPtr<VideoDecodeAccelerator::Client>& client,
-    const scoped_refptr<base::MessageLoopProxy>& client_message_loop_proxy,
+    const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner,
     base::SharedMemory* shm,
     size_t size,
     int32 input_id)
     : client(client),
-      client_message_loop_proxy(client_message_loop_proxy),
+      client_task_runner(client_task_runner),
       shm(shm),
       size(size),
       bytes_used(0),
       input_id(input_id) {
 }
 
 V4L2SliceVideoDecodeAccelerator::BitstreamBufferRef::~BitstreamBufferRef() {
   if (input_id >= 0) {
     DVLOGF(5) << "returning input_id: " << input_id;
-    client_message_loop_proxy->PostTask(
+    client_task_runner->PostTask(
         FROM_HERE,
         base::Bind(&VideoDecodeAccelerator::Client::NotifyEndOfBitstreamBuffer,
                    client, input_id));
   }
 }
 
 struct V4L2SliceVideoDecodeAccelerator::EGLSyncKHRRef {
   EGLSyncKHRRef(EGLDisplay egl_display, EGLSyncKHR egl_sync);
   ~EGLSyncKHRRef();
   EGLDisplay const egl_display;
@@ skipping 167 matching lines @@
 
 V4L2VP8Picture::~V4L2VP8Picture() {
 }
 
 V4L2SliceVideoDecodeAccelerator::V4L2SliceVideoDecodeAccelerator(
     const scoped_refptr<V4L2Device>& device,
     EGLDisplay egl_display,
     EGLContext egl_context,
     const base::WeakPtr<Client>& io_client,
     const base::Callback<bool(void)>& make_context_current,
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy)
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : input_planes_count_(0),
       output_planes_count_(0),
-      child_message_loop_proxy_(base::MessageLoopProxy::current()),
-      io_message_loop_proxy_(io_message_loop_proxy),
+      child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      io_task_runner_(io_task_runner),
       io_client_(io_client),
       device_(device),
       decoder_thread_("V4L2SliceVideoDecodeAcceleratorThread"),
       device_poll_thread_("V4L2SliceVideoDecodeAcceleratorDevicePollThread"),
       input_streamon_(false),
       input_buffer_queued_count_(0),
       output_streamon_(false),
       output_buffer_queued_count_(0),
       video_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN),
       output_format_fourcc_(0),
       state_(kUninitialized),
       decoder_flushing_(false),
       decoder_resetting_(false),
       surface_set_change_pending_(false),
       picture_clearing_count_(0),
       pictures_assigned_(false, false),
       make_context_current_(make_context_current),
       egl_display_(egl_display),
       egl_context_(egl_context),
       weak_this_factory_(this) {
   weak_this_ = weak_this_factory_.GetWeakPtr();
 }
 
 V4L2SliceVideoDecodeAccelerator::~V4L2SliceVideoDecodeAccelerator() {
   DVLOGF(2);
 
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!decoder_thread_.IsRunning());
   DCHECK(!device_poll_thread_.IsRunning());
 
   DCHECK(input_buffer_map_.empty());
   DCHECK(output_buffer_map_.empty());
 }
 
 void V4L2SliceVideoDecodeAccelerator::NotifyError(Error error) {
-  if (!child_message_loop_proxy_->BelongsToCurrentThread()) {
-    child_message_loop_proxy_->PostTask(
+  if (!child_task_runner_->BelongsToCurrentThread()) {
+    child_task_runner_->PostTask(
         FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::NotifyError,
                               weak_this_, error));
     return;
   }
 
   if (client_) {
     client_->NotifyError(error);
     client_ptr_factory_.reset();
   }
 }
 
 bool V4L2SliceVideoDecodeAccelerator::Initialize(
     media::VideoCodecProfile profile,
     VideoDecodeAccelerator::Client* client) {
   DVLOGF(3) << "profile: " << profile;
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kUninitialized);
 
   client_ptr_factory_.reset(
       new base::WeakPtrFactory<VideoDecodeAccelerator::Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
 
   video_profile_ = profile;
 
   if (video_profile_ >= media::H264PROFILE_MIN &&
       video_profile_ <= media::H264PROFILE_MAX) {
@@ skipping 41 matching lines @@
     return false;
   }
 
   if (!SetupFormats())
     return false;
 
   if (!decoder_thread_.Start()) {
     DLOG(ERROR) << "Initialize(): device thread failed to start";
     return false;
   }
-  decoder_thread_proxy_ = decoder_thread_.message_loop_proxy();
+  decoder_thread_task_runner_ = decoder_thread_.task_runner();
 
   state_ = kInitialized;
 
   // InitializeTask will NOTIFY_ERROR on failure.
-  decoder_thread_proxy_->PostTask(
+  decoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::InitializeTask,
                             base::Unretained(this)));
 
   DVLOGF(1) << "V4L2SliceVideoDecodeAccelerator initialized";
   return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::InitializeTask() {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kInitialized);
 
   if (!CreateInputBuffers())
     NOTIFY_ERROR(PLATFORM_FAILURE);
 
   // Output buffers will be created once decoder gives us information
   // about their size and required count.
   state_ = kDecoding;
 }
 
 void V4L2SliceVideoDecodeAccelerator::Destroy() {
   DVLOGF(3);
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (decoder_thread_.IsRunning()) {
-    decoder_thread_proxy_->PostTask(
+    decoder_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::DestroyTask,
                               base::Unretained(this)));
 
     // Wait for tasks to finish/early-exit.
     decoder_thread_.Stop();
   }
 
   delete this;
   DVLOGF(3) << "Destroyed";
 }
 
 void V4L2SliceVideoDecodeAccelerator::DestroyTask() {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   state_ = kError;
 
   decoder_->Reset();
 
   decoder_current_bitstream_buffer_.reset();
   while (!decoder_input_queue_.empty())
     decoder_input_queue_.pop();
 
   // Stop streaming and the device_poll_thread_.
@@ skipping 60 matching lines @@
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   format.fmt.pix_mp.pixelformat = output_format_fourcc_;
   format.fmt.pix_mp.num_planes = output_planes_count_;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
 
   return true;
 }
 
 bool V4L2SliceVideoDecodeAccelerator::CreateInputBuffers() {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
   DCHECK(input_buffer_map_.empty());
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = kNumInputBuffers;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
   if (reqbufs.count < kNumInputBuffers) {
@@ skipping 26 matching lines @@
     }
     input_buffer_map_[i].address = address;
     input_buffer_map_[i].length = buffer.m.planes[0].length;
   }
 
   return true;
 }
 
 bool V4L2SliceVideoDecodeAccelerator::CreateOutputBuffers() {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK(!output_streamon_);
   DCHECK(output_buffer_map_.empty());
   DCHECK(surfaces_at_display_.empty());
   DCHECK(surfaces_at_device_.empty());
 
   visible_size_ = decoder_->GetPicSize();
   size_t num_pictures = decoder_->GetRequiredNumOfPictures();
 
   DCHECK_GT(num_pictures, 0u);
   DCHECK(!visible_size_.IsEmpty());
@@ skipping 33 matching lines @@
     PLOG(ERROR) << "Could not allocate enough output buffers";
     return false;
   }
 
   output_buffer_map_.resize(reqbufs.count);
 
   DVLOGF(3) << "buffer_count=" << output_buffer_map_.size()
             << ", visible size=" << visible_size_.ToString()
             << ", coded size=" << coded_size_.ToString();
 
-  child_message_loop_proxy_->PostTask(
+  child_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoDecodeAccelerator::Client::ProvidePictureBuffers,
                  client_, output_buffer_map_.size(), coded_size_,
                  device_->GetTextureTarget()));
 
   // Wait for the client to call AssignPictureBuffers() on the Child thread.
   // We do this, because if we continue decoding without finishing buffer
   // allocation, we may end up Resetting before AssignPictureBuffers arrives,
   // resulting in unnecessary complications and subtle bugs.
   pictures_assigned_.Wait();
 
   return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::DestroyInputBuffers() {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread() ||
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread() ||
          !decoder_thread_.IsRunning());
   DCHECK(!input_streamon_);
 
   for (auto& input_record : input_buffer_map_) {
     if (input_record.address != nullptr)
       device_->Munmap(input_record.address, input_record.length);
   }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   input_buffer_map_.clear();
   free_input_buffers_.clear();
 }
 
 void V4L2SliceVideoDecodeAccelerator::DismissPictures(
     std::vector<int32> picture_buffer_ids,
     base::WaitableEvent* done) {
   DVLOGF(3);
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   for (auto picture_buffer_id : picture_buffer_ids) {
     DVLOGF(1) << "dismissing PictureBuffer id=" << picture_buffer_id;
     client_->DismissPictureBuffer(picture_buffer_id);
   }
 
   done->Signal();
 }
 
 void V4L2SliceVideoDecodeAccelerator::DevicePollTask(bool poll_device) {
   DVLOGF(4);
   DCHECK_EQ(device_poll_thread_.message_loop(), base::MessageLoop::current());
 
   bool event_pending;
   if (!device_->Poll(poll_device, &event_pending)) {
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   // All processing should happen on ServiceDeviceTask(), since we shouldn't
   // touch encoder state from this thread.
-  decoder_thread_proxy_->PostTask(
+  decoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::ServiceDeviceTask,
                             base::Unretained(this)));
 }
 
 void V4L2SliceVideoDecodeAccelerator::ServiceDeviceTask() {
   DVLOGF(4);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   // ServiceDeviceTask() should only ever be scheduled from DevicePollTask().
 
   Dequeue();
   SchedulePollIfNeeded();
 }
 
 void V4L2SliceVideoDecodeAccelerator::SchedulePollIfNeeded() {
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (!device_poll_thread_.IsRunning()) {
     DVLOGF(2) << "Device poll thread stopped, will not schedule poll";
     return;
   }
 
   DCHECK(input_streamon_ || output_streamon_);
 
   if (input_buffer_queued_count_ + output_buffer_queued_count_ == 0) {
     DVLOGF(4) << "No buffers queued, will not schedule poll";
@@ skipping 14 matching lines @@
             << input_buffer_map_.size() << "]->["
             << free_output_buffers_.size() << "+"
             << output_buffer_queued_count_ << "/"
             << output_buffer_map_.size() << "]"
             << " => DISPLAYQ[" << decoder_display_queue_.size() << "]"
             << " => CLIENT[" << surfaces_at_display_.size() << "]";
 }
 
 void V4L2SliceVideoDecodeAccelerator::Enqueue(
     const scoped_refptr<V4L2DecodeSurface>& dec_surface) {
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   const int old_inputs_queued = input_buffer_queued_count_;
   const int old_outputs_queued = output_buffer_queued_count_;
 
   if (!EnqueueInputRecord(dec_surface->input_record(),
                           dec_surface->config_store())) {
     DVLOGF(1) << "Failed queueing an input buffer";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   if (!EnqueueOutputRecord(dec_surface->output_record())) {
     DVLOGF(1) << "Failed queueing an output buffer";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   bool inserted =
       surfaces_at_device_.insert(std::make_pair(dec_surface->output_record(),
                                                 dec_surface)).second;
   DCHECK(inserted);
 
   if (old_inputs_queued == 0 && old_outputs_queued == 0)
     SchedulePollIfNeeded();
 }
 
 void V4L2SliceVideoDecodeAccelerator::Dequeue() {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   struct v4l2_buffer dqbuf;
   struct v4l2_plane planes[VIDEO_MAX_PLANES];
   while (input_buffer_queued_count_ > 0) {
     DCHECK(input_streamon_);
     memset(&dqbuf, 0, sizeof(dqbuf));
     memset(&planes, 0, sizeof(planes));
     dqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
     dqbuf.memory = V4L2_MEMORY_USERPTR;
     dqbuf.m.planes = planes;
@@ skipping 64 matching lines @@
   // put the decoder in an undefined state.
   FinishSurfaceSetChangeIfNeeded();
 
   // Process external (client) requests.
   FinishFlushIfNeeded();
   FinishResetIfNeeded();
 }
 
 void V4L2SliceVideoDecodeAccelerator::ReuseInputBuffer(int index) {
   DVLOGF(4) << "Reusing input buffer, index=" << index;
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   DCHECK_LT(index, static_cast<int>(input_buffer_map_.size()));
   InputRecord& input_record = input_buffer_map_[index];
 
   DCHECK(!input_record.at_device);
   input_record.input_id = -1;
   input_record.bytes_used = 0;
 
   DCHECK_EQ(std::count(free_input_buffers_.begin(), free_input_buffers_.end(),
             index), 0);
   free_input_buffers_.push_back(index);
 }
 
 void V4L2SliceVideoDecodeAccelerator::ReuseOutputBuffer(int index) {
   DVLOGF(4) << "Reusing output buffer, index=" << index;
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   DCHECK_LT(index, static_cast<int>(output_buffer_map_.size()));
   OutputRecord& output_record = output_buffer_map_[index];
   DCHECK(!output_record.at_device);
   DCHECK(!output_record.at_client);
 
   DCHECK_EQ(std::count(free_output_buffers_.begin(), free_output_buffers_.end(),
             index), 0);
   free_output_buffers_.push_back(index);
 
@@ skipping 71 matching lines @@
   output_record.at_device = true;
   output_buffer_queued_count_++;
   DVLOGF(4) << "Enqueued output=" << qbuf.index
             << " count: " << output_buffer_queued_count_;
 
   return true;
 }
 
 bool V4L2SliceVideoDecodeAccelerator::StartDevicePoll() {
   DVLOGF(3) << "Starting device poll";
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_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()) {
     DLOG(ERROR) << "StartDevicePoll(): Device thread failed to start";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return false;
   }
   if (!input_streamon_) {
     __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
@@ skipping 10 matching lines @@
   device_poll_thread_.message_loop()->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::DevicePollTask,
                             base::Unretained(this), true));
 
   return true;
 }
 
 bool V4L2SliceVideoDecodeAccelerator::StopDevicePoll(bool keep_input_state) {
   DVLOGF(3) << "Stopping device poll";
   if (decoder_thread_.IsRunning())
-    DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+    DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   // Signal the DevicePollTask() to stop, and stop the device poll thread.
   if (!device_->SetDevicePollInterrupt()) {
     PLOG(ERROR) << "SetDevicePollInterrupt(): failed";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return false;
   }
   device_poll_thread_.Stop();
   DVLOGF(3) << "Device poll thread stopped";
 
@@ skipping 47 matching lines @@
     decoder_display_queue_.pop();
 
   DVLOGF(3) << "Device poll stopped";
   return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DVLOGF(3) << "input_id=" << bitstream_buffer.id()
             << ", size=" << bitstream_buffer.size();
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
-  decoder_thread_proxy_->PostTask(
+  decoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::DecodeTask,
                             base::Unretained(this), bitstream_buffer));
 }
 
 void V4L2SliceVideoDecodeAccelerator::DecodeTask(
     const media::BitstreamBuffer& bitstream_buffer) {
   DVLOGF(3) << "input_id=" << bitstream_buffer.id()
             << " size=" << bitstream_buffer.size();
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   scoped_ptr<BitstreamBufferRef> bitstream_record(new BitstreamBufferRef(
-      io_client_, io_message_loop_proxy_,
+      io_client_, io_task_runner_,
       new base::SharedMemory(bitstream_buffer.handle(), true),
       bitstream_buffer.size(), bitstream_buffer.id()));
   if (!bitstream_record->shm->Map(bitstream_buffer.size())) {
     LOGF(ERROR) << "Could not map bitstream_buffer";
     NOTIFY_ERROR(UNREADABLE_INPUT);
     return;
   }
   DVLOGF(3) << "mapped at=" << bitstream_record->shm->memory();
 
   decoder_input_queue_.push(
       linked_ptr<BitstreamBufferRef>(bitstream_record.release()));
 
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 bool V4L2SliceVideoDecodeAccelerator::TrySetNewBistreamBuffer() {
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK(!decoder_current_bitstream_buffer_);
 
   if (decoder_input_queue_.empty())
     return false;
 
   decoder_current_bitstream_buffer_.reset(
       decoder_input_queue_.front().release());
   decoder_input_queue_.pop();
 
   if (decoder_current_bitstream_buffer_->input_id == kFlushBufferId) {
     // This is a buffer we queued for ourselves to trigger flush at this time.
     InitiateFlush();
     return false;
   }
 
   const uint8_t* const data = reinterpret_cast<const uint8_t*>(
       decoder_current_bitstream_buffer_->shm->memory());
   const size_t data_size = decoder_current_bitstream_buffer_->size;
   decoder_->SetStream(data, data_size);
 
   return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::ScheduleDecodeBufferTaskIfNeeded() {
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   if (state_ == kDecoding) {
-    decoder_thread_proxy_->PostTask(
+    decoder_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&V4L2SliceVideoDecodeAccelerator::DecodeBufferTask,
                    base::Unretained(this)));
   }
 }
 
 void V4L2SliceVideoDecodeAccelerator::DecodeBufferTask() {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (state_ != kDecoding) {
     DVLOGF(3) << "Early exit, not in kDecoding";
     return;
   }
 
   while (true) {
     AcceleratedVideoDecoder::DecodeResult res;
     res = decoder_->Decode();
     switch (res) {
@@ skipping 17 matching lines @@
       case AcceleratedVideoDecoder::kDecodeError:
         DVLOGF(1) << "Error decoding stream";
         NOTIFY_ERROR(PLATFORM_FAILURE);
         return;
     }
   }
 }
 
 void V4L2SliceVideoDecodeAccelerator::InitiateSurfaceSetChange() {
   DVLOGF(2);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   DCHECK_EQ(state_, kDecoding);
   state_ = kIdle;
 
   DCHECK(!surface_set_change_pending_);
   surface_set_change_pending_ = true;
 
   FinishSurfaceSetChangeIfNeeded();
 }
 
 void V4L2SliceVideoDecodeAccelerator::FinishSurfaceSetChangeIfNeeded() {
   DVLOGF(2);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (!surface_set_change_pending_ || !surfaces_at_device_.empty())
     return;
 
   DCHECK_EQ(state_, kIdle);
   DCHECK(decoder_display_queue_.empty());
   // All output buffers should've been returned from decoder and device by now.
   // The only remaining owner of surfaces may be display (client), and we will
   // dismiss them when destroying output buffers below.
   DCHECK_EQ(free_output_buffers_.size() + surfaces_at_display_.size(),
@@ skipping 26 matching lines @@
 
   DVLOGF(3) << "Surface set change finished";
 
   surface_set_change_pending_ = false;
   state_ = kDecoding;
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 bool V4L2SliceVideoDecodeAccelerator::DestroyOutputs(bool dismiss) {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   std::vector<EGLImageKHR> egl_images_to_destroy;
   std::vector<int32> picture_buffers_to_dismiss;
 
   if (output_buffer_map_.empty())
     return true;
 
   for (auto output_record : output_buffer_map_) {
     DCHECK(!output_record.at_device);
 
     if (output_record.egl_sync != EGL_NO_SYNC_KHR) {
       if (eglDestroySyncKHR(egl_display_, output_record.egl_sync) != EGL_TRUE)
         DVLOGF(1) << "eglDestroySyncKHR failed.";
     }
 
     if (output_record.egl_image != EGL_NO_IMAGE_KHR) {
-      child_message_loop_proxy_->PostTask(
+      child_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(base::IgnoreResult(&V4L2Device::DestroyEGLImage), device_,
                      egl_display_, output_record.egl_image));
     }
 
     picture_buffers_to_dismiss.push_back(output_record.picture_id);
   }
 
   if (dismiss) {
     DVLOGF(2) << "Scheduling picture dismissal";
     base::WaitableEvent done(false, false);
-    child_message_loop_proxy_->PostTask(
+    child_task_runner_->PostTask(
         FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::DismissPictures,
                               weak_this_, picture_buffers_to_dismiss, &done));
     done.Wait();
   }
 
   // At this point client can't call ReusePictureBuffer on any of the pictures
   // anymore, so it's safe to destroy.
   return DestroyOutputBuffers();
 }
 
 bool V4L2SliceVideoDecodeAccelerator::DestroyOutputBuffers() {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread() ||
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread() ||
          !decoder_thread_.IsRunning());
   DCHECK(!output_streamon_);
   DCHECK(surfaces_at_device_.empty());
   DCHECK(decoder_display_queue_.empty());
   DCHECK_EQ(surfaces_at_display_.size() + free_output_buffers_.size(),
             output_buffer_map_.size());
 
   if (output_buffer_map_.empty())
     return true;
 
@@ skipping 21 matching lines @@
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
 
   return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DVLOGF(3);
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (buffers.size() != output_buffer_map_.size()) {
     DLOG(ERROR) << "Failed to provide requested picture buffers. "
                 << "(Got " << buffers.size()
                 << ", requested " << output_buffer_map_.size() << ")";
     NOTIFY_ERROR(INVALID_ARGUMENT);
     return;
   }
 
   if (!make_context_current_.Run()) {
@@ skipping 38 matching lines @@
     output_record.picture_id = buffers[i].id();
     free_output_buffers_.push_back(i);
     DVLOGF(3) << "buffer[" << i << "]: picture_id=" << output_record.picture_id;
   }
 
   pictures_assigned_.Signal();
 }
 
 void V4L2SliceVideoDecodeAccelerator::ReusePictureBuffer(
     int32 picture_buffer_id) {
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DVLOGF(4) << "picture_buffer_id=" << picture_buffer_id;
 
   if (!make_context_current_.Run()) {
     LOGF(ERROR) << "could not make context current";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   EGLSyncKHR egl_sync =
       eglCreateSyncKHR(egl_display_, EGL_SYNC_FENCE_KHR, NULL);
   if (egl_sync == EGL_NO_SYNC_KHR) {
     LOGF(ERROR) << "eglCreateSyncKHR() failed";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   scoped_ptr<EGLSyncKHRRef> egl_sync_ref(
       new EGLSyncKHRRef(egl_display_, egl_sync));
-  decoder_thread_proxy_->PostTask(
+  decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&V4L2SliceVideoDecodeAccelerator::ReusePictureBufferTask,
                  base::Unretained(this), picture_buffer_id,
                  base::Passed(&egl_sync_ref)));
 }
 
 void V4L2SliceVideoDecodeAccelerator::ReusePictureBufferTask(
     int32 picture_buffer_id,
     scoped_ptr<EGLSyncKHRRef> egl_sync_ref) {
   DVLOGF(3) << "picture_buffer_id=" << picture_buffer_id;
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   V4L2DecodeSurfaceByPictureBufferId::iterator it =
       surfaces_at_display_.find(picture_buffer_id);
   if (it == surfaces_at_display_.end()) {
     // It's possible that we've already posted a DismissPictureBuffer for this
     // picture, but it has not yet executed when this ReusePictureBuffer was
     // posted to us by the client. In that case just ignore this (we've already
     // dismissed it and accounted for that) and let the sync object get
     // destroyed.
     DVLOGF(3) << "got picture id=" << picture_buffer_id
@@ skipping 12 matching lines @@
   DCHECK(!output_record.at_device);
   output_record.at_client = false;
   output_record.egl_sync = egl_sync_ref->egl_sync;
   // Take ownership of the EGLSync.
   egl_sync_ref->egl_sync = EGL_NO_SYNC_KHR;
   surfaces_at_display_.erase(it);
 }
 
 void V4L2SliceVideoDecodeAccelerator::Flush() {
   DVLOGF(3);
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
-  decoder_thread_proxy_->PostTask(
+  decoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::FlushTask,
                             base::Unretained(this)));
 }
 
 void V4L2SliceVideoDecodeAccelerator::FlushTask() {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (!decoder_input_queue_.empty()) {
     // We are not done with pending inputs, so queue an empty buffer,
     // which - when reached - will trigger flush sequence.
     decoder_input_queue_.push(
         linked_ptr<BitstreamBufferRef>(new BitstreamBufferRef(
-            io_client_, io_message_loop_proxy_, nullptr, 0, kFlushBufferId)));
+            io_client_, io_task_runner_, nullptr, 0, kFlushBufferId)));
     return;
   }
 
   // No more inputs pending, so just finish flushing here.
   InitiateFlush();
 }
 
 void V4L2SliceVideoDecodeAccelerator::InitiateFlush() {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   DCHECK(!decoder_flushing_);
   DCHECK_EQ(state_, kDecoding);
   state_ = kIdle;
 
   // This will trigger output for all remaining surfaces in the decoder.
   // However, not all of them may be decoded yet (they would be queued
   // in hardware then).
   if (!decoder_->Flush()) {
     DVLOGF(1) << "Failed flushing the decoder.";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   // Put the decoder in an idle state, ready to resume.
   decoder_->Reset();
 
   decoder_flushing_ = true;
 
-  decoder_thread_proxy_->PostTask(
+  decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&V4L2SliceVideoDecodeAccelerator::FinishFlushIfNeeded,
                  base::Unretained(this)));
 }
 
 void V4L2SliceVideoDecodeAccelerator::FinishFlushIfNeeded() {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (!decoder_flushing_ || !surfaces_at_device_.empty())
     return;
 
   DCHECK_EQ(state_, kIdle);
 
   // At this point, all remaining surfaces are decoded and dequeued, and since
   // we have already scheduled output for them in InitiateFlush(), their
   // respective PictureReady calls have been posted (or they have been queued on
   // pending_picture_ready_). So at this time, once we SendPictureReady(),
   // we will have all remaining PictureReady() posted to the client and we
   // can post NotifyFlushDone().
   DCHECK(decoder_display_queue_.empty());
 
   // Decoder should have already returned all surfaces and all surfaces are
   // out of hardware. There can be no other owners of input buffers.
   DCHECK_EQ(free_input_buffers_.size(), input_buffer_map_.size());
 
   SendPictureReady();
 
-  child_message_loop_proxy_->PostTask(
-      FROM_HERE, base::Bind(&Client::NotifyFlushDone, client_));
+  child_task_runner_->PostTask(FROM_HERE,
+                               base::Bind(&Client::NotifyFlushDone, client_));
 
   decoder_flushing_ = false;
 
   DVLOGF(3) << "Flush finished";
   state_ = kDecoding;
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 void V4L2SliceVideoDecodeAccelerator::Reset() {
   DVLOGF(3);
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
-  decoder_thread_proxy_->PostTask(
+  decoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::ResetTask,
                             base::Unretained(this)));
 }
 
 void V4L2SliceVideoDecodeAccelerator::ResetTask() {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (decoder_resetting_) {
     // This is a bug in the client, multiple Reset()s before NotifyResetDone()
     // are not allowed.
     NOTREACHED() << "Client should not be requesting multiple Reset()s";
     return;
   }
 
   DCHECK_EQ(state_, kDecoding);
   state_ = kIdle;
 
   // Put the decoder in an idle state, ready to resume.
   decoder_->Reset();
 
   decoder_resetting_ = true;
 
   // Drop all remaining inputs.
   decoder_current_bitstream_buffer_.reset();
   while (!decoder_input_queue_.empty())
     decoder_input_queue_.pop();
 
   FinishResetIfNeeded();
 }
 
 void V4L2SliceVideoDecodeAccelerator::FinishResetIfNeeded() {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (!decoder_resetting_ || !surfaces_at_device_.empty())
     return;
 
   DCHECK_EQ(state_, kIdle);
   DCHECK(!decoder_flushing_);
   SendPictureReady();
 
   // Drop any pending outputs.
   while (!decoder_display_queue_.empty())
     decoder_display_queue_.pop();
 
   // At this point we can have no input buffers in the decoder, because we
   // Reset()ed it in ResetTask(), and have not scheduled any new Decode()s
   // having been in kIdle since. We don't have any surfaces in the HW either -
   // we just checked that surfaces_at_device_.empty(), and inputs are tied
   // to surfaces. Since there can be no other owners of input buffers, we can
   // simply mark them all as available.
   DCHECK_EQ(input_buffer_queued_count_, 0);
   free_input_buffers_.clear();
   for (size_t i = 0; i < input_buffer_map_.size(); ++i) {
     DCHECK(!input_buffer_map_[i].at_device);
     ReuseInputBuffer(i);
   }
 
   decoder_resetting_ = false;
 
-  child_message_loop_proxy_->PostTask(
-      FROM_HERE, base::Bind(&Client::NotifyResetDone, client_));
+  child_task_runner_->PostTask(FROM_HERE,
+                               base::Bind(&Client::NotifyResetDone, client_));
 
   DVLOGF(3) << "Reset finished";
 
   state_ = kDecoding;
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 void V4L2SliceVideoDecodeAccelerator::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_.IsRunning() &&
-      !decoder_thread_proxy_->BelongsToCurrentThread()) {
-    decoder_thread_proxy_->PostTask(
+      !decoder_thread_task_runner_->BelongsToCurrentThread()) {
+    decoder_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::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 (state_ != kError && state_ != kUninitialized)
     NotifyError(error);
 
@@ skipping 332 matching lines @@
   memset(data_copy.get(), 0, data_copy_size);
   data_copy[2] = 0x01;
   memcpy(data_copy.get() + 3, data, size);
   return v4l2_dec_->SubmitSlice(dec_surface->input_record(), data_copy.get(),
                                 data_copy_size);
 }
 
 bool V4L2SliceVideoDecodeAccelerator::SubmitSlice(int index,
                                                   const uint8_t* data,
                                                   size_t size) {
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   InputRecord& input_record = input_buffer_map_[index];
 
   if (input_record.bytes_used + size > input_record.length) {
     DVLOGF(1) << "Input buffer too small";
     return false;
   }
 
   memcpy(static_cast<uint8_t*>(input_record.address) + input_record.bytes_used,
          data, size);
@@ skipping 291 matching lines @@
 scoped_refptr<V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>
 V4L2SliceVideoDecodeAccelerator::V4L2VP8Accelerator::
     VP8PictureToV4L2DecodeSurface(const scoped_refptr<VP8Picture>& pic) {
   V4L2VP8Picture* v4l2_pic = pic->AsV4L2VP8Picture();
   CHECK(v4l2_pic);
   return v4l2_pic->dec_surface();
 }
 
 void V4L2SliceVideoDecodeAccelerator::DecodeSurface(
     const scoped_refptr<V4L2DecodeSurface>& dec_surface) {
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   DVLOGF(3) << "Submitting decode for surface: " << dec_surface->ToString();
   Enqueue(dec_surface);
 }
 
 void V4L2SliceVideoDecodeAccelerator::SurfaceReady(
     const scoped_refptr<V4L2DecodeSurface>& dec_surface) {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   decoder_display_queue_.push(dec_surface);
   TryOutputSurfaces();
 }
 
 void V4L2SliceVideoDecodeAccelerator::TryOutputSurfaces() {
   while (!decoder_display_queue_.empty()) {
     scoped_refptr<V4L2DecodeSurface> dec_surface =
         decoder_display_queue_.front();
 
     if (!dec_surface->decoded())
       break;
 
     decoder_display_queue_.pop();
     OutputSurface(dec_surface);
   }
 }
 
 void V4L2SliceVideoDecodeAccelerator::OutputSurface(
     const scoped_refptr<V4L2DecodeSurface>& dec_surface) {
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   OutputRecord& output_record =
       output_buffer_map_[dec_surface->output_record()];
 
   bool inserted =
       surfaces_at_display_.insert(std::make_pair(output_record.picture_id,
                                                  dec_surface)).second;
   DCHECK(inserted);
 
   DCHECK(!output_record.at_client);
   DCHECK(!output_record.at_device);
   DCHECK_NE(output_record.egl_image, EGL_NO_IMAGE_KHR);
   DCHECK_NE(output_record.picture_id, -1);
   output_record.at_client = true;
 
   media::Picture picture(output_record.picture_id, dec_surface->bitstream_id(),
                          gfx::Rect(visible_size_), false);
   DVLOGF(3) << dec_surface->ToString()
             << ", bitstream_id: " << picture.bitstream_buffer_id()
             << ", picture_id: " << picture.picture_buffer_id();
   pending_picture_ready_.push(PictureRecord(output_record.cleared, picture));
   SendPictureReady();
   output_record.cleared = true;
 }
 
 scoped_refptr<V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>
 V4L2SliceVideoDecodeAccelerator::CreateSurface() {
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kDecoding);
 
   if (free_input_buffers_.empty() || free_output_buffers_.empty())
     return nullptr;
 
   int input = free_input_buffers_.front();
   free_input_buffers_.pop_front();
   int output = free_output_buffers_.front();
   free_output_buffers_.pop_front();
 
   InputRecord& input_record = input_buffer_map_[input];
   DCHECK_EQ(input_record.bytes_used, 0u);
   DCHECK_EQ(input_record.input_id, -1);
   DCHECK(decoder_current_bitstream_buffer_ != nullptr);
   input_record.input_id = decoder_current_bitstream_buffer_->input_id;
 
   scoped_refptr<V4L2DecodeSurface> dec_surface = new V4L2DecodeSurface(
       decoder_current_bitstream_buffer_->input_id, input, output,
       base::Bind(&V4L2SliceVideoDecodeAccelerator::ReuseOutputBuffer,
                  base::Unretained(this)));
 
   DVLOGF(4) << "Created surface " << input << " -> " << output;
   return dec_surface;
 }
 
 void V4L2SliceVideoDecodeAccelerator::SendPictureReady() {
   DVLOGF(3);
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   bool resetting_or_flushing = (decoder_resetting_ || decoder_flushing_);
   while (!pending_picture_ready_.empty()) {
     bool cleared = pending_picture_ready_.front().cleared;
     const media::Picture& picture = pending_picture_ready_.front().picture;
     if (cleared && picture_clearing_count_ == 0) {
       DVLOGF(4) << "Posting picture ready to IO for: "
                 << picture.picture_buffer_id();
       // This picture is cleared. Post it to IO thread to reduce latency. This
       // should be the case after all pictures are cleared at the beginning.
-      io_message_loop_proxy_->PostTask(
+      io_task_runner_->PostTask(
           FROM_HERE, base::Bind(&Client::PictureReady, io_client_, picture));
       pending_picture_ready_.pop();
     } else if (!cleared || resetting_or_flushing) {
       DVLOGF(3) << "cleared=" << pending_picture_ready_.front().cleared
                 << ", decoder_resetting_=" << decoder_resetting_
                 << ", decoder_flushing_=" << decoder_flushing_
                 << ", picture_clearing_count_=" << picture_clearing_count_;
       DVLOGF(4) << "Posting picture ready to GPU for: "
                 << picture.picture_buffer_id();
       // If the picture is not cleared, post it to the child thread because it
       // has to be cleared in the child thread. A picture only needs to be
       // cleared once. If the decoder is resetting or flushing, send all
       // pictures to ensure PictureReady arrive before reset or flush done.
-      child_message_loop_proxy_->PostTaskAndReply(
+      child_task_runner_->PostTaskAndReply(
           FROM_HERE, base::Bind(&Client::PictureReady, client_, picture),
           // Unretained is safe. If Client::PictureReady gets to run, |this| is
           // alive. Destroy() will wait the decode thread to finish.
           base::Bind(&V4L2SliceVideoDecodeAccelerator::PictureCleared,
                      base::Unretained(this)));
       picture_clearing_count_++;
       pending_picture_ready_.pop();
     } else {
       // 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 V4L2SliceVideoDecodeAccelerator::PictureCleared() {
   DVLOGF(3) << "clearing count=" << picture_clearing_count_;
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK_GT(picture_clearing_count_, 0);
   picture_clearing_count_--;
   SendPictureReady();
 }
 
 bool V4L2SliceVideoDecodeAccelerator::CanDecodeOnIOThread() {
   return true;
 }
 
 // static
 media::VideoDecodeAccelerator::SupportedProfiles
 V4L2SliceVideoDecodeAccelerator::GetSupportedProfiles() {
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (!device)
     return SupportedProfiles();
 
   const uint32_t supported_formats[] = {
       V4L2_PIX_FMT_H264_SLICE, V4L2_PIX_FMT_VP8_FRAME};
   return device->GetSupportedDecodeProfiles(arraysize(supported_formats),
                                             supported_formats);
 }
 
 }  // namespace content