Replace MessageLoopProxy with SingleThreadTaskRunner for media/filters/ + associated code.

content/renderer/media/rtc_video_encoder.cc

 // Copyright 2013 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/media/rtc_video_encoder.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 483 matching lines @@
            << ", width=" << codec_settings->width
            << ", height=" << codec_settings->height
            << ", startBitrate=" << codec_settings->startBitrate;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!impl_);
 
   weak_this_factory_.InvalidateWeakPtrs();
   impl_ = new Impl(weak_this_factory_.GetWeakPtr(), gpu_factories_);
   base::WaitableEvent initialization_waiter(true, false);
   int32_t initialization_retval = WEBRTC_VIDEO_CODEC_UNINITIALIZED;
-  gpu_factories_->GetMessageLoop()->PostTask(
+  gpu_factories_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&RTCVideoEncoder::Impl::CreateAndInitializeVEA,
                  impl_,
                  gfx::Size(codec_settings->width, codec_settings->height),
                  codec_settings->startBitrate,
                  video_codec_profile_,
                  &initialization_waiter,
                  &initialization_retval));
 
   // webrtc::VideoEncoder expects this call to be synchronous.
   initialization_waiter.Wait();
   RecordInitEncodeUMA(initialization_retval);
   return initialization_retval;
 }
 
 int32_t RTCVideoEncoder::Encode(
     const webrtc::I420VideoFrame& input_image,
     const webrtc::CodecSpecificInfo* codec_specific_info,
     const std::vector<webrtc::VideoFrameType>* frame_types) {
   DVLOG(3) << "Encode()";
   // TODO(sheu): figure out why this check fails.
   // DCHECK(thread_checker_.CalledOnValidThread());
   if (!impl_) {
     DVLOG(3) << "Encode(): returning impl_status_=" << impl_status_;
     return impl_status_;
   }
 
   base::WaitableEvent encode_waiter(true, false);
   int32_t encode_retval = WEBRTC_VIDEO_CODEC_UNINITIALIZED;
-  gpu_factories_->GetMessageLoop()->PostTask(
+  gpu_factories_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&RTCVideoEncoder::Impl::Enqueue,
                  impl_,
                  &input_image,
                  (frame_types->front() == webrtc::kKeyFrame),
                  &encode_waiter,
                  &encode_retval));
 
   // webrtc::VideoEncoder expects this call to be synchronous.
   encode_waiter.Wait();
@@ skipping 15 matching lines @@
 }
 
 int32_t RTCVideoEncoder::Release() {
   DVLOG(3) << "Release()";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Reset the gpu_factory_, in case we reuse this encoder.
   gpu_factories_->Abort();
   gpu_factories_ = gpu_factories_->Clone();
   if (impl_) {
-    gpu_factories_->GetMessageLoop()->PostTask(
+    gpu_factories_->GetTaskRunner()->PostTask(
         FROM_HERE, base::Bind(&RTCVideoEncoder::Impl::Destroy, impl_));
     impl_ = NULL;
     weak_this_factory_.InvalidateWeakPtrs();
     impl_status_ = WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t RTCVideoEncoder::SetChannelParameters(uint32_t packet_loss, int rtt) {
   DVLOG(3) << "SetChannelParameters(): packet_loss=" << packet_loss
            << ", rtt=" << rtt;
   DCHECK(thread_checker_.CalledOnValidThread());
   // Ignored.
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t RTCVideoEncoder::SetRates(uint32_t new_bit_rate, uint32_t frame_rate) {
   DVLOG(3) << "SetRates(): new_bit_rate=" << new_bit_rate
            << ", frame_rate=" << frame_rate;
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!impl_) {
     DVLOG(3) << "SetRates(): returning " << impl_status_;
     return impl_status_;
   }
 
-  gpu_factories_->GetMessageLoop()->PostTask(
+  gpu_factories_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&RTCVideoEncoder::Impl::RequestEncodingParametersChange,
                  impl_,
                  new_bit_rate,
                  frame_rate));
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void RTCVideoEncoder::ReturnEncodedImage(scoped_ptr<webrtc::EncodedImage> image,
                                          int32 bitstream_buffer_id) {
@@ skipping 23 matching lines @@
   header.fragmentationTimeDiff[0] = 0;
 
   int32_t retval = encoded_image_callback_->Encoded(*image, &info, &header);
   if (retval < 0) {
     DVLOG(2) << "ReturnEncodedImage(): encoded_image_callback_ returned "
              << retval;
   }
 
   // The call through webrtc::EncodedImageCallback is synchronous, so we can
   // immediately recycle the output buffer back to the Impl.
-  gpu_factories_->GetMessageLoop()->PostTask(
+  gpu_factories_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&RTCVideoEncoder::Impl::UseOutputBitstreamBufferId,
                  impl_,
                  bitstream_buffer_id));
 }
 
 void RTCVideoEncoder::NotifyError(int32_t error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "NotifyError(): error=" << error;
 
   impl_status_ = error;
-  gpu_factories_->GetMessageLoop()->PostTask(
+  gpu_factories_->GetTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&RTCVideoEncoder::Impl::Destroy, impl_));
   impl_ = NULL;
 }
 
 void RTCVideoEncoder::RecordInitEncodeUMA(int32_t init_retval) {
   UMA_HISTOGRAM_BOOLEAN("Media.RTCVideoEncoderInitEncodeSuccess",
                         init_retval == WEBRTC_VIDEO_CODEC_OK);
   if (init_retval == WEBRTC_VIDEO_CODEC_OK) {
     UMA_HISTOGRAM_ENUMERATION("Media.RTCVideoEncoderProfile",
                               video_codec_profile_,
                               media::VIDEO_CODEC_PROFILE_MAX);
   }
 }
 
 }  // namespace content