Change media MessageLoopProxy usage to SingleThreadTaskRunners.

Changing WebMediaPlayerImpl and related media code to use task runners
instead of MessageLoopProxy to avoid presubmit errors when moving this
code to media/blink. There is no functional change here. Just making the
tools happy. :)

BUG=408338

Review URL: https://codereview.chromium.org/508293003

Cr-Commit-Position: refs/heads/master@{#292389}

19 files changed, 219 insertions, 208 deletions

diff --git a/content/renderer/media/android/media_source_delegate.cc b/content/renderer/media/android/media_source_delegate.cc
index 9024712..93e46aa 100644
--- a/content/renderer/media/android/media_source_delegate.cc
+++ b/content/renderer/media/android/media_source_delegate.cc
@@ -48,7 +48,7 @@ static void LogMediaSourceError(const scoped_refptr<media::MediaLog>& media_log,
 MediaSourceDelegate::MediaSourceDelegate(
     RendererDemuxerAndroid* demuxer_client,
     int demuxer_client_id,
-    const scoped_refptr<base::MessageLoopProxy>& media_loop,
+    const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const scoped_refptr<media::MediaLog> media_log)
     : demuxer_client_(demuxer_client),
       demuxer_client_id_(demuxer_client_id),
@@ -62,16 +62,16 @@ MediaSourceDelegate::MediaSourceDelegate(
       browser_seek_time_(media::kNoTimestamp()),
       expecting_regular_seek_(false),
       access_unit_size_(0),
-      main_loop_(base::MessageLoopProxy::current()),
-      media_loop_(media_loop),
+      main_task_runner_(base::MessageLoopProxy::current()),
+      media_task_runner_(media_task_runner),
       main_weak_factory_(this),
       media_weak_factory_(this),
       main_weak_this_(main_weak_factory_.GetWeakPtr()) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 }
 
 MediaSourceDelegate::~MediaSourceDelegate() {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
   DCHECK(!chunk_demuxer_);
   DCHECK(!demuxer_client_);
@@ -82,7 +82,7 @@ MediaSourceDelegate::~MediaSourceDelegate() {
 }
 
 void MediaSourceDelegate::Destroy() {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
 
   if (!chunk_demuxer_) {
@@ -103,19 +103,19 @@ void MediaSourceDelegate::Destroy() {
   // |this| will be transferred to the callback StopDemuxer() and
   // OnDemuxerStopDone(). They own |this| and OnDemuxerStopDone() will delete
   // it when called, hence using base::Unretained(this) is safe here.
-  media_loop_->PostTask(FROM_HERE,
+  media_task_runner_->PostTask(FROM_HERE,
                         base::Bind(&MediaSourceDelegate::StopDemuxer,
                         base::Unretained(this)));
 }
 
 bool MediaSourceDelegate::IsVideoEncrypted() {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(is_video_encrypted_lock_);
   return is_video_encrypted_;
 }
 
 base::Time MediaSourceDelegate::GetTimelineOffset() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   if (!chunk_demuxer_)
     return base::Time();
 
@@ -123,7 +123,7 @@ base::Time MediaSourceDelegate::GetTimelineOffset() const {
 }
 
 void MediaSourceDelegate::StopDemuxer() {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DCHECK(chunk_demuxer_);
 
   demuxer_client_->RemoveDelegate(demuxer_client_id_);
@@ -151,7 +151,7 @@ void MediaSourceDelegate::InitializeMediaSource(
     const media::SetDecryptorReadyCB& set_decryptor_ready_cb,
     const UpdateNetworkStateCB& update_network_state_cb,
     const DurationChangeCB& duration_change_cb) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(!media_source_opened_cb.is_null());
   media_source_opened_cb_ = media_source_opened_cb;
   need_key_cb_ = need_key_cb;
@@ -170,13 +170,13 @@ void MediaSourceDelegate::InitializeMediaSource(
 
   // |this| will be retained until StopDemuxer() is posted, so Unretained() is
   // safe here.
-  media_loop_->PostTask(FROM_HERE,
+  media_task_runner_->PostTask(FROM_HERE,
                         base::Bind(&MediaSourceDelegate::InitializeDemuxer,
                         base::Unretained(this)));
 }
 
 void MediaSourceDelegate::InitializeDemuxer() {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   demuxer_client_->AddDelegate(demuxer_client_id_, this);
   chunk_demuxer_->Initialize(this,
                              base::Bind(&MediaSourceDelegate::OnDemuxerInitDone,
@@ -205,7 +205,7 @@ size_t MediaSourceDelegate::VideoDecodedByteCount() const {
 }
 
 void MediaSourceDelegate::CancelPendingSeek(const base::TimeDelta& seek_time) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << "(" << seek_time.InSecondsF() << ") : "
            << demuxer_client_id_;
 
@@ -229,7 +229,7 @@ void MediaSourceDelegate::CancelPendingSeek(const base::TimeDelta& seek_time) {
 
 void MediaSourceDelegate::StartWaitingForSeek(
     const base::TimeDelta& seek_time) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << "(" << seek_time.InSecondsF() << ") : "
            << demuxer_client_id_;
 
@@ -257,7 +257,7 @@ void MediaSourceDelegate::StartWaitingForSeek(
 
 void MediaSourceDelegate::Seek(
     const base::TimeDelta& seek_time, bool is_browser_seek) {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << "(" << seek_time.InSecondsF() << ", "
            << (is_browser_seek ? "browser seek" : "regular seek") << ") : "
            << demuxer_client_id_;
@@ -299,7 +299,7 @@ void MediaSourceDelegate::Seek(
 }
 
 void MediaSourceDelegate::SeekInternal(const base::TimeDelta& seek_time) {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DCHECK(IsSeeking());
   chunk_demuxer_->Seek(seek_time, base::Bind(
       &MediaSourceDelegate::OnDemuxerSeekDone,
@@ -312,18 +312,18 @@ void MediaSourceDelegate::AddBufferedTimeRange(base::TimeDelta start,
 }
 
 void MediaSourceDelegate::SetDuration(base::TimeDelta duration) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << "(" << duration.InSecondsF() << ") : "
            << demuxer_client_id_;
 
   // Force duration change notification to be async to avoid reentrancy into
   // ChunkDemxuer.
-  main_loop_->PostTask(FROM_HERE, base::Bind(
+  main_task_runner_->PostTask(FROM_HERE, base::Bind(
       &MediaSourceDelegate::OnDurationChanged, main_weak_this_, duration));
 }
 
 void MediaSourceDelegate::OnDurationChanged(const base::TimeDelta& duration) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   if (demuxer_client_)
     demuxer_client_->DurationChanged(demuxer_client_id_, duration);
   if (!duration_change_cb_.is_null())
@@ -331,7 +331,7 @@ void MediaSourceDelegate::OnDurationChanged(const base::TimeDelta& duration) {
 }
 
 void MediaSourceDelegate::OnReadFromDemuxer(media::DemuxerStream::Type type) {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << "(" << type << ") : " << demuxer_client_id_;
   if (IsSeeking())
     return;  // Drop the request during seeking.
@@ -348,7 +348,7 @@ void MediaSourceDelegate::OnReadFromDemuxer(media::DemuxerStream::Type type) {
 void MediaSourceDelegate::ReadFromDemuxerStream(media::DemuxerStream::Type type,
                                                 scoped_ptr<DemuxerData> data,
                                                 size_t index) {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   // DemuxerStream::Read() always returns the read callback asynchronously.
   DemuxerStream* stream =
       (type == DemuxerStream::AUDIO) ? audio_stream_ : video_stream_;
@@ -363,7 +363,7 @@ void MediaSourceDelegate::OnBufferReady(
     size_t index,
     DemuxerStream::Status status,
     const scoped_refptr<media::DecoderBuffer>& buffer) {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << "(" << index << ", " << status << ", "
            << ((!buffer || buffer->end_of_stream()) ?
                -1 : buffer->timestamp().InMilliseconds())
@@ -481,7 +481,7 @@ void MediaSourceDelegate::RemoveTextStream(
 }
 
 void MediaSourceDelegate::OnDemuxerInitDone(media::PipelineStatus status) {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << "(" << status << ") : " << demuxer_client_id_;
   DCHECK(chunk_demuxer_);
 
@@ -513,12 +513,12 @@ void MediaSourceDelegate::OnDemuxerInitDone(media::PipelineStatus status) {
 }
 
 void MediaSourceDelegate::InitAudioDecryptingDemuxerStream() {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
   DCHECK(!set_decryptor_ready_cb_.is_null());
 
   audio_decrypting_demuxer_stream_.reset(new media::DecryptingDemuxerStream(
-      media_loop_, set_decryptor_ready_cb_));
+      media_task_runner_, set_decryptor_ready_cb_));
   audio_decrypting_demuxer_stream_->Initialize(
       audio_stream_,
       base::Bind(&MediaSourceDelegate::OnAudioDecryptingDemuxerStreamInitDone,
@@ -526,12 +526,12 @@ void MediaSourceDelegate::InitAudioDecryptingDemuxerStream() {
 }
 
 void MediaSourceDelegate::InitVideoDecryptingDemuxerStream() {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
   DCHECK(!set_decryptor_ready_cb_.is_null());
 
   video_decrypting_demuxer_stream_.reset(new media::DecryptingDemuxerStream(
-      media_loop_, set_decryptor_ready_cb_));
+      media_task_runner_, set_decryptor_ready_cb_));
   video_decrypting_demuxer_stream_->Initialize(
       video_stream_,
       base::Bind(&MediaSourceDelegate::OnVideoDecryptingDemuxerStreamInitDone,
@@ -540,7 +540,7 @@ void MediaSourceDelegate::InitVideoDecryptingDemuxerStream() {
 
 void MediaSourceDelegate::OnAudioDecryptingDemuxerStreamInitDone(
     media::PipelineStatus status) {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << "(" << status << ") : " << demuxer_client_id_;
   DCHECK(chunk_demuxer_);
 
@@ -562,7 +562,7 @@ void MediaSourceDelegate::OnAudioDecryptingDemuxerStreamInitDone(
 
 void MediaSourceDelegate::OnVideoDecryptingDemuxerStreamInitDone(
     media::PipelineStatus status) {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << "(" << status << ") : " << demuxer_client_id_;
   DCHECK(chunk_demuxer_);
 
@@ -577,7 +577,7 @@ void MediaSourceDelegate::OnVideoDecryptingDemuxerStreamInitDone(
 }
 
 void MediaSourceDelegate::OnDemuxerSeekDone(media::PipelineStatus status) {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << "(" << status << ") : " << demuxer_client_id_;
   DCHECK(IsSeeking());
 
@@ -590,7 +590,7 @@ void MediaSourceDelegate::OnDemuxerSeekDone(media::PipelineStatus status) {
 }
 
 void MediaSourceDelegate::ResetAudioDecryptingDemuxerStream() {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
   if (audio_decrypting_demuxer_stream_) {
     audio_decrypting_demuxer_stream_->Reset(
@@ -603,7 +603,7 @@ void MediaSourceDelegate::ResetAudioDecryptingDemuxerStream() {
 }
 
 void MediaSourceDelegate::ResetVideoDecryptingDemuxerStream() {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
   if (video_decrypting_demuxer_stream_) {
     video_decrypting_demuxer_stream_->Reset(base::Bind(
@@ -616,7 +616,7 @@ void MediaSourceDelegate::ResetVideoDecryptingDemuxerStream() {
 }
 
 void MediaSourceDelegate::FinishResettingDecryptingDemuxerStreams() {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
 
   base::AutoLock auto_lock(seeking_lock_);
@@ -627,22 +627,22 @@ void MediaSourceDelegate::FinishResettingDecryptingDemuxerStreams() {
 }
 
 void MediaSourceDelegate::OnDemuxerStopDone() {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
-  main_loop_->PostTask(
+  main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MediaSourceDelegate::DeleteSelf, base::Unretained(this)));
 }
 
 void MediaSourceDelegate::DeleteSelf() {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
   chunk_demuxer_.reset();
   delete this;
 }
 
 void MediaSourceDelegate::NotifyDemuxerReady() {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
   DCHECK(is_demuxer_ready_);
 
@@ -659,7 +659,7 @@ void MediaSourceDelegate::NotifyDemuxerReady() {
 }
 
 base::TimeDelta MediaSourceDelegate::GetDuration() const {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   if (!chunk_demuxer_)
     return media::kNoTimestamp();
 
@@ -671,7 +671,7 @@ base::TimeDelta MediaSourceDelegate::GetDuration() const {
 }
 
 void MediaSourceDelegate::OnDemuxerOpened() {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   if (media_source_opened_cb_.is_null())
     return;
 
@@ -681,7 +681,7 @@ void MediaSourceDelegate::OnDemuxerOpened() {
 
 void MediaSourceDelegate::OnNeedKey(const std::string& type,
                                     const std::vector<uint8>& init_data) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   if (need_key_cb_.is_null())
     return;
 
@@ -736,7 +736,7 @@ base::TimeDelta MediaSourceDelegate::FindBufferedBrowserSeekTime_Locked(
 
 bool MediaSourceDelegate::GetDemuxerConfigFromStream(
     media::DemuxerConfigs* configs, bool is_audio) {
-  DCHECK(media_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   if (!is_demuxer_ready_)
     return false;
   if (is_audio && audio_stream_) {
diff --git a/content/renderer/media/android/media_source_delegate.h b/content/renderer/media/android/media_source_delegate.h
index c208454..d5e62b4 100644
--- a/content/renderer/media/android/media_source_delegate.h
+++ b/content/renderer/media/android/media_source_delegate.h
@@ -12,7 +12,6 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
-#include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "media/base/decryptor.h"
 #include "media/base/demuxer.h"
@@ -22,6 +21,10 @@
 #include "media/base/text_track.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
 
+namespace base {
+class SingleThreadTaskRunner;
+}
+
 namespace media {
 class ChunkDemuxer;
 class DecoderBuffer;
@@ -53,10 +56,11 @@ class MediaSourceDelegate : public media::DemuxerHost {
     }
   };
 
-  MediaSourceDelegate(RendererDemuxerAndroid* demuxer_client,
-                      int demuxer_client_id,
-                      const scoped_refptr<base::MessageLoopProxy>& media_loop,
-                      const scoped_refptr<media::MediaLog> media_log);
+  MediaSourceDelegate(
+      RendererDemuxerAndroid* demuxer_client,
+      int demuxer_client_id,
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+      const scoped_refptr<media::MediaLog> media_log);
 
   // Initialize the MediaSourceDelegate. |media_source| will be owned by
   // this object after this call.
@@ -231,9 +235,9 @@ class MediaSourceDelegate : public media::DemuxerHost {
 
   size_t access_unit_size_;
 
-  // Message loop for main renderer and media threads.
-  const scoped_refptr<base::MessageLoopProxy> main_loop_;
-  const scoped_refptr<base::MessageLoopProxy> media_loop_;
+  // Task runner for main renderer and media threads.
+  const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
+  const scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<MediaSourceDelegate> main_weak_factory_;
diff --git a/content/renderer/media/android/renderer_demuxer_android.cc b/content/renderer/media/android/renderer_demuxer_android.cc
index 586d7fa..6d40b20 100644
--- a/content/renderer/media/android/renderer_demuxer_android.cc
+++ b/content/renderer/media/android/renderer_demuxer_android.cc
@@ -5,8 +5,7 @@
 #include "content/renderer/media/android/renderer_demuxer_android.h"
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/media/media_player_messages_android.h"
 #include "content/renderer/media/android/media_source_delegate.h"
@@ -18,8 +17,8 @@ namespace content {
 
 RendererDemuxerAndroid::RendererDemuxerAndroid()
     : thread_safe_sender_(RenderThreadImpl::current()->thread_safe_sender()),
-      media_message_loop_(
-          RenderThreadImpl::current()->GetMediaThreadMessageLoopProxy()) {}
+      media_task_runner_(
+          RenderThreadImpl::current()->GetMediaThreadTaskRunner()) {}
 
 RendererDemuxerAndroid::~RendererDemuxerAndroid() {}
 
@@ -30,12 +29,12 @@ int RendererDemuxerAndroid::GetNextDemuxerClientID() {
 
 void RendererDemuxerAndroid::AddDelegate(int demuxer_client_id,
                                          MediaSourceDelegate* delegate) {
-  DCHECK(media_message_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   delegates_.AddWithID(delegate, demuxer_client_id);
 }
 
 void RendererDemuxerAndroid::RemoveDelegate(int demuxer_client_id) {
-  DCHECK(media_message_loop_->BelongsToCurrentThread());
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
   delegates_.Remove(demuxer_client_id);
 }
 
@@ -43,7 +42,7 @@ bool RendererDemuxerAndroid::OnMessageReceived(const IPC::Message& message) {
   switch (message.type()) {
     case MediaPlayerMsg_DemuxerSeekRequest::ID:
     case MediaPlayerMsg_ReadFromDemuxer::ID:
-      media_message_loop_->PostTask(FROM_HERE, base::Bind(
+      media_task_runner_->PostTask(FROM_HERE, base::Bind(
           &RendererDemuxerAndroid::DispatchMessage, this, message));
       return true;
    }
diff --git a/content/renderer/media/android/renderer_demuxer_android.h b/content/renderer/media/android/renderer_demuxer_android.h
index 2a92918..99c8cc9 100644
--- a/content/renderer/media/android/renderer_demuxer_android.h
+++ b/content/renderer/media/android/renderer_demuxer_android.h
@@ -11,7 +11,7 @@
 #include "media/base/android/demuxer_stream_player_params.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace content {
@@ -75,7 +75,7 @@ class RendererDemuxerAndroid : public IPC::MessageFilter {
 
   IDMap<MediaSourceDelegate> delegates_;
   scoped_refptr<ThreadSafeSender> thread_safe_sender_;
-  scoped_refptr<base::MessageLoopProxy> media_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererDemuxerAndroid);
 };
diff --git a/content/renderer/media/android/webmediaplayer_android.cc b/content/renderer/media/android/webmediaplayer_android.cc
index e752066..c3d6cec 100644
--- a/content/renderer/media/android/webmediaplayer_android.cc
+++ b/content/renderer/media/android/webmediaplayer_android.cc
@@ -12,8 +12,8 @@
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "cc/blink/web_layer_impl.h"
@@ -115,14 +115,14 @@ WebMediaPlayerAndroid::WebMediaPlayerAndroid(
     RendererMediaPlayerManager* player_manager,
     RendererCdmManager* cdm_manager,
     scoped_refptr<StreamTextureFactory> factory,
-    const scoped_refptr<base::MessageLoopProxy>& media_loop,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     media::MediaLog* media_log)
     : RenderFrameObserver(RenderFrame::FromWebFrame(frame)),
       frame_(frame),
       client_(client),
       delegate_(delegate),
       buffered_(static_cast<size_t>(1)),
-      media_loop_(media_loop),
+      media_task_runner_(task_runner),
       ignore_metadata_duration_change_(false),
       pending_seek_(false),
       seeking_(false),
@@ -224,7 +224,7 @@ void WebMediaPlayerAndroid::load(LoadType load_type,
     demuxer_client_id = demuxer->GetNextDemuxerClientID();
 
     media_source_delegate_.reset(new MediaSourceDelegate(
-        demuxer, demuxer_client_id, media_loop_, media_log_));
+        demuxer, demuxer_client_id, media_task_runner_, media_log_));
 
     if (player_type_ == MEDIA_PLAYER_TYPE_MEDIA_SOURCE) {
       media::SetDecryptorReadyCB set_decryptor_ready_cb =
diff --git a/content/renderer/media/android/webmediaplayer_android.h b/content/renderer/media/android/webmediaplayer_android.h
index 7168fc3..dc3d706 100644
--- a/content/renderer/media/android/webmediaplayer_android.h
+++ b/content/renderer/media/android/webmediaplayer_android.h
@@ -13,6 +13,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "cc/layers/video_frame_provider.h"
 #include "content/common/media/media_player_messages_enums_android.h"
@@ -35,7 +36,7 @@
 #include "ui/gfx/rect_f.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace blink {
@@ -77,14 +78,15 @@ class WebMediaPlayerAndroid : public blink::WebMediaPlayer,
   // player can enter fullscreen. This logic should probably be moved into
   // blink, so that enterFullscreen() will not be called if another video is
   // already in fullscreen.
-  WebMediaPlayerAndroid(blink::WebFrame* frame,
-                        blink::WebMediaPlayerClient* client,
-                        base::WeakPtr<WebMediaPlayerDelegate> delegate,
-                        RendererMediaPlayerManager* player_manager,
-                        RendererCdmManager* cdm_manager,
-                        scoped_refptr<StreamTextureFactory> factory,
-                        const scoped_refptr<base::MessageLoopProxy>& media_loop,
-                        media::MediaLog* media_log);
+  WebMediaPlayerAndroid(
+      blink::WebFrame* frame,
+      blink::WebMediaPlayerClient* client,
+      base::WeakPtr<WebMediaPlayerDelegate> delegate,
+      RendererMediaPlayerManager* player_manager,
+      RendererCdmManager* cdm_manager,
+      scoped_refptr<StreamTextureFactory> factory,
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+      media::MediaLog* media_log);
   virtual ~WebMediaPlayerAndroid();
 
   // blink::WebMediaPlayer implementation.
@@ -346,7 +348,7 @@ class WebMediaPlayerAndroid : public blink::WebMediaPlayer,
   base::ThreadChecker main_thread_checker_;
 
   // Message loop for media thread.
-  const scoped_refptr<base::MessageLoopProxy> media_loop_;
+  const scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
 
   // URL of the media file to be fetched.
   GURL url_;
diff --git a/content/renderer/media/buffered_data_source.cc b/content/renderer/media/buffered_data_source.cc
index e05ec43..5fc0c59 100644
--- a/content/renderer/media/buffered_data_source.cc
+++ b/content/renderer/media/buffered_data_source.cc
@@ -6,7 +6,7 @@
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "content/public/common/url_constants.h"
 #include "media/base/media_log.h"
 #include "net/base/net_errors.h"
@@ -81,7 +81,7 @@ void BufferedDataSource::ReadOperation::Run(
 BufferedDataSource::BufferedDataSource(
     const GURL& url,
     BufferedResourceLoader::CORSMode cors_mode,
-    const scoped_refptr<base::MessageLoopProxy>& render_loop,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     WebFrame* frame,
     media::MediaLog* media_log,
     BufferedDataSourceHost* host,
@@ -93,7 +93,7 @@ BufferedDataSource::BufferedDataSource(
       frame_(frame),
       intermediate_read_buffer_(new uint8[kInitialReadBufferSize]),
       intermediate_read_buffer_size_(kInitialReadBufferSize),
-      render_loop_(render_loop),
+      render_task_runner_(task_runner),
       stop_signal_received_(false),
       media_has_played_(false),
       preload_(AUTO),
@@ -114,7 +114,7 @@ BufferedDataSource::~BufferedDataSource() {}
 // for testing purpose.
 BufferedResourceLoader* BufferedDataSource::CreateResourceLoader(
     int64 first_byte_position, int64 last_byte_position) {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   BufferedResourceLoader::DeferStrategy strategy = preload_ == METADATA ?
       BufferedResourceLoader::kReadThenDefer :
@@ -131,7 +131,7 @@ BufferedResourceLoader* BufferedDataSource::CreateResourceLoader(
 }
 
 void BufferedDataSource::Initialize(const InitializeCB& init_cb) {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
   DCHECK(!init_cb.is_null());
   DCHECK(!loader_.get());
 
@@ -158,12 +158,12 @@ void BufferedDataSource::Initialize(const InitializeCB& init_cb) {
 }
 
 void BufferedDataSource::SetPreload(Preload preload) {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
   preload_ = preload;
 }
 
 bool BufferedDataSource::HasSingleOrigin() {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
   DCHECK(init_cb_.is_null() && loader_.get())
       << "Initialize() must complete before calling HasSingleOrigin()";
   return loader_->HasSingleOrigin();
@@ -174,7 +174,7 @@ bool BufferedDataSource::DidPassCORSAccessCheck() const {
 }
 
 void BufferedDataSource::Abort() {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
   {
     base::AutoLock auto_lock(lock_);
     StopInternal_Locked();
@@ -184,7 +184,7 @@ void BufferedDataSource::Abort() {
 }
 
 void BufferedDataSource::MediaPlaybackRateChanged(float playback_rate) {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
   DCHECK(loader_.get());
 
   if (playback_rate < 0.0f)
@@ -195,13 +195,13 @@ void BufferedDataSource::MediaPlaybackRateChanged(float playback_rate) {
 }
 
 void BufferedDataSource::MediaIsPlaying() {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
   media_has_played_ = true;
   UpdateDeferStrategy(false);
 }
 
 void BufferedDataSource::MediaIsPaused() {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
   UpdateDeferStrategy(true);
 }
 
@@ -213,13 +213,13 @@ void BufferedDataSource::Stop() {
     StopInternal_Locked();
   }
 
-  render_loop_->PostTask(
+  render_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BufferedDataSource::StopLoader, weak_factory_.GetWeakPtr()));
 }
 
 void BufferedDataSource::SetBitrate(int bitrate) {
-  render_loop_->PostTask(FROM_HERE,
+  render_task_runner_->PostTask(FROM_HERE,
                          base::Bind(&BufferedDataSource::SetBitrateTask,
                                     weak_factory_.GetWeakPtr(),
                                     bitrate));
@@ -243,7 +243,7 @@ void BufferedDataSource::Read(
     read_op_.reset(new ReadOperation(position, size, data, read_cb));
   }
 
-  render_loop_->PostTask(
+  render_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BufferedDataSource::ReadTask, weak_factory_.GetWeakPtr()));
 }
@@ -264,7 +264,7 @@ bool BufferedDataSource::IsStreaming() {
 /////////////////////////////////////////////////////////////////////////////
 // Render thread tasks.
 void BufferedDataSource::ReadTask() {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
   ReadInternal();
 }
 
@@ -284,14 +284,14 @@ void BufferedDataSource::StopInternal_Locked() {
 }
 
 void BufferedDataSource::StopLoader() {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   if (loader_)
     loader_->Stop();
 }
 
 void BufferedDataSource::SetBitrateTask(int bitrate) {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
   DCHECK(loader_.get());
 
   bitrate_ = bitrate;
@@ -301,7 +301,7 @@ void BufferedDataSource::SetBitrateTask(int bitrate) {
 // This method is the place where actual read happens, |loader_| must be valid
 // prior to make this method call.
 void BufferedDataSource::ReadInternal() {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
   int64 position = 0;
   int size = 0;
   {
@@ -332,7 +332,7 @@ void BufferedDataSource::ReadInternal() {
 // BufferedResourceLoader callback methods.
 void BufferedDataSource::StartCallback(
     BufferedResourceLoader::Status status) {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
   DCHECK(loader_.get());
 
   bool init_cb_is_null = false;
@@ -389,7 +389,7 @@ void BufferedDataSource::StartCallback(
 
 void BufferedDataSource::PartialReadStartCallback(
     BufferedResourceLoader::Status status) {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
   DCHECK(loader_.get());
 
   if (status == BufferedResourceLoader::kOk) {
@@ -413,7 +413,7 @@ void BufferedDataSource::PartialReadStartCallback(
 void BufferedDataSource::ReadCallback(
     BufferedResourceLoader::Status status,
     int bytes_read) {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   // TODO(scherkus): we shouldn't have to lock to signal host(), see
   // http://crbug.com/113712 for details.
@@ -467,7 +467,7 @@ void BufferedDataSource::ReadCallback(
 
 void BufferedDataSource::LoadingStateChangedCallback(
     BufferedResourceLoader::LoadingState state) {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   if (assume_fully_buffered())
     return;
@@ -495,7 +495,7 @@ void BufferedDataSource::LoadingStateChangedCallback(
 }
 
 void BufferedDataSource::ProgressCallback(int64 position) {
-  DCHECK(render_loop_->BelongsToCurrentThread());
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   if (assume_fully_buffered())
     return;
diff --git a/content/renderer/media/buffered_data_source.h b/content/renderer/media/buffered_data_source.h
index 9a4db0f..a9a8cd3 100644
--- a/content/renderer/media/buffered_data_source.h
+++ b/content/renderer/media/buffered_data_source.h
@@ -18,7 +18,7 @@
 #include "url/gurl.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace media {
@@ -53,13 +53,14 @@ class CONTENT_EXPORT BufferedDataSource : public media::DataSource {
   // |url| and |cors_mode| are passed to the object. Buffered byte range changes
   // will be reported to |host|. |downloading_cb| will be called whenever the
   // downloading/paused state of the source changes.
-  BufferedDataSource(const GURL& url,
-                     BufferedResourceLoader::CORSMode cors_mode,
-                     const scoped_refptr<base::MessageLoopProxy>& render_loop,
-                     blink::WebFrame* frame,
-                     media::MediaLog* media_log,
-                     BufferedDataSourceHost* host,
-                     const DownloadingCB& downloading_cb);
+  BufferedDataSource(
+      const GURL& url,
+      BufferedResourceLoader::CORSMode cors_mode,
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+      blink::WebFrame* frame,
+      media::MediaLog* media_log,
+      BufferedDataSourceHost* host,
+      const DownloadingCB& downloading_cb);
   virtual ~BufferedDataSource();
 
   // Executes |init_cb| with the result of initialization when it has completed.
@@ -190,8 +191,8 @@ class CONTENT_EXPORT BufferedDataSource : public media::DataSource {
   scoped_ptr<uint8[]> intermediate_read_buffer_;
   int intermediate_read_buffer_size_;
 
-  // The message loop of the render thread.
-  const scoped_refptr<base::MessageLoopProxy> render_loop_;
+  // The task runner of the render thread.
+  const scoped_refptr<base::SingleThreadTaskRunner> render_task_runner_;
 
   // Protects |stop_signal_received_| and |read_op_|.
   base::Lock lock_;
diff --git a/content/renderer/media/renderer_gpu_video_accelerator_factories.cc b/content/renderer/media/renderer_gpu_video_accelerator_factories.cc
index 9478556..d90123e 100644
--- a/content/renderer/media/renderer_gpu_video_accelerator_factories.cc
+++ b/content/renderer/media/renderer_gpu_video_accelerator_factories.cc
@@ -25,14 +25,14 @@ namespace content {
 scoped_refptr<RendererGpuVideoAcceleratorFactories>
 RendererGpuVideoAcceleratorFactories::Create(
     GpuChannelHost* gpu_channel_host,
-    const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     const scoped_refptr<ContextProviderCommandBuffer>& context_provider) {
   scoped_refptr<RendererGpuVideoAcceleratorFactories> factories =
       new RendererGpuVideoAcceleratorFactories(
-          gpu_channel_host, message_loop_proxy, context_provider);
+          gpu_channel_host, task_runner, context_provider);
   // Post task from outside constructor, since AddRef()/Release() is unsafe from
   // within.
-  message_loop_proxy->PostTask(
+  task_runner->PostTask(
       FROM_HERE,
       base::Bind(&RendererGpuVideoAcceleratorFactories::BindContext,
                  factories));
@@ -41,9 +41,9 @@ RendererGpuVideoAcceleratorFactories::Create(
 
 RendererGpuVideoAcceleratorFactories::RendererGpuVideoAcceleratorFactories(
     GpuChannelHost* gpu_channel_host,
-    const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     const scoped_refptr<ContextProviderCommandBuffer>& context_provider)
-    : task_runner_(message_loop_proxy),
+    : task_runner_(task_runner),
       gpu_channel_host_(gpu_channel_host),
       context_provider_(context_provider),
       thread_safe_sender_(ChildThread::current()->thread_safe_sender()) {}
diff --git a/content/renderer/media/renderer_gpu_video_accelerator_factories.h b/content/renderer/media/renderer_gpu_video_accelerator_factories.h
index ffbc0ab..e5a405b 100644
--- a/content/renderer/media/renderer_gpu_video_accelerator_factories.h
+++ b/content/renderer/media/renderer_gpu_video_accelerator_factories.h
@@ -32,7 +32,7 @@ class WebGraphicsContext3DCommandBufferImpl;
 //
 // The RendererGpuVideoAcceleratorFactories can be constructed on any thread,
 // but subsequent calls to all public methods of the class must be called from
-// the |message_loop_proxy_|, as provided during construction.
+// the |task_runner_|, as provided during construction.
 class CONTENT_EXPORT RendererGpuVideoAcceleratorFactories
     : public media::GpuVideoAcceleratorFactories {
  public:
@@ -40,7 +40,7 @@ class CONTENT_EXPORT RendererGpuVideoAcceleratorFactories
   // use.  Safe to call from any thread.
   static scoped_refptr<RendererGpuVideoAcceleratorFactories> Create(
       GpuChannelHost* gpu_channel_host,
-      const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy,
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       const scoped_refptr<ContextProviderCommandBuffer>& context_provider);
 
   // media::GpuVideoAcceleratorFactories implementation.
@@ -67,7 +67,7 @@ class CONTENT_EXPORT RendererGpuVideoAcceleratorFactories
   friend class base::RefCountedThreadSafe<RendererGpuVideoAcceleratorFactories>;
   RendererGpuVideoAcceleratorFactories(
       GpuChannelHost* gpu_channel_host,
-      const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy,
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       const scoped_refptr<ContextProviderCommandBuffer>& context_provider);
   virtual ~RendererGpuVideoAcceleratorFactories();
 
diff --git a/content/renderer/media/texttrack_impl.cc b/content/renderer/media/texttrack_impl.cc
index 1e24f9b..565689f 100644
--- a/content/renderer/media/texttrack_impl.cc
+++ b/content/renderer/media/texttrack_impl.cc
@@ -6,7 +6,7 @@
 
 #include "base/bind.h"
 #include "base/location.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "content/renderer/media/webinbandtexttrack_impl.h"
 #include "media/base/bind_to_current_loop.h"
 #include "third_party/WebKit/public/platform/WebInbandTextTrackClient.h"
@@ -15,17 +15,17 @@
 namespace content {
 
 TextTrackImpl::TextTrackImpl(
-    const scoped_refptr<base::MessageLoopProxy>& message_loop,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     blink::WebMediaPlayerClient* client,
     scoped_ptr<WebInbandTextTrackImpl> text_track)
-    : message_loop_(message_loop),
+    : task_runner_(task_runner),
       client_(client),
       text_track_(text_track.Pass()) {
   client_->addTextTrack(text_track_.get());
 }
 
 TextTrackImpl::~TextTrackImpl() {
-  message_loop_->PostTask(
+  task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&TextTrackImpl::OnRemoveTrack,
                  client_,
@@ -37,7 +37,7 @@ void TextTrackImpl::addWebVTTCue(const base::TimeDelta& start,
                                  const std::string& id,
                                  const std::string& content,
                                  const std::string& settings) {
-  message_loop_->PostTask(
+  task_runner_->PostTask(
     FROM_HERE,
     base::Bind(&TextTrackImpl::OnAddCue,
                 text_track_.get(),
diff --git a/content/renderer/media/texttrack_impl.h b/content/renderer/media/texttrack_impl.h
index 3285b60..436d4ea 100644
--- a/content/renderer/media/texttrack_impl.h
+++ b/content/renderer/media/texttrack_impl.h
@@ -12,7 +12,7 @@
 #include "media/base/text_track.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace blink {
@@ -27,7 +27,7 @@ class WebInbandTextTrackImpl;
 class TextTrackImpl : public media::TextTrack {
  public:
   // Constructor assumes ownership of the |text_track| object.
-  TextTrackImpl(const scoped_refptr<base::MessageLoopProxy>& message_loop,
+  TextTrackImpl(const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
                 blink::WebMediaPlayerClient* client,
                 scoped_ptr<WebInbandTextTrackImpl> text_track);
 
@@ -50,7 +50,7 @@ class TextTrackImpl : public media::TextTrack {
   static void OnRemoveTrack(blink::WebMediaPlayerClient* client,
                             scoped_ptr<WebInbandTextTrackImpl> text_track);
 
-  scoped_refptr<base::MessageLoopProxy> message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   blink::WebMediaPlayerClient* client_;
   scoped_ptr<WebInbandTextTrackImpl> text_track_;
   DISALLOW_COPY_AND_ASSIGN(TextTrackImpl);
@@ -59,4 +59,3 @@ class TextTrackImpl : public media::TextTrack {
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_TEXTTRACK_IMPL_H_
-
diff --git a/content/renderer/media/webmediaplayer_impl.cc b/content/renderer/media/webmediaplayer_impl.cc
index 2f4928f..5067d28 100644
--- a/content/renderer/media/webmediaplayer_impl.cc
+++ b/content/renderer/media/webmediaplayer_impl.cc
@@ -18,6 +18,7 @@
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
+#include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/video_layer.h"
@@ -127,11 +128,11 @@ COMPILE_ASSERT_MATCHING_ENUM(UseCredentials);
 #undef COMPILE_ASSERT_MATCHING_ENUM
 
 #define BIND_TO_RENDER_LOOP(function) \
-  (DCHECK(main_loop_->BelongsToCurrentThread()), \
+  (DCHECK(main_task_runner_->BelongsToCurrentThread()), \
   media::BindToCurrentLoop(base::Bind(function, AsWeakPtr())))
 
 #define BIND_TO_RENDER_LOOP1(function, arg1) \
-  (DCHECK(main_loop_->BelongsToCurrentThread()), \
+  (DCHECK(main_task_runner_->BelongsToCurrentThread()), \
   media::BindToCurrentLoop(base::Bind(function, AsWeakPtr(), arg1)))
 
 static void LogMediaSourceError(const scoped_refptr<media::MediaLog>& media_log,
@@ -148,11 +149,11 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       preload_(AUTO),
-      main_loop_(base::MessageLoopProxy::current()),
-      media_loop_(
-          RenderThreadImpl::current()->GetMediaThreadMessageLoopProxy()),
+      main_task_runner_(base::MessageLoopProxy::current()),
+      media_task_runner_(
+          RenderThreadImpl::current()->GetMediaThreadTaskRunner()),
       media_log_(new RenderMediaLog()),
-      pipeline_(media_loop_, media_log_.get()),
+      pipeline_(media_task_runner_, media_log_.get()),
       load_type_(LoadTypeURL),
       opaque_(false),
       paused_(true),
@@ -186,19 +187,19 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
   // |GetTaskRunner()|.  Since |pipeline_| will own decoders created from the
   // factories, require that their message loops are identical.
   DCHECK(!gpu_factories_.get() ||
-         (gpu_factories_->GetTaskRunner() == media_loop_.get()));
+         (gpu_factories_->GetTaskRunner() == media_task_runner_.get()));
 
   // Use the null sink if no sink was provided.
   audio_source_provider_ = new WebAudioSourceProviderImpl(
       params.audio_renderer_sink().get()
           ? params.audio_renderer_sink()
-          : new media::NullAudioSink(media_loop_));
+          : new media::NullAudioSink(media_task_runner_));
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   client_->setWebLayer(NULL);
 
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 
@@ -240,7 +241,7 @@ void WebMediaPlayerImpl::load(LoadType load_type, const blink::WebURL& url,
 void WebMediaPlayerImpl::DoLoad(LoadType load_type,
                                 const blink::WebURL& url,
                                 CORSMode cors_mode) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   GURL gurl(url);
   ReportMediaSchemeUma(gurl);
@@ -265,7 +266,7 @@ void WebMediaPlayerImpl::DoLoad(LoadType load_type,
   data_source_.reset(new BufferedDataSource(
       url,
       static_cast<BufferedResourceLoader::CORSMode>(cors_mode),
-      main_loop_,
+      main_task_runner_,
       frame_,
       media_log_.get(),
       &buffered_data_source_host_,
@@ -277,7 +278,7 @@ void WebMediaPlayerImpl::DoLoad(LoadType load_type,
 
 void WebMediaPlayerImpl::play() {
   DVLOG(1) << __FUNCTION__;
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   paused_ = false;
   pipeline_.SetPlaybackRate(playback_rate_);
@@ -292,7 +293,7 @@ void WebMediaPlayerImpl::play() {
 
 void WebMediaPlayerImpl::pause() {
   DVLOG(1) << __FUNCTION__;
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   paused_ = true;
   pipeline_.SetPlaybackRate(0.0f);
@@ -307,13 +308,13 @@ void WebMediaPlayerImpl::pause() {
 }
 
 bool WebMediaPlayerImpl::supportsSave() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   return supports_save_;
 }
 
 void WebMediaPlayerImpl::seek(double seconds) {
   DVLOG(1) << __FUNCTION__ << "(" << seconds << ")";
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (ready_state_ > WebMediaPlayer::ReadyStateHaveMetadata)
     SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
@@ -347,7 +348,7 @@ void WebMediaPlayerImpl::seek(double seconds) {
 
 void WebMediaPlayerImpl::setRate(double rate) {
   DVLOG(1) << __FUNCTION__ << "(" << rate << ")";
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // TODO(kylep): Remove when support for negatives is added. Also, modify the
   // following checks so rewind uses reasonable values also.
@@ -372,7 +373,7 @@ void WebMediaPlayerImpl::setRate(double rate) {
 
 void WebMediaPlayerImpl::setVolume(double volume) {
   DVLOG(1) << __FUNCTION__ << "(" << volume << ")";
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   pipeline_.SetVolume(volume);
 }
@@ -388,7 +389,7 @@ COMPILE_ASSERT_MATCHING_ENUM(PreloadAuto, AUTO);
 
 void WebMediaPlayerImpl::setPreload(WebMediaPlayer::Preload preload) {
   DVLOG(1) << __FUNCTION__ << "(" << preload << ")";
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   preload_ = static_cast<content::Preload>(preload);
   if (data_source_)
@@ -396,31 +397,31 @@ void WebMediaPlayerImpl::setPreload(WebMediaPlayer::Preload preload) {
 }
 
 bool WebMediaPlayerImpl::hasVideo() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return pipeline_metadata_.has_video;
 }
 
 bool WebMediaPlayerImpl::hasAudio() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return pipeline_metadata_.has_audio;
 }
 
 blink::WebSize WebMediaPlayerImpl::naturalSize() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return blink::WebSize(pipeline_metadata_.natural_size);
 }
 
 bool WebMediaPlayerImpl::paused() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return pipeline_.GetPlaybackRate() == 0.0f;
 }
 
 bool WebMediaPlayerImpl::seeking() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
     return false;
@@ -429,7 +430,7 @@ bool WebMediaPlayerImpl::seeking() const {
 }
 
 double WebMediaPlayerImpl::duration() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
     return std::numeric_limits<double>::quiet_NaN();
@@ -438,7 +439,7 @@ double WebMediaPlayerImpl::duration() const {
 }
 
 double WebMediaPlayerImpl::timelineOffset() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (pipeline_metadata_.timeline_offset.is_null())
     return std::numeric_limits<double>::quiet_NaN();
@@ -447,22 +448,22 @@ double WebMediaPlayerImpl::timelineOffset() const {
 }
 
 double WebMediaPlayerImpl::currentTime() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   return (paused_ ? paused_time_ : pipeline_.GetMediaTime()).InSecondsF();
 }
 
 WebMediaPlayer::NetworkState WebMediaPlayerImpl::networkState() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   return network_state_;
 }
 
 WebMediaPlayer::ReadyState WebMediaPlayerImpl::readyState() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   return ready_state_;
 }
 
 blink::WebTimeRanges WebMediaPlayerImpl::buffered() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   media::Ranges<base::TimeDelta> buffered_time_ranges =
       pipeline_.GetBufferedTimeRanges();
@@ -476,7 +477,7 @@ blink::WebTimeRanges WebMediaPlayerImpl::buffered() const {
 }
 
 double WebMediaPlayerImpl::maxTimeSeekable() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // If we haven't even gotten to ReadyStateHaveMetadata yet then just
   // return 0 so that the seekable range is empty.
@@ -490,7 +491,7 @@ double WebMediaPlayerImpl::maxTimeSeekable() const {
 }
 
 bool WebMediaPlayerImpl::didLoadingProgress() {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   bool pipeline_progress = pipeline_.DidLoadingProgress();
   bool data_progress = buffered_data_source_host_.DidLoadingProgress();
   return pipeline_progress || data_progress;
@@ -506,7 +507,7 @@ void WebMediaPlayerImpl::paint(blink::WebCanvas* canvas,
                                const blink::WebRect& rect,
                                unsigned char alpha,
                                SkXfermode::Mode mode) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT0("media", "WebMediaPlayerImpl:paint");
 
   // TODO(scherkus): Clarify paint() API contract to better understand when and
@@ -544,28 +545,28 @@ double WebMediaPlayerImpl::mediaTimeForTimeValue(double timeValue) const {
 }
 
 unsigned WebMediaPlayerImpl::decodedFrameCount() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   media::PipelineStatistics stats = pipeline_.GetStatistics();
   return stats.video_frames_decoded;
 }
 
 unsigned WebMediaPlayerImpl::droppedFrameCount() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   media::PipelineStatistics stats = pipeline_.GetStatistics();
   return stats.video_frames_dropped;
 }
 
 unsigned WebMediaPlayerImpl::audioDecodedByteCount() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   media::PipelineStatistics stats = pipeline_.GetStatistics();
   return stats.audio_bytes_decoded;
 }
 
 unsigned WebMediaPlayerImpl::videoDecodedByteCount() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   media::PipelineStatistics stats = pipeline_.GetStatistics();
   return stats.video_bytes_decoded;
@@ -628,7 +629,7 @@ WebMediaPlayer::MediaKeyException
 WebMediaPlayerImpl::generateKeyRequest(const WebString& key_system,
                                        const unsigned char* init_data,
                                        unsigned init_data_length) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return encrypted_media_support_->GenerateKeyRequest(
       frame_, key_system, init_data, init_data_length);
@@ -641,7 +642,7 @@ WebMediaPlayer::MediaKeyException WebMediaPlayerImpl::addKey(
     const unsigned char* init_data,
     unsigned init_data_length,
     const WebString& session_id) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return encrypted_media_support_->AddKey(
       key_system, key, key_length, init_data, init_data_length, session_id);
@@ -650,14 +651,14 @@ WebMediaPlayer::MediaKeyException WebMediaPlayerImpl::addKey(
 WebMediaPlayer::MediaKeyException WebMediaPlayerImpl::cancelKeyRequest(
     const WebString& key_system,
     const WebString& session_id) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return encrypted_media_support_->CancelKeyRequest(key_system, session_id);
 }
 
 void WebMediaPlayerImpl::setContentDecryptionModule(
     blink::WebContentDecryptionModule* cdm) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   encrypted_media_support_->SetContentDecryptionModule(cdm);
 }
@@ -665,14 +666,14 @@ void WebMediaPlayerImpl::setContentDecryptionModule(
 void WebMediaPlayerImpl::setContentDecryptionModule(
     blink::WebContentDecryptionModule* cdm,
     blink::WebContentDecryptionModuleResult result) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   encrypted_media_support_->SetContentDecryptionModule(cdm, result);
 }
 
 void WebMediaPlayerImpl::setContentDecryptionModuleSync(
     blink::WebContentDecryptionModule* cdm) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   encrypted_media_support_->SetContentDecryptionModuleSync(cdm);
 }
@@ -680,7 +681,7 @@ void WebMediaPlayerImpl::setContentDecryptionModuleSync(
 void WebMediaPlayerImpl::OnPipelineSeeked(bool time_changed,
                                           PipelineStatus status) {
   DVLOG(1) << __FUNCTION__ << "(" << time_changed << ", " << status << ")";
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   seeking_ = false;
   if (pending_seek_) {
     pending_seek_ = false;
@@ -702,12 +703,12 @@ void WebMediaPlayerImpl::OnPipelineSeeked(bool time_changed,
 
 void WebMediaPlayerImpl::OnPipelineEnded() {
   DVLOG(1) << __FUNCTION__;
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   client_->timeChanged();
 }
 
 void WebMediaPlayerImpl::OnPipelineError(PipelineStatus error) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(error, media::PIPELINE_OK);
 
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing) {
@@ -770,7 +771,7 @@ void WebMediaPlayerImpl::OnPipelineBufferingStateChanged(
 }
 
 void WebMediaPlayerImpl::OnDemuxerOpened() {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   client_->mediaSourceOpened(new WebMediaSourceImpl(
       chunk_demuxer_, base::Bind(&LogMediaSourceError, media_log_)));
 }
@@ -778,7 +779,7 @@ void WebMediaPlayerImpl::OnDemuxerOpened() {
 void WebMediaPlayerImpl::OnAddTextTrack(
     const media::TextTrackConfig& config,
     const media::AddTextTrackDoneCB& done_cb) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   const WebInbandTextTrackImpl::Kind web_kind =
       static_cast<WebInbandTextTrackImpl::Kind>(config.kind());
@@ -793,14 +794,14 @@ void WebMediaPlayerImpl::OnAddTextTrack(
       new WebInbandTextTrackImpl(web_kind, web_label, web_language, web_id,
                                  text_track_index_++));
 
-  scoped_ptr<media::TextTrack> text_track(
-      new TextTrackImpl(main_loop_, client_, web_inband_text_track.Pass()));
+  scoped_ptr<media::TextTrack> text_track(new TextTrackImpl(
+      main_task_runner_, client_, web_inband_text_track.Pass()));
 
   done_cb.Run(text_track.Pass());
 }
 
 void WebMediaPlayerImpl::DataSourceInitialized(bool success) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (!success) {
     SetNetworkState(WebMediaPlayer::NetworkStateFormatError);
@@ -831,11 +832,12 @@ scoped_ptr<media::Renderer> WebMediaPlayerImpl::CreateRenderer() {
   ScopedVector<media::AudioDecoder> audio_decoders;
 
   media::LogCB log_cb = base::Bind(&LogMediaSourceError, media_log_);
-  audio_decoders.push_back(new media::FFmpegAudioDecoder(media_loop_, log_cb));
-  audio_decoders.push_back(new media::OpusAudioDecoder(media_loop_));
+  audio_decoders.push_back(new media::FFmpegAudioDecoder(media_task_runner_,
+                                                         log_cb));
+  audio_decoders.push_back(new media::OpusAudioDecoder(media_task_runner_));
 
   scoped_ptr<media::AudioRenderer> audio_renderer(new media::AudioRendererImpl(
-      media_loop_,
+      media_task_runner_,
       audio_source_provider_.get(),
       audio_decoders.Pass(),
       set_decryptor_ready_cb,
@@ -850,14 +852,14 @@ scoped_ptr<media::Renderer> WebMediaPlayerImpl::CreateRenderer() {
   }
 
 #if !defined(MEDIA_DISABLE_LIBVPX)
-  video_decoders.push_back(new media::VpxVideoDecoder(media_loop_));
+  video_decoders.push_back(new media::VpxVideoDecoder(media_task_runner_));
 #endif  // !defined(MEDIA_DISABLE_LIBVPX)
 
-  video_decoders.push_back(new media::FFmpegVideoDecoder(media_loop_));
+  video_decoders.push_back(new media::FFmpegVideoDecoder(media_task_runner_));
 
   scoped_ptr<media::VideoRenderer> video_renderer(
       new media::VideoRendererImpl(
-          media_loop_,
+          media_task_runner_,
           video_decoders.Pass(),
           set_decryptor_ready_cb,
           base::Bind(&WebMediaPlayerImpl::FrameReady, base::Unretained(this)),
@@ -865,14 +867,14 @@ scoped_ptr<media::Renderer> WebMediaPlayerImpl::CreateRenderer() {
 
   // Create renderer.
   return scoped_ptr<media::Renderer>(new media::RendererImpl(
-      media_loop_,
+      media_task_runner_,
       demuxer_.get(),
       audio_renderer.Pass(),
       video_renderer.Pass()));
 }
 
 void WebMediaPlayerImpl::StartPipeline() {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 
   // Keep track if this is a MSE or non-MSE playback.
@@ -889,7 +891,7 @@ void WebMediaPlayerImpl::StartPipeline() {
     DCHECK(data_source_);
 
     demuxer_.reset(new media::FFmpegDemuxer(
-        media_loop_, data_source_.get(),
+        media_task_runner_, data_source_.get(),
         need_key_cb,
         media_log_));
   } else {
@@ -914,7 +916,7 @@ void WebMediaPlayerImpl::StartPipeline() {
   if (cmd_line->HasSwitch(switches::kEnableInbandTextTracks)) {
     scoped_ptr<media::TextRenderer> text_renderer(
         new media::TextRenderer(
-            media_loop_,
+            media_task_runner_,
             BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnAddTextTrack)));
 
     filter_collection->SetTextRenderer(text_renderer.Pass());
@@ -934,7 +936,7 @@ void WebMediaPlayerImpl::StartPipeline() {
 
 void WebMediaPlayerImpl::SetNetworkState(WebMediaPlayer::NetworkState state) {
   DVLOG(1) << __FUNCTION__ << "(" << state << ")";
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   network_state_ = state;
   // Always notify to ensure client has the latest value.
   client_->networkStateChanged();
@@ -942,7 +944,7 @@ void WebMediaPlayerImpl::SetNetworkState(WebMediaPlayer::NetworkState state) {
 
 void WebMediaPlayerImpl::SetReadyState(WebMediaPlayer::ReadyState state) {
   DVLOG(1) << __FUNCTION__ << "(" << state << ")";
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (state == WebMediaPlayer::ReadyStateHaveEnoughData && data_source_ &&
       data_source_->assume_fully_buffered() &&
@@ -977,7 +979,7 @@ void WebMediaPlayerImpl::OnDurationChanged() {
 }
 
 void WebMediaPlayerImpl::OnNaturalSizeChanged(gfx::Size size) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(ready_state_, WebMediaPlayer::ReadyStateHaveNothing);
   TRACE_EVENT0("media", "WebMediaPlayerImpl::OnNaturalSizeChanged");
 
@@ -989,7 +991,7 @@ void WebMediaPlayerImpl::OnNaturalSizeChanged(gfx::Size size) {
 }
 
 void WebMediaPlayerImpl::OnOpacityChanged(bool opaque) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(ready_state_, WebMediaPlayer::ReadyStateHaveNothing);
 
   opaque_ = opaque;
diff --git a/content/renderer/media/webmediaplayer_impl.h b/content/renderer/media/webmediaplayer_impl.h
index 8631ecf..f81976c 100644
--- a/content/renderer/media/webmediaplayer_impl.h
+++ b/content/renderer/media/webmediaplayer_impl.h
@@ -34,7 +34,7 @@ class WebLocalFrame;
 }
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace cc_blink {
@@ -230,11 +230,11 @@ class WebMediaPlayerImpl
   // Preload state for when |data_source_| is created after setPreload().
   content::Preload preload_;
 
-  // Message loops for posting tasks on Chrome's main thread. Also used
+  // Task runner for posting tasks on Chrome's main thread. Also used
   // for DCHECKs so methods calls won't execute in the wrong thread.
-  const scoped_refptr<base::MessageLoopProxy> main_loop_;
+  const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 
-  scoped_refptr<base::MessageLoopProxy> media_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
   scoped_refptr<media::MediaLog> media_log_;
   media::Pipeline pipeline_;
 
diff --git a/content/renderer/pepper/video_decoder_shim.cc b/content/renderer/pepper/video_decoder_shim.cc
index d175728..9bad6c0 100644
--- a/content/renderer/pepper/video_decoder_shim.cc
+++ b/content/renderer/pepper/video_decoder_shim.cc
@@ -10,6 +10,7 @@
 
 #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"
@@ -294,15 +295,15 @@ void VideoDecoderShim::DecoderImpl::OnResetComplete() {
 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()));
 }
@@ -322,7 +323,7 @@ VideoDecoderShim::~VideoDecoderShim() {
 
   // 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())));
@@ -354,7 +355,7 @@ bool VideoDecoderShim::Initialize(
       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()),
@@ -372,7 +373,7 @@ void VideoDecoderShim::Decode(const media::BitstreamBuffer& bitstream_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,
@@ -429,7 +430,7 @@ 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())));
diff --git a/content/renderer/pepper/video_decoder_shim.h b/content/renderer/pepper/video_decoder_shim.h
index aa33a74..a9c4cce 100644
--- a/content/renderer/pepper/video_decoder_shim.h
+++ b/content/renderer/pepper/video_decoder_shim.h
@@ -13,13 +13,16 @@
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "media/base/video_decoder_config.h"
 #include "media/video/video_decode_accelerator.h"
 
 #include "ppapi/c/pp_codecs.h"
 
+namespace base {
+class SingleThreadTaskRunner;
+}
+
 namespace gpu {
 namespace gles2 {
 class GLES2Interface;
@@ -89,7 +92,7 @@ class VideoDecoderShim : public media::VideoDecodeAccelerator {
   State state_;
 
   PepperVideoDecoderHost* host_;
-  scoped_refptr<base::MessageLoopProxy> media_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
   scoped_refptr<webkit::gpu::ContextProviderWebContext> context_provider_;
 
   // The current decoded frame size.
diff --git a/content/renderer/render_frame_impl.cc b/content/renderer/render_frame_impl.cc
index 10fd5b5..60525cb 100644
--- a/content/renderer/render_frame_impl.cc
+++ b/content/renderer/render_frame_impl.cc
@@ -3802,7 +3802,7 @@ WebMediaPlayer* RenderFrameImpl::CreateAndroidWebMediaPlayer(
       GetMediaPlayerManager(),
       GetCdmManager(),
       stream_texture_factory,
-      RenderThreadImpl::current()->GetMediaThreadMessageLoopProxy(),
+      RenderThreadImpl::current()->GetMediaThreadTaskRunner(),
       new RenderMediaLog());
 }
 
diff --git a/content/renderer/render_thread_impl.cc b/content/renderer/render_thread_impl.cc
index c1f8e95..d6aa2743 100644
--- a/content/renderer/render_thread_impl.cc
+++ b/content/renderer/render_thread_impl.cc
@@ -1108,8 +1108,8 @@ RenderThreadImpl::GetGpuFactories() {
   scoped_refptr<GpuChannelHost> gpu_channel_host = GetGpuChannel();
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   scoped_refptr<media::GpuVideoAcceleratorFactories> gpu_factories;
-  scoped_refptr<base::MessageLoopProxy> media_loop_proxy =
-      GetMediaThreadMessageLoopProxy();
+  scoped_refptr<base::SingleThreadTaskRunner> media_task_runner =
+      GetMediaThreadTaskRunner();
   if (!cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode)) {
     if (!gpu_va_context_provider_.get() ||
         gpu_va_context_provider_->DestroyedOnMainThread()) {
@@ -1133,7 +1133,7 @@ RenderThreadImpl::GetGpuFactories() {
   }
   if (gpu_va_context_provider_.get()) {
     gpu_factories = RendererGpuVideoAcceleratorFactories::Create(
-        gpu_channel_host.get(), media_loop_proxy, gpu_va_context_provider_);
+        gpu_channel_host.get(), media_task_runner, gpu_va_context_provider_);
   }
   return gpu_factories;
 }
@@ -1588,8 +1588,8 @@ RenderThreadImpl::GetFileThreadMessageLoopProxy() {
   return file_thread_->message_loop_proxy();
 }
 
-scoped_refptr<base::MessageLoopProxy>
-RenderThreadImpl::GetMediaThreadMessageLoopProxy() {
+scoped_refptr<base::SingleThreadTaskRunner>
+RenderThreadImpl::GetMediaThreadTaskRunner() {
   DCHECK(message_loop() == base::MessageLoop::current());
   if (!media_thread_) {
     media_thread_.reset(new base::Thread("Media"));
diff --git a/content/renderer/render_thread_impl.h b/content/renderer/render_thread_impl.h
index 68828f6..ea65fd2 100644
--- a/content/renderer/render_thread_impl.h
+++ b/content/renderer/render_thread_impl.h
@@ -297,10 +297,10 @@ class CONTENT_EXPORT RenderThreadImpl : public RenderThread,
   // on the renderer's main thread.
   scoped_refptr<base::MessageLoopProxy> GetFileThreadMessageLoopProxy();
 
-  // Returns a MessageLoopProxy instance corresponding to the message loop
+  // Returns a SingleThreadTaskRunner instance corresponding to the message loop
   // of the thread on which media operations should be run. Must be called
   // on the renderer's main thread.
-  scoped_refptr<base::MessageLoopProxy> GetMediaThreadMessageLoopProxy();
+  scoped_refptr<base::SingleThreadTaskRunner> GetMediaThreadTaskRunner();
 
   // Causes the idle handler to skip sending idle notifications
   // on the two next scheduled calls, so idle notifications are