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

content/common/gpu/media/vaapi_video_decode_accelerator.cc

 // Copyright (c) 2012 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_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
@@ skipping 188 matching lines @@
 };
 
 VaapiVideoDecodeAccelerator::InputBuffer::InputBuffer() : id(0), size(0) {
 }
 
 VaapiVideoDecodeAccelerator::InputBuffer::~InputBuffer() {
 }
 
 void VaapiVideoDecodeAccelerator::NotifyError(Error error) {
   if (message_loop_ != base::MessageLoop::current()) {
-    DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+    DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &VaapiVideoDecodeAccelerator::NotifyError, weak_this_, error));
     return;
   }
 
   // Post Cleanup() as a task so we don't recursively acquire lock_.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &VaapiVideoDecodeAccelerator::Cleanup, weak_this_));
 
   LOG(ERROR) << "Notifying of error " << error;
@@ skipping 80 matching lines @@
   } else if (profile >= media::VP8PROFILE_MIN &&
              profile <= media::VP8PROFILE_MAX) {
     vp8_accelerator_.reset(new VaapiVP8Accelerator(this, vaapi_wrapper_.get()));
     decoder_.reset(new VP8Decoder(vp8_accelerator_.get()));
   } else {
     DLOG(ERROR) << "Unsupported profile " << profile;
     return false;
   }
 
   CHECK(decoder_thread_.Start());
-  decoder_thread_proxy_ = decoder_thread_.message_loop_proxy();
+  decoder_thread_task_runner_ = decoder_thread_.task_runner();
 
   state_ = kIdle;
   return true;
 }
 
 void VaapiVideoDecodeAccelerator::OutputPicture(
     const scoped_refptr<VASurface>& va_surface,
     int32 input_id,
     VaapiPicture* picture) {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
@@ skipping 71 matching lines @@
 
   ++num_stream_bufs_at_decoder_;
   TRACE_COUNTER1("Video Decoder", "Stream buffers at decoder",
                  num_stream_bufs_at_decoder_);
 
   input_buffers_.push(input_buffer);
   input_ready_.Signal();
 }
 
 bool VaapiVideoDecodeAccelerator::GetInputBuffer_Locked() {
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
 
   if (curr_input_buffer_.get())
     return true;
 
   // Will only wait if it is expected that in current state new buffers will
   // be queued from the client via Decode(). The state can change during wait.
   while (input_buffers_.empty() && (state_ == kDecoding || state_ == kIdle)) {
     input_ready_.Wait();
   }
@@ skipping 25 matching lines @@
 
     default:
       // We got woken up due to being destroyed/reset, ignore any already
       // queued inputs.
       return false;
   }
 }
 
 void VaapiVideoDecodeAccelerator::ReturnCurrInputBuffer_Locked() {
   lock_.AssertAcquired();
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK(curr_input_buffer_.get());
 
   int32 id = curr_input_buffer_->id;
   curr_input_buffer_.reset();
   DVLOG(4) << "End of input buffer " << id;
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Client::NotifyEndOfBitstreamBuffer, client_, id));
 
   --num_stream_bufs_at_decoder_;
   TRACE_COUNTER1("Video Decoder", "Stream buffers at decoder",
                  num_stream_bufs_at_decoder_);
 }
 
 // TODO(posciak): refactor the whole class to remove sleeping in wait for
 // surfaces, and reschedule DecodeTask instead.
 bool VaapiVideoDecodeAccelerator::WaitForSurfaces_Locked() {
   lock_.AssertAcquired();
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   while (available_va_surfaces_.empty() &&
          (state_ == kDecoding || state_ == kFlushing || state_ == kIdle)) {
     surfaces_available_.Wait();
   }
 
   if (state_ != kDecoding && state_ != kFlushing && state_ != kIdle)
     return false;
 
   return true;
 }
 
 void VaapiVideoDecodeAccelerator::DecodeTask() {
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT0("Video Decoder", "VAVDA::DecodeTask");
   base::AutoLock auto_lock(lock_);
 
   if (state_ != kDecoding)
     return;
 
   // Main decode task.
   DVLOG(4) << "Decode task";
 
   // Try to decode what stream data is (still) in the decoder until we run out
@@ skipping 112 matching lines @@
   TRACE_EVENT1("Video Decoder", "VAVDA::Decode", "Buffer id",
                bitstream_buffer.id());
 
   // We got a new input buffer from the client, map it and queue for later use.
   MapAndQueueNewInputBuffer(bitstream_buffer);
 
   base::AutoLock auto_lock(lock_);
   switch (state_) {
     case kIdle:
       state_ = kDecoding;
-      decoder_thread_proxy_->PostTask(FROM_HERE, base::Bind(
-          &VaapiVideoDecodeAccelerator::DecodeTask,
-          base::Unretained(this)));
+      decoder_thread_task_runner_->PostTask(
+          FROM_HERE, base::Bind(&VaapiVideoDecodeAccelerator::DecodeTask,
+                                base::Unretained(this)));
       break;
 
     case kDecoding:
       // Decoder already running, fallthrough.
     case kResetting:
       // When resetting, allow accumulating bitstream buffers, so that
       // the client can queue after-seek-buffers while we are finishing with
       // the before-seek one.
       break;
 
@@ skipping 60 matching lines @@
     bool inserted =
         pictures_.insert(std::make_pair(buffers[i].id(), picture)).second;
     DCHECK(inserted);
 
     output_buffers_.push(buffers[i].id());
     available_va_surfaces_.push_back(va_surface_ids[i]);
     surfaces_available_.Signal();
   }
 
   state_ = kDecoding;
-  decoder_thread_proxy_->PostTask(FROM_HERE, base::Bind(
-      &VaapiVideoDecodeAccelerator::DecodeTask, base::Unretained(this)));
+  decoder_thread_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VaapiVideoDecodeAccelerator::DecodeTask,
+                            base::Unretained(this)));
 }
 
 void VaapiVideoDecodeAccelerator::ReusePictureBuffer(int32 picture_buffer_id) {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
   TRACE_EVENT1("Video Decoder", "VAVDA::ReusePictureBuffer", "Picture id",
                picture_buffer_id);
 
   --num_frames_at_client_;
   TRACE_COUNTER1("Video Decoder", "Textures at client", num_frames_at_client_);
 
   output_buffers_.push(picture_buffer_id);
   TryOutputSurface();
 }
 
 void VaapiVideoDecodeAccelerator::FlushTask() {
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << "Flush task";
 
   // First flush all the pictures that haven't been outputted, notifying the
   // client to output them.
   bool res = decoder_->Flush();
   RETURN_AND_NOTIFY_ON_FAILURE(res, "Failed flushing the decoder.",
                                PLATFORM_FAILURE, );
 
   // Put the decoder in idle state, ready to resume.
   decoder_->Reset();
 
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &VaapiVideoDecodeAccelerator::FinishFlush, weak_this_));
 }
 
 void VaapiVideoDecodeAccelerator::Flush() {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
   DVLOG(1) << "Got flush request";
 
   base::AutoLock auto_lock(lock_);
   state_ = kFlushing;
   // Queue a flush task after all existing decoding tasks to clean up.
-  decoder_thread_proxy_->PostTask(FROM_HERE, base::Bind(
-      &VaapiVideoDecodeAccelerator::FlushTask, base::Unretained(this)));
+  decoder_thread_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VaapiVideoDecodeAccelerator::FlushTask,
+                            base::Unretained(this)));
 
   input_ready_.Signal();
   surfaces_available_.Signal();
 }
 
 void VaapiVideoDecodeAccelerator::FinishFlush() {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 
   finish_flush_pending_ = false;
 
@@ skipping 12 matching lines @@
 
   state_ = kIdle;
 
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Client::NotifyFlushDone, client_));
 
   DVLOG(1) << "Flush finished";
 }
 
 void VaapiVideoDecodeAccelerator::ResetTask() {
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << "ResetTask";
 
   // All the decoding tasks from before the reset request from client are done
   // by now, as this task was scheduled after them and client is expected not
   // to call Decode() after Reset() and before NotifyResetDone.
   decoder_->Reset();
 
   base::AutoLock auto_lock(lock_);
 
   // Return current input buffer, if present.
@@ skipping 15 matching lines @@
   finish_flush_pending_ = false;
 
   // Drop all remaining input buffers, if present.
   while (!input_buffers_.empty()) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &Client::NotifyEndOfBitstreamBuffer, client_,
         input_buffers_.front()->id));
     input_buffers_.pop();
   }
 
-  decoder_thread_proxy_->PostTask(FROM_HERE, base::Bind(
-      &VaapiVideoDecodeAccelerator::ResetTask, base::Unretained(this)));
+  decoder_thread_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VaapiVideoDecodeAccelerator::ResetTask,
+                            base::Unretained(this)));
 
   input_ready_.Signal();
   surfaces_available_.Signal();
 }
 
 void VaapiVideoDecodeAccelerator::FinishReset() {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
   DVLOG(1) << "FinishReset";
   base::AutoLock auto_lock(lock_);
 
@@ skipping 22 matching lines @@
       &Client::NotifyResetDone, client_));
 
   // The client might have given us new buffers via Decode() while we were
   // resetting and might be waiting for our move, and not call Decode() anymore
   // until we return something. Post a DecodeTask() so that we won't
   // sleep forever waiting for Decode() in that case. Having two of them
   // in the pipe is harmless, the additional one will return as soon as it sees
   // that we are back in kDecoding state.
   if (!input_buffers_.empty()) {
     state_ = kDecoding;
-    decoder_thread_proxy_->PostTask(FROM_HERE, base::Bind(
-      &VaapiVideoDecodeAccelerator::DecodeTask,
-      base::Unretained(this)));
+    decoder_thread_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&VaapiVideoDecodeAccelerator::DecodeTask,
+                              base::Unretained(this)));
   }
 
   DVLOG(1) << "Reset finished";
 }
 
 void VaapiVideoDecodeAccelerator::Cleanup() {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 
   base::AutoLock auto_lock(lock_);
   if (state_ == kUninitialized || state_ == kDestroying)
@@ skipping 59 matching lines @@
 
   pending_output_cbs_.push(
       base::Bind(&VaapiVideoDecodeAccelerator::OutputPicture, weak_this_,
                  dec_surface->va_surface(), dec_surface->bitstream_id()));
 
   TryOutputSurface();
 }
 
 scoped_refptr<VaapiVideoDecodeAccelerator::VaapiDecodeSurface>
 VaapiVideoDecodeAccelerator::CreateSurface() {
-  DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
 
   if (available_va_surfaces_.empty())
     return nullptr;
 
   DCHECK(!awaiting_va_surfaces_recycle_);
   scoped_refptr<VASurface> va_surface(
       new VASurface(available_va_surfaces_.front(), requested_pic_size_,
                     va_surface_release_cb_));
   available_va_surfaces_.pop_front();
@@ skipping 566 matching lines @@
   return vaapi_pic->dec_surface();
 }
 
 // static
 media::VideoDecodeAccelerator::SupportedProfiles
 VaapiVideoDecodeAccelerator::GetSupportedProfiles() {
   return VaapiWrapper::GetSupportedDecodeProfiles();
 }
 
 }  // namespace content