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

content/common/gpu/media/vaapi_video_encode_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 "content/common/gpu/media/vaapi_video_encode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
 #include "content/common/gpu/media/h264_dpb.h"
 #include "media/base/bind_to_current_loop.h"
 #include "third_party/libva/va/va_enc_h264.h"
 
 #define DVLOGF(level) DVLOG(level) << __FUNCTION__ << "(): "
 
 #define NOTIFY_ERROR(error, msg)                         \
   do {                                                   \
@@ skipping 106 matching lines @@
       mb_height_(0),
       output_buffer_byte_size_(0),
       state_(kUninitialized),
       frame_num_(0),
       idr_pic_id_(0),
       bitrate_(0),
       framerate_(0),
       cpb_size_(0),
       encoding_parameters_changed_(false),
       encoder_thread_("VAVEAEncoderThread"),
-      child_message_loop_proxy_(base::MessageLoopProxy::current()),
+      child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_this_ptr_factory_(this) {
   DVLOGF(4);
   weak_this_ = weak_this_ptr_factory_.GetWeakPtr();
 
   max_ref_idx_l0_size_ = kMaxNumReferenceFrames;
   qp_ = kDefaultQP;
   idr_period_ = kIDRPeriod;
   i_period_ = kIPeriod;
   ip_period_ = kIPPeriod;
 }
 
 VaapiVideoEncodeAccelerator::~VaapiVideoEncodeAccelerator() {
   DVLOGF(4);
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!encoder_thread_.IsRunning());
 }
 
 bool VaapiVideoEncodeAccelerator::Initialize(
     media::VideoFrame::Format format,
     const gfx::Size& input_visible_size,
     media::VideoCodecProfile output_profile,
     uint32 initial_bitrate,
     Client* client) {
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!encoder_thread_.IsRunning());
   DCHECK_EQ(state_, kUninitialized);
 
   DVLOGF(1) << "Initializing VAVEA, input_format: "
             << media::VideoFrame::FormatToString(format)
             << ", input_visible_size: " << input_visible_size.ToString()
             << ", output_profile: " << output_profile
             << ", initial_bitrate: " << initial_bitrate;
 
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
@@ skipping 29 matching lines @@
                                         base::Bind(&ReportToUMA, VAAPI_ERROR));
   if (!vaapi_wrapper_.get()) {
     DVLOGF(1) << "Failed initializing VAAPI for profile " << output_profile;
     return false;
   }
 
   if (!encoder_thread_.Start()) {
     LOG(ERROR) << "Failed to start encoder thread";
     return false;
   }
-  encoder_thread_proxy_ = encoder_thread_.message_loop_proxy();
+  encoder_thread_proxy_ = encoder_thread_.task_runner();
 
   // Finish the remaining initialization on the encoder thread.
   encoder_thread_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&VaapiVideoEncodeAccelerator::InitializeTask,
                  base::Unretained(this)));
 
   return true;
 }
 
@@ skipping 11 matching lines @@
     NOTIFY_ERROR(kPlatformFailureError, "Failed creating VASurfaces");
     return;
   }
 
   UpdateSPS();
   GeneratePackedSPS();
 
   UpdatePPS();
   GeneratePackedPPS();
 
-  child_message_loop_proxy_->PostTask(
+  child_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&Client::RequireBitstreamBuffers,
-                 client_,
-                 kNumInputBuffers,
-                 coded_size_,
-                 output_buffer_byte_size_));
+      base::Bind(&Client::RequireBitstreamBuffers, client_, kNumInputBuffers,
+                 coded_size_, output_buffer_byte_size_));
 
   SetState(kEncoding);
 }
 
 void VaapiVideoEncodeAccelerator::RecycleVASurfaceID(
     VASurfaceID va_surface_id) {
   DVLOGF(4) << "va_surface_id: " << va_surface_id;
   DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
 
   available_va_surface_ids_.push_back(va_surface_id);
@@ skipping 290 matching lines @@
           buffer->size,
           &data_size)) {
     NOTIFY_ERROR(kPlatformFailureError, "Failed downloading coded buffer");
     return;
   }
 
   DVLOGF(3) << "Returning bitstream buffer "
             << (encode_job->keyframe ? "(keyframe)" : "")
             << " id: " << buffer->id << " size: " << data_size;
 
-  child_message_loop_proxy_->PostTask(FROM_HERE,
-                                      base::Bind(&Client::BitstreamBufferReady,
-                                                 client_,
-                                                 buffer->id,
-                                                 data_size,
-                                                 encode_job->keyframe));
+  child_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Client::BitstreamBufferReady, client_, buffer->id,
+                            data_size, encode_job->keyframe));
 }
 
 void VaapiVideoEncodeAccelerator::Encode(
     const scoped_refptr<media::VideoFrame>& frame,
     bool force_keyframe) {
   DVLOGF(3) << "Frame timestamp: " << frame->timestamp().InMilliseconds()
             << " force_keyframe: " << force_keyframe;
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   encoder_thread_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&VaapiVideoEncodeAccelerator::EncodeTask,
                  base::Unretained(this),
                  frame,
                  force_keyframe));
 }
 
 bool VaapiVideoEncodeAccelerator::PrepareNextJob() {
@@ skipping 73 matching lines @@
     return;
   }
 
   EndFrame();
   TryToReturnBitstreamBuffer();
 }
 
 void VaapiVideoEncodeAccelerator::UseOutputBitstreamBuffer(
     const media::BitstreamBuffer& buffer) {
   DVLOGF(4) << "id: " << buffer.id();
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (buffer.size() < output_buffer_byte_size_) {
     NOTIFY_ERROR(kInvalidArgumentError, "Provided bitstream buffer too small");
     return;
   }
 
   scoped_ptr<base::SharedMemory> shm(
       new base::SharedMemory(buffer.handle(), false));
   if (!shm->Map(buffer.size())) {
     NOTIFY_ERROR(kPlatformFailureError, "Failed mapping shared memory.");
@@ skipping 16 matching lines @@
   DCHECK_NE(state_, kUninitialized);
 
   available_bitstream_buffers_.push(make_linked_ptr(buffer_ref.release()));
   TryToReturnBitstreamBuffer();
 }
 
 void VaapiVideoEncodeAccelerator::RequestEncodingParametersChange(
     uint32 bitrate,
     uint32 framerate) {
   DVLOGF(2) << "bitrate: " << bitrate << " framerate: " << framerate;
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   encoder_thread_proxy_->PostTask(
       FROM_HERE,
       base::Bind(
           &VaapiVideoEncodeAccelerator::RequestEncodingParametersChangeTask,
           base::Unretained(this),
           bitrate,
           framerate));
 }
 
@@ skipping 31 matching lines @@
   UpdateRates(bitrate, framerate);
 
   UpdateSPS();
   GeneratePackedSPS();
 
   // Submit new parameters along with next frame that will be processed.
   encoding_parameters_changed_ = true;
 }
 
 void VaapiVideoEncodeAccelerator::Destroy() {
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   // Can't call client anymore after Destroy() returns.
   client_ptr_factory_.reset();
   weak_this_ptr_factory_.InvalidateWeakPtrs();
 
   // Early-exit encoder tasks if they are running and join the thread.
   if (encoder_thread_.IsRunning()) {
     encoder_thread_.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&VaapiVideoEncodeAccelerator::DestroyTask,
@@ skipping 277 matching lines @@
                    base::Unretained(this),
                    state));
     return;
   }
 
   DVLOGF(1) << "setting state to: " << state;
   state_ = state;
 }
 
 void VaapiVideoEncodeAccelerator::NotifyError(Error error) {
-  if (!child_message_loop_proxy_->BelongsToCurrentThread()) {
-    child_message_loop_proxy_->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &VaapiVideoEncodeAccelerator::NotifyError, weak_this_, error));
+  if (!child_task_runner_->BelongsToCurrentThread()) {
+    child_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&VaapiVideoEncodeAccelerator::NotifyError,
+                              weak_this_, error));
     return;
   }
 
   if (client_) {
     client_->NotifyError(error);
     client_ptr_factory_.reset();
   }
 }
 
 VaapiVideoEncodeAccelerator::EncodeJob::EncodeJob()
     : coded_buffer(VA_INVALID_ID), keyframe(false) {
 }
 
 VaapiVideoEncodeAccelerator::EncodeJob::~EncodeJob() {
 }
 
 }  // namespace content