Replace MessageLoopProxy with SingleThreadTaskRunner for the rest of media/.

media/video/capture/video_capture_proxy.cc

 // Copyright (c) 2011 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 "media/video/capture/video_capture_proxy.h"
 
 #include "base/bind.h"
 #include "base/location.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "media/base/video_frame.h"
 
 namespace {
 
 // Called on VC thread: extracts the state out of the VideoCapture, and
 // serialize it into a VideoCaptureState.
 media::VideoCaptureHandlerProxy::VideoCaptureState GetState(
     media::VideoCapture* capture) {
   media::VideoCaptureHandlerProxy::VideoCaptureState state;
   state.started = capture->CaptureStarted();
   state.frame_rate = capture->CaptureFrameRate();
   return state;
 }
 
 }  // anonymous namespace
 
 namespace media {
 
 VideoCaptureHandlerProxy::VideoCaptureHandlerProxy(
     VideoCapture::EventHandler* proxied,
-    scoped_refptr<base::MessageLoopProxy> main_message_loop)
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner)
     : proxied_(proxied),
-      main_message_loop_(main_message_loop) {
+      main_task_runner_(main_task_runner) {
 }
 
 VideoCaptureHandlerProxy::~VideoCaptureHandlerProxy() {
 }
 
 void VideoCaptureHandlerProxy::OnStarted(VideoCapture* capture) {
-  main_message_loop_->PostTask(FROM_HERE, base::Bind(
+  main_task_runner_->PostTask(FROM_HERE, base::Bind(
         &VideoCaptureHandlerProxy::OnStartedOnMainThread,
         base::Unretained(this),
         capture,
         GetState(capture)));
 }
 
 void VideoCaptureHandlerProxy::OnStopped(VideoCapture* capture) {
-  main_message_loop_->PostTask(FROM_HERE, base::Bind(
+  main_task_runner_->PostTask(FROM_HERE, base::Bind(
         &VideoCaptureHandlerProxy::OnStoppedOnMainThread,
         base::Unretained(this),
         capture,
         GetState(capture)));
 }
 
 void VideoCaptureHandlerProxy::OnPaused(VideoCapture* capture) {
-  main_message_loop_->PostTask(FROM_HERE, base::Bind(
+  main_task_runner_->PostTask(FROM_HERE, base::Bind(
       &VideoCaptureHandlerProxy::OnPausedOnMainThread,
       base::Unretained(this),
       capture,
       GetState(capture)));
 }
 
 void VideoCaptureHandlerProxy::OnError(VideoCapture* capture, int error_code) {
-  main_message_loop_->PostTask(FROM_HERE, base::Bind(
+  main_task_runner_->PostTask(FROM_HERE, base::Bind(
       &VideoCaptureHandlerProxy::OnErrorOnMainThread,
       base::Unretained(this),
       capture,
       GetState(capture),
       error_code));
 }
 
 void VideoCaptureHandlerProxy::OnRemoved(VideoCapture* capture) {
-  main_message_loop_->PostTask(FROM_HERE, base::Bind(
+  main_task_runner_->PostTask(FROM_HERE, base::Bind(
       &VideoCaptureHandlerProxy::OnRemovedOnMainThread,
       base::Unretained(this),
       capture,
       GetState(capture)));
 }
 
 void VideoCaptureHandlerProxy::OnFrameReady(
     VideoCapture* capture,
     const scoped_refptr<VideoFrame>& frame) {
-  main_message_loop_->PostTask(
+  main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureHandlerProxy::OnFrameReadyOnMainThread,
                  base::Unretained(this),
                  capture,
                  GetState(capture),
                  frame));
 }
 
 void VideoCaptureHandlerProxy::OnStartedOnMainThread(
     VideoCapture* capture,
@@ skipping 33 matching lines @@
 
 void VideoCaptureHandlerProxy::OnFrameReadyOnMainThread(
     VideoCapture* capture,
     const VideoCaptureState& state,
     const scoped_refptr<VideoFrame>& frame) {
   state_ = state;
   proxied_->OnFrameReady(capture, frame);
 }
 
 }  // namespace media