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

content/common/gpu/media/vt_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 <algorithm>
 
 #include <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 
@@ skipping 306 matching lines @@
     return false;
 
   // Count the session as successfully initialized.
   UMA_HISTOGRAM_ENUMERATION("Media.VTVDA.SessionFailureReason",
                             SFT_SUCCESSFULLY_INITIALIZED,
                             SFT_MAX + 1);
   return true;
 }
 
 bool VTVideoDecodeAccelerator::FinishDelayedFrames() {
-  DCHECK(decoder_thread_.message_loop_proxy()->BelongsToCurrentThread());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   if (session_) {
     OSStatus status = VTDecompressionSessionWaitForAsynchronousFrames(session_);
     if (status) {
       NOTIFY_STATUS("VTDecompressionSessionWaitForAsynchronousFrames()",
                     status, SFT_PLATFORM_ERROR);
       return false;
     }
   }
   return true;
 }
 
 bool VTVideoDecodeAccelerator::ConfigureDecoder() {
-  DCHECK(decoder_thread_.message_loop_proxy()->BelongsToCurrentThread());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK(!last_sps_.empty());
   DCHECK(!last_pps_.empty());
 
   // Build the configuration records.
   std::vector<const uint8_t*> nalu_data_ptrs;
   std::vector<size_t> nalu_data_sizes;
   nalu_data_ptrs.reserve(3);
   nalu_data_sizes.reserve(3);
   nalu_data_ptrs.push_back(&last_sps_.front());
   nalu_data_sizes.push_back(last_sps_.size());
@@ skipping 89 matching lines @@
     using_hardware = CFBooleanGetValue(cf_using_hardware);
   }
   UMA_HISTOGRAM_BOOLEAN("Media.VTVDA.HardwareAccelerated", using_hardware);
 
   return true;
 }
 
 void VTVideoDecodeAccelerator::DecodeTask(
     const media::BitstreamBuffer& bitstream,
     Frame* frame) {
-  DCHECK(decoder_thread_.message_loop_proxy()->BelongsToCurrentThread());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   // Map the bitstream buffer.
   base::SharedMemory memory(bitstream.handle(), true);
   size_t size = bitstream.size();
   if (!memory.Map(size)) {
     DLOG(ERROR) << "Failed to map bitstream buffer";
     NotifyError(PLATFORM_FAILURE, SFT_PLATFORM_ERROR);
     return;
   }
   const uint8_t* buf = static_cast<uint8_t*>(memory.memory());
@@ skipping 276 matching lines @@
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(1u, pending_frames_.count(frame->bitstream_id));
   Task task(TASK_FRAME);
   task.frame = pending_frames_[frame->bitstream_id];
   pending_frames_.erase(frame->bitstream_id);
   task_queue_.push(task);
   ProcessWorkQueues();
 }
 
 void VTVideoDecodeAccelerator::FlushTask(TaskType type) {
-  DCHECK(decoder_thread_.message_loop_proxy()->BelongsToCurrentThread());
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   FinishDelayedFrames();
 
   // Always queue a task, even if FinishDelayedFrames() fails, so that
   // destruction always completes.
   gpu_task_runner_->PostTask(FROM_HERE, base::Bind(
       &VTVideoDecodeAccelerator::FlushDone, weak_this_, type));
 }
 
 void VTVideoDecodeAccelerator::FlushDone(TaskType type) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   task_queue_.push(Task(type));
   ProcessWorkQueues();
 }
 
 void VTVideoDecodeAccelerator::Decode(const media::BitstreamBuffer& bitstream) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(0u, assigned_bitstream_ids_.count(bitstream.id()));
   assigned_bitstream_ids_.insert(bitstream.id());
   Frame* frame = new Frame(bitstream.id());
   pending_frames_[frame->bitstream_id] = make_linked_ptr(frame);
-  decoder_thread_.message_loop_proxy()->PostTask(FROM_HERE, base::Bind(
-      &VTVideoDecodeAccelerator::DecodeTask, base::Unretained(this),
-      bitstream, frame));
+  decoder_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&VTVideoDecodeAccelerator::DecodeTask,
+                            base::Unretained(this), bitstream, frame));
 }
 
 void VTVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& pictures) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
 
   for (const media::PictureBuffer& picture : pictures) {
     DCHECK(!texture_ids_.count(picture.id()));
     assigned_picture_ids_.insert(picture.id());
     available_picture_ids_.push_back(picture.id());
@@ skipping 216 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("Media.VTVDA.SessionFailureReason",
                               session_failure_type,
                               SFT_MAX + 1);
     client_->NotifyError(vda_error_type);
   }
 }
 
 void VTVideoDecodeAccelerator::QueueFlush(TaskType type) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   pending_flush_tasks_.push(type);
-  decoder_thread_.message_loop_proxy()->PostTask(FROM_HERE, base::Bind(
-      &VTVideoDecodeAccelerator::FlushTask, base::Unretained(this),
-      type));
+  decoder_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&VTVideoDecodeAccelerator::FlushTask,
+                            base::Unretained(this), type));
 
   // If this is a new flush request, see if we can make progress.
   if (pending_flush_tasks_.size() == 1)
     ProcessWorkQueues();
 }
 
 void VTVideoDecodeAccelerator::Flush() {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   QueueFlush(TASK_FLUSH);
 }
@@ skipping 35 matching lines @@
     SupportedProfile profile;
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(16, 16);
     profile.max_resolution.SetSize(4096, 2160);
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 }  // namespace content