[chrome/renderer/media] Replace MessageLoopProxy usage with ThreadTaskRunnerHandle

chrome/renderer/media/cast_session.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 "chrome/renderer/media/cast_session.h"
 
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "chrome/renderer/media/cast_session_delegate.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/video_encode_accelerator.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_sender.h"
 #include "media/cast/logging/logging_defines.h"
 
 namespace {
@@ skipping 17 matching lines @@
   if (!shm->Map(size)) {
     NOTREACHED() << "Map failed";
   }
   callback.Run(shm.Pass());
 }
 
 }  // namespace
 
 CastSession::CastSession()
     : delegate_(new CastSessionDelegate()),
-      io_message_loop_proxy_(
+      io_task_runner_(
           content::RenderThread::Get()->GetIOMessageLoopProxy()) {}
 
 CastSession::~CastSession() {
   // We should always be able to delete the object on the IO thread.
-  CHECK(io_message_loop_proxy_->DeleteSoon(FROM_HERE, delegate_.release()));
+  CHECK(io_task_runner_->DeleteSoon(FROM_HERE, delegate_.release()));
 }
 
 void CastSession::StartAudio(const media::cast::AudioSenderConfig& config,
                              const AudioFrameInputAvailableCallback& callback,
                              const ErrorCallback& error_callback) {
   DCHECK(content::RenderThread::Get()
              ->GetTaskRunner()->BelongsToCurrentThread());
 
-  io_message_loop_proxy_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CastSessionDelegate::StartAudio,
                  base::Unretained(delegate_.get()),
                  config,
                  media::BindToCurrentLoop(callback),
                  media::BindToCurrentLoop(error_callback)));
 }
 
 void CastSession::StartVideo(const media::cast::VideoSenderConfig& config,
                              const VideoFrameInputAvailableCallback& callback,
                              const ErrorCallback& error_callback) {
   DCHECK(content::RenderThread::Get()
              ->GetTaskRunner()->BelongsToCurrentThread());
 
-  io_message_loop_proxy_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CastSessionDelegate::StartVideo,
                  base::Unretained(delegate_.get()),
                  config,
                  media::BindToCurrentLoop(callback),
                  media::BindToCurrentLoop(error_callback),
                  media::BindToCurrentLoop(
                      base::Bind(&CreateVideoEncodeAccelerator)),
                  media::BindToCurrentLoop(
                      base::Bind(&CreateVideoEncodeMemory))));
 }
 
 void CastSession::StartUDP(const net::IPEndPoint& remote_endpoint,
                            scoped_ptr<base::DictionaryValue> options,
                            const ErrorCallback& error_callback) {
-  io_message_loop_proxy_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &CastSessionDelegate::StartUDP,
           base::Unretained(delegate_.get()),
           net::IPEndPoint(),
           remote_endpoint,
           base::Passed(&options),
           media::BindToCurrentLoop(error_callback)));
 }
 
 void CastSession::ToggleLogging(bool is_audio, bool enable) {
-  io_message_loop_proxy_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CastSessionDelegate::ToggleLogging,
                  base::Unretained(delegate_.get()),
                  is_audio,
                  enable));
 }
 
 void CastSession::GetEventLogsAndReset(
     bool is_audio, const std::string& extra_data,
     const EventLogsCallback& callback) {
-  io_message_loop_proxy_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CastSessionDelegate::GetEventLogsAndReset,
                  base::Unretained(delegate_.get()),
                  is_audio,
                  extra_data,
                  media::BindToCurrentLoop(callback)));
 }
 
 void CastSession::GetStatsAndReset(bool is_audio,
                                    const StatsCallback& callback) {
-  io_message_loop_proxy_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CastSessionDelegate::GetStatsAndReset,
                  base::Unretained(delegate_.get()),
                  is_audio,
                  media::BindToCurrentLoop(callback)));
 }