Revert of 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_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      child_message_loop_proxy_(base::MessageLoopProxy::current()),
       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_task_runner_->BelongsToCurrentThread());
+  DCHECK(child_message_loop_proxy_->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_task_runner_->BelongsToCurrentThread());
+  DCHECK(child_message_loop_proxy_->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_task_runner_ = encoder_thread_.task_runner();
+  encoder_thread_proxy_ = encoder_thread_.message_loop_proxy();
 
   // Finish the remaining initialization on the encoder thread.
-  encoder_thread_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&VaapiVideoEncodeAccelerator::InitializeTask,
-                            base::Unretained(this)));
+  encoder_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&VaapiVideoEncodeAccelerator::InitializeTask,
+                 base::Unretained(this)));
 
   return true;
 }
 
 void VaapiVideoEncodeAccelerator::InitializeTask() {
-  DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kUninitialized);
   DVLOGF(4);
 
   va_surface_release_cb_ = media::BindToCurrentLoop(
       base::Bind(&VaapiVideoEncodeAccelerator::RecycleVASurfaceID,
                  base::Unretained(this)));
 
   if (!vaapi_wrapper_->CreateSurfaces(
           coded_size_, kNumSurfaces, &available_va_surface_ids_)) {
     NOTIFY_ERROR(kPlatformFailureError, "Failed creating VASurfaces");
     return;
   }
 
   UpdateSPS();
   GeneratePackedSPS();
 
   UpdatePPS();
   GeneratePackedPPS();
 
-  child_task_runner_->PostTask(
+  child_message_loop_proxy_->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_task_runner_->BelongsToCurrentThread());
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
 
   available_va_surface_ids_.push_back(va_surface_id);
   EncodeFrameTask();
 }
 
 void VaapiVideoEncodeAccelerator::BeginFrame(bool force_keyframe) {
   current_pic_ = new H264Picture();
 
   // If the current picture is an IDR picture, frame_num shall be equal to 0.
   if (force_keyframe)
@@ skipping 251 matching lines @@
       current_encode_job_->input_surface->id());
 }
 
 bool VaapiVideoEncodeAccelerator::UploadFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
   return vaapi_wrapper_->UploadVideoFrameToSurface(
       frame, current_encode_job_->input_surface->id());
 }
 
 void VaapiVideoEncodeAccelerator::TryToReturnBitstreamBuffer() {
-  DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
 
   if (state_ != kEncoding)
     return;
 
   if (submitted_encode_jobs_.empty() || available_bitstream_buffers_.empty())
     return;
 
   linked_ptr<BitstreamBufferRef> buffer = available_bitstream_buffers_.front();
   available_bitstream_buffers_.pop();
 
@@ skipping 10 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_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&Client::BitstreamBufferReady, client_, buffer->id,
-                            data_size, encode_job->keyframe));
+  child_message_loop_proxy_->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_task_runner_->BelongsToCurrentThread());
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
 
-  encoder_thread_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&VaapiVideoEncodeAccelerator::EncodeTask,
-                            base::Unretained(this), frame, force_keyframe));
+  encoder_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&VaapiVideoEncodeAccelerator::EncodeTask,
+                 base::Unretained(this),
+                 frame,
+                 force_keyframe));
 }
 
 bool VaapiVideoEncodeAccelerator::PrepareNextJob() {
   if (available_va_surface_ids_.size() < kMinSurfacesToEncode)
     return false;
 
   DCHECK(!current_encode_job_);
   current_encode_job_.reset(new EncodeJob());
 
   if (!vaapi_wrapper_->CreateCodedBuffer(output_buffer_byte_size_,
@@ skipping 14 matching lines @@
   // removed from ref_pic_list0_ when it's full at the end of job submission.
   // Keep refs to them along with the job and only release after sync.
   current_encode_job_->reference_surfaces = ref_pic_list0_;
 
   return true;
 }
 
 void VaapiVideoEncodeAccelerator::EncodeTask(
     const scoped_refptr<media::VideoFrame>& frame,
     bool force_keyframe) {
-  DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
   DCHECK_NE(state_, kUninitialized);
 
   encoder_input_queue_.push(
       make_linked_ptr(new InputFrameRef(frame, force_keyframe)));
   EncodeFrameTask();
 }
 
 void VaapiVideoEncodeAccelerator::EncodeFrameTask() {
-  DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
 
   if (state_ != kEncoding || encoder_input_queue_.empty())
     return;
 
   if (!PrepareNextJob()) {
     DVLOGF(4) << "Not ready for next frame yet";
     return;
   }
 
   linked_ptr<InputFrameRef> frame_ref = encoder_input_queue_.front();
@@ skipping 22 matching lines @@
     return;
   }
 
   EndFrame();
   TryToReturnBitstreamBuffer();
 }
 
 void VaapiVideoEncodeAccelerator::UseOutputBitstreamBuffer(
     const media::BitstreamBuffer& buffer) {
   DVLOGF(4) << "id: " << buffer.id();
-  DCHECK(child_task_runner_->BelongsToCurrentThread());
+  DCHECK(child_message_loop_proxy_->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.");
     return;
   }
 
   scoped_ptr<BitstreamBufferRef> buffer_ref(
       new BitstreamBufferRef(buffer.id(), shm.Pass(), buffer.size()));
 
-  encoder_thread_task_runner_->PostTask(
+  encoder_thread_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&VaapiVideoEncodeAccelerator::UseOutputBitstreamBufferTask,
-                 base::Unretained(this), base::Passed(&buffer_ref)));
+                 base::Unretained(this),
+                 base::Passed(&buffer_ref)));
 }
 
 void VaapiVideoEncodeAccelerator::UseOutputBitstreamBufferTask(
     scoped_ptr<BitstreamBufferRef> buffer_ref) {
-  DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
   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_task_runner_->BelongsToCurrentThread());
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
 
-  encoder_thread_task_runner_->PostTask(
+  encoder_thread_proxy_->PostTask(
       FROM_HERE,
       base::Bind(
           &VaapiVideoEncodeAccelerator::RequestEncodingParametersChangeTask,
-          base::Unretained(this), bitrate, framerate));
+          base::Unretained(this),
+          bitrate,
+          framerate));
 }
 
 void VaapiVideoEncodeAccelerator::UpdateRates(uint32 bitrate,
                                               uint32 framerate) {
   if (encoder_thread_.IsRunning())
-    DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
+    DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
   DCHECK_NE(bitrate, 0u);
   DCHECK_NE(framerate, 0u);
   bitrate_ = bitrate;
   framerate_ = framerate;
   cpb_size_ = bitrate_ * kCPBWindowSizeMs / 1000;
 }
 
 void VaapiVideoEncodeAccelerator::RequestEncodingParametersChangeTask(
     uint32 bitrate,
     uint32 framerate) {
   DVLOGF(2) << "bitrate: " << bitrate << " framerate: " << framerate;
-  DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
   DCHECK_NE(state_, kUninitialized);
 
   // This is a workaround to zero being temporarily, as part of the initial
   // setup, provided by the webrtc video encode and a zero bitrate and
   // framerate not being accepted by VAAPI
   // TODO: This code is common with v4l2_video_encode_accelerator.cc, perhaps
   // it could be pulled up to RTCVideoEncoder
   if (bitrate < 1)
     bitrate = 1;
   if (framerate < 1)
     framerate = 1;
 
   if (bitrate_ == bitrate && framerate_ == framerate)
     return;
 
   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_task_runner_->BelongsToCurrentThread());
+  DCHECK(child_message_loop_proxy_->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,
                    base::Unretained(this)));
     encoder_thread_.Stop();
   }
 
   delete this;
 }
 
 void VaapiVideoEncodeAccelerator::DestroyTask() {
   DVLOGF(2);
-  DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
   SetState(kError);
 }
 
 void VaapiVideoEncodeAccelerator::UpdateSPS() {
   memset(&current_sps_, 0, sizeof(media::H264SPS));
 
   // Spec A.2 and A.3.
   switch (profile_) {
     case media::H264PROFILE_BASELINE:
       // Due to crbug.com/345569, we don't distinguish between constrained
@@ skipping 243 matching lines @@
   packed_pps_.AppendBool(current_pps_.pic_scaling_matrix_present_flag);
   DCHECK(!current_pps_.pic_scaling_matrix_present_flag);
   packed_pps_.AppendSE(current_pps_.second_chroma_qp_index_offset);
 
   packed_pps_.FinishNALU();
 }
 
 void VaapiVideoEncodeAccelerator::SetState(State state) {
   // Only touch state on encoder thread, unless it's not running.
   if (encoder_thread_.IsRunning() &&
-      !encoder_thread_task_runner_->BelongsToCurrentThread()) {
-    encoder_thread_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&VaapiVideoEncodeAccelerator::SetState,
-                              base::Unretained(this), state));
+      !encoder_thread_proxy_->BelongsToCurrentThread()) {
+    encoder_thread_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&VaapiVideoEncodeAccelerator::SetState,
+                   base::Unretained(this),
+                   state));
     return;
   }
 
   DVLOGF(1) << "setting state to: " << state;
   state_ = state;
 }
 
 void VaapiVideoEncodeAccelerator::NotifyError(Error error) {
-  if (!child_task_runner_->BelongsToCurrentThread()) {
-    child_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&VaapiVideoEncodeAccelerator::NotifyError,
-                              weak_this_, error));
+  if (!child_message_loop_proxy_->BelongsToCurrentThread()) {
+    child_message_loop_proxy_->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