Change media MessageLoopProxy usage to SingleThreadTaskRunners.

content/renderer/pepper/video_decoder_shim.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/renderer/pepper/video_decoder_shim.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
 #include "base/bind.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/single_thread_task_runner.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/renderer/pepper/pepper_video_decoder_host.h"
 #include "content/renderer/render_thread_impl.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/limits.h"
 #include "media/base/video_decoder.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "media/filters/vpx_video_decoder.h"
 #include "media/video/picture.h"
@@ skipping 264 matching lines @@
 }
 
 void VideoDecoderShim::DecoderImpl::OnResetComplete() {
   main_message_loop_->PostTask(
       FROM_HERE, base::Bind(&VideoDecoderShim::OnResetComplete, shim_));
 }
 
 VideoDecoderShim::VideoDecoderShim(PepperVideoDecoderHost* host)
     : state_(UNINITIALIZED),
       host_(host),
-      media_message_loop_(
-          RenderThreadImpl::current()->GetMediaThreadMessageLoopProxy()),
+      media_task_runner_(
+          RenderThreadImpl::current()->GetMediaThreadTaskRunner()),
       context_provider_(
           RenderThreadImpl::current()->SharedMainThreadContextProvider()),
       texture_pool_size_(0),
       num_pending_decodes_(0),
       weak_ptr_factory_(this) {
   DCHECK(host_);
-  DCHECK(media_message_loop_.get());
+  DCHECK(media_task_runner_.get());
   DCHECK(context_provider_.get());
   decoder_impl_.reset(new DecoderImpl(weak_ptr_factory_.GetWeakPtr()));
 }
 
 VideoDecoderShim::~VideoDecoderShim() {
   DCHECK(RenderThreadImpl::current());
   // Delete any remaining textures.
   TextureIdMap::iterator it = texture_id_map_.begin();
   for (; it != texture_id_map_.end(); ++it)
     DeleteTexture(it->second);
   texture_id_map_.clear();
 
   FlushCommandBuffer();
 
   weak_ptr_factory_.InvalidateWeakPtrs();
   // No more callbacks from the delegate will be received now.
 
   // The callback now holds the only reference to the DecoderImpl, which will be
   // deleted when Stop completes.
-  media_message_loop_->PostTask(
+  media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoDecoderShim::DecoderImpl::Stop,
                  base::Owned(decoder_impl_.release())));
 }
 
 bool VideoDecoderShim::Initialize(
     media::VideoCodecProfile profile,
     media::VideoDecodeAccelerator::Client* client) {
   DCHECK_EQ(client, host_);
   DCHECK(RenderThreadImpl::current());
@@ skipping 11 matching lines @@
       codec,
       profile,
       media::VideoFrame::YV12,
       gfx::Size(32, 24),  // Small sizes that won't fail.
       gfx::Rect(32, 24),
       gfx::Size(32, 24),
       NULL /* extra_data */,  // TODO(bbudge) Verify this isn't needed.
       0 /* extra_data_size */,
       false /* decryption */);
 
-  media_message_loop_->PostTask(
+  media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoDecoderShim::DecoderImpl::Initialize,
                  base::Unretained(decoder_impl_.get()),
                  config));
   // Return success, even though we are asynchronous, to mimic
   // media::VideoDecodeAccelerator.
   return true;
 }
 
 void VideoDecoderShim::Decode(const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK(RenderThreadImpl::current());
   DCHECK_EQ(state_, DECODING);
 
   // We need the address of the shared memory, so we can copy the buffer.
   const uint8_t* buffer = host_->DecodeIdToAddress(bitstream_buffer.id());
   DCHECK(buffer);
 
-  media_message_loop_->PostTask(
+  media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &VideoDecoderShim::DecoderImpl::Decode,
           base::Unretained(decoder_impl_.get()),
           bitstream_buffer.id(),
           media::DecoderBuffer::CopyFrom(buffer, bitstream_buffer.size())));
   num_pending_decodes_++;
 }
 
 void VideoDecoderShim::AssignPictureBuffers(
@@ skipping 36 matching lines @@
 void VideoDecoderShim::Flush() {
   DCHECK(RenderThreadImpl::current());
   DCHECK_EQ(state_, DECODING);
   state_ = FLUSHING;
 }
 
 void VideoDecoderShim::Reset() {
   DCHECK(RenderThreadImpl::current());
   DCHECK_EQ(state_, DECODING);
   state_ = RESETTING;
-  media_message_loop_->PostTask(
+  media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoDecoderShim::DecoderImpl::Reset,
                  base::Unretained(decoder_impl_.get())));
 }
 
 void VideoDecoderShim::Destroy() {
   // This will be called, but our destructor does the actual work.
 }
 
 void VideoDecoderShim::OnInitializeComplete(int32_t result,
@@ skipping 144 matching lines @@
 void VideoDecoderShim::DeleteTexture(uint32_t texture_id) {
   gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
   gles2->DeleteTextures(1, &texture_id);
 }
 
 void VideoDecoderShim::FlushCommandBuffer() {
   context_provider_->ContextGL()->Flush();
 }
 
 }  // namespace content