content/child: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

This patch was mostly autogenerated with
https://codereview.chromium.org/1010073002/.

BUG=465354
TBR=jochen@chromium.org,raymes@chromium.org

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

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

93 files changed, 621 insertions, 672 deletions

diff --git a/chrome/renderer/chrome_mock_render_thread.cc b/chrome/renderer/chrome_mock_render_thread.cc
index 61b68c0..e197222 100644
--- a/chrome/renderer/chrome_mock_render_thread.cc
+++ b/chrome/renderer/chrome_mock_render_thread.cc
@@ -16,7 +16,7 @@ ChromeMockRenderThread::ChromeMockRenderThread() {
 ChromeMockRenderThread::~ChromeMockRenderThread() {
 }
 
-scoped_refptr<base::MessageLoopProxy>
+scoped_refptr<base::SingleThreadTaskRunner>
 ChromeMockRenderThread::GetIOMessageLoopProxy() {
   return io_message_loop_proxy_;
 }
diff --git a/chrome/renderer/chrome_mock_render_thread.h b/chrome/renderer/chrome_mock_render_thread.h
index f97629d..f6e460f 100644
--- a/chrome/renderer/chrome_mock_render_thread.h
+++ b/chrome/renderer/chrome_mock_render_thread.h
@@ -18,7 +18,7 @@ class ChromeMockRenderThread : public content::MockRenderThread {
   ~ChromeMockRenderThread() override;
 
   // content::RenderThread overrides.
-  scoped_refptr<base::MessageLoopProxy> GetIOMessageLoopProxy() override;
+  scoped_refptr<base::SingleThreadTaskRunner> GetIOMessageLoopProxy() override;
 
   //////////////////////////////////////////////////////////////////////////
   // The following functions are called by the test itself.
diff --git a/components/nacl/renderer/pnacl_translation_resource_host.cc b/components/nacl/renderer/pnacl_translation_resource_host.cc
index f47f1d4..a4079c1 100644
--- a/components/nacl/renderer/pnacl_translation_resource_host.cc
+++ b/components/nacl/renderer/pnacl_translation_resource_host.cc
@@ -11,32 +11,33 @@
 using ppapi::PpapiGlobals;
 
 PnaclTranslationResourceHost::PnaclTranslationResourceHost(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
-    : io_message_loop_(io_message_loop), sender_(NULL) {}
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
+    : io_task_runner_(io_task_runner), sender_(NULL) {
+}
 
 PnaclTranslationResourceHost::~PnaclTranslationResourceHost() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   CleanupCacheRequests();
 }
 
 void PnaclTranslationResourceHost::OnFilterAdded(IPC::Sender* sender) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   sender_ = sender;
 }
 
 void PnaclTranslationResourceHost::OnFilterRemoved() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   sender_ = NULL;
 }
 
 void PnaclTranslationResourceHost::OnChannelClosing() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   sender_ = NULL;
 }
 
 bool PnaclTranslationResourceHost::OnMessageReceived(
     const IPC::Message& message) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PnaclTranslationResourceHost, message)
     IPC_MESSAGE_HANDLER(NaClViewMsg_NexeTempFileReply, OnNexeTempFileReply)
@@ -52,14 +53,10 @@ void PnaclTranslationResourceHost::RequestNexeFd(
     RequestNexeFdCallback callback) {
   DCHECK(PpapiGlobals::Get()->
          GetMainThreadMessageLoop()->BelongsToCurrentThread());
-  io_message_loop_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&PnaclTranslationResourceHost::SendRequestNexeFd,
-                 this,
-                 render_view_id,
-                 instance,
-                 cache_info,
-                 callback));
+      base::Bind(&PnaclTranslationResourceHost::SendRequestNexeFd, this,
+                 render_view_id, instance, cache_info, callback));
   return;
 }
 
@@ -68,7 +65,7 @@ void PnaclTranslationResourceHost::SendRequestNexeFd(
     PP_Instance instance,
     const nacl::PnaclCacheInfo& cache_info,
     RequestNexeFdCallback callback) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (!sender_ || !sender_->Send(new NaClHostMsg_NexeTempFileRequest(
           render_view_id, instance, cache_info))) {
     PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
@@ -87,19 +84,17 @@ void PnaclTranslationResourceHost::ReportTranslationFinished(
     PP_Bool success) {
   DCHECK(PpapiGlobals::Get()->
          GetMainThreadMessageLoop()->BelongsToCurrentThread());
-  io_message_loop_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PnaclTranslationResourceHost::SendReportTranslationFinished,
-                 this,
-                 instance,
-                 success));
+                 this, instance, success));
   return;
 }
 
 void PnaclTranslationResourceHost::SendReportTranslationFinished(
     PP_Instance instance,
     PP_Bool success) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   // If the sender is closed or we have been detached, we are probably shutting
   // down, so just don't send anything.
   if (!sender_)
@@ -113,7 +108,7 @@ void PnaclTranslationResourceHost::OnNexeTempFileReply(
     PP_Instance instance,
     bool is_hit,
     IPC::PlatformFileForTransit file) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   base::File base_file = IPC::PlatformFileForTransitToFile(file);
   CacheRequestInfoMap::iterator it = pending_cache_requests_.find(instance);
   if (!base_file.IsValid()) {
@@ -136,7 +131,7 @@ void PnaclTranslationResourceHost::OnNexeTempFileReply(
 }
 
 void PnaclTranslationResourceHost::CleanupCacheRequests() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   for (CacheRequestInfoMap::iterator it = pending_cache_requests_.begin();
        it != pending_cache_requests_.end();
        ++it) {
diff --git a/components/nacl/renderer/pnacl_translation_resource_host.h b/components/nacl/renderer/pnacl_translation_resource_host.h
index 2548f1d..4ddb7c2 100644
--- a/components/nacl/renderer/pnacl_translation_resource_host.h
+++ b/components/nacl/renderer/pnacl_translation_resource_host.h
@@ -31,7 +31,7 @@ class PnaclTranslationResourceHost : public IPC::MessageFilter {
           RequestNexeFdCallback;
 
   explicit PnaclTranslationResourceHost(
-      const scoped_refptr<base::MessageLoopProxy>& io_message_loop);
+      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner);
   void RequestNexeFd(int render_view_id,
                      PP_Instance instance,
                      const nacl::PnaclCacheInfo& cache_info,
@@ -63,7 +63,7 @@ class PnaclTranslationResourceHost : public IPC::MessageFilter {
                            IPC::PlatformFileForTransit file);
   void CleanupCacheRequests();
 
-  scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // Should be accessed on the io thread.
   IPC::Sender* sender_;
diff --git a/components/printing/test/print_mock_render_thread.cc b/components/printing/test/print_mock_render_thread.cc
index 4cf3b74..294f986 100644
--- a/components/printing/test/print_mock_render_thread.cc
+++ b/components/printing/test/print_mock_render_thread.cc
@@ -36,7 +36,7 @@ PrintMockRenderThread::PrintMockRenderThread()
 PrintMockRenderThread::~PrintMockRenderThread() {
 }
 
-scoped_refptr<base::MessageLoopProxy>
+scoped_refptr<base::SingleThreadTaskRunner>
 PrintMockRenderThread::GetIOMessageLoopProxy() {
   return io_message_loop_proxy_;
 }
diff --git a/components/printing/test/print_mock_render_thread.h b/components/printing/test/print_mock_render_thread.h
index 961341e..fdec4b2 100644
--- a/components/printing/test/print_mock_render_thread.h
+++ b/components/printing/test/print_mock_render_thread.h
@@ -29,7 +29,7 @@ class PrintMockRenderThread : public content::MockRenderThread {
   ~PrintMockRenderThread() override;
 
   // content::RenderThread overrides.
-  scoped_refptr<base::MessageLoopProxy> GetIOMessageLoopProxy() override;
+  scoped_refptr<base::SingleThreadTaskRunner> GetIOMessageLoopProxy() override;
 
   //////////////////////////////////////////////////////////////////////////
   // The following functions are called by the test itself.
diff --git a/components/tracing/child_memory_dump_manager_delegate_impl.cc b/components/tracing/child_memory_dump_manager_delegate_impl.cc
index f8048d9..4e2cc9f 100644
--- a/components/tracing/child_memory_dump_manager_delegate_impl.cc
+++ b/components/tracing/child_memory_dump_manager_delegate_impl.cc
@@ -31,7 +31,7 @@ void ChildMemoryDumpManagerDelegateImpl::SetChildTraceMessageFilter(
   // replacing a valid instance with another one (should never happen).
   DCHECK(ctmf_ == nullptr || (ctmf == nullptr && ctmf_task_runner_ != nullptr));
   ctmf_ = ctmf;
-  ctmf_task_runner_ = ctmf ? (ctmf->ipc_message_loop()) : nullptr;
+  ctmf_task_runner_ = ctmf ? (ctmf->ipc_task_runner()) : nullptr;
 }
 
 // Invoked in child processes by the MemoryDumpManager.
diff --git a/components/tracing/child_trace_message_filter.cc b/components/tracing/child_trace_message_filter.cc
index 3dd1223..194f097 100644
--- a/components/tracing/child_trace_message_filter.cc
+++ b/components/tracing/child_trace_message_filter.cc
@@ -15,9 +15,9 @@ using base::trace_event::TraceLog;
 namespace tracing {
 
 ChildTraceMessageFilter::ChildTraceMessageFilter(
-    base::MessageLoopProxy* ipc_message_loop)
+    base::SingleThreadTaskRunner* ipc_task_runner)
     : sender_(NULL),
-      ipc_message_loop_(ipc_message_loop),
+      ipc_task_runner_(ipc_task_runner),
       pending_memory_dump_guid_(0) {
 }
 
@@ -132,8 +132,9 @@ void ChildTraceMessageFilter::OnCancelWatchEvent() {
 }
 
 void ChildTraceMessageFilter::OnWatchEventMatched() {
-  if (!ipc_message_loop_->BelongsToCurrentThread()) {
-    ipc_message_loop_->PostTask(FROM_HERE,
+  if (!ipc_task_runner_->BelongsToCurrentThread()) {
+    ipc_task_runner_->PostTask(
+        FROM_HERE,
         base::Bind(&ChildTraceMessageFilter::OnWatchEventMatched, this));
     return;
   }
@@ -143,10 +144,10 @@ void ChildTraceMessageFilter::OnWatchEventMatched() {
 void ChildTraceMessageFilter::OnTraceDataCollected(
     const scoped_refptr<base::RefCountedString>& events_str_ptr,
     bool has_more_events) {
-  if (!ipc_message_loop_->BelongsToCurrentThread()) {
-    ipc_message_loop_->PostTask(FROM_HERE,
-        base::Bind(&ChildTraceMessageFilter::OnTraceDataCollected, this,
-                   events_str_ptr, has_more_events));
+  if (!ipc_task_runner_->BelongsToCurrentThread()) {
+    ipc_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&ChildTraceMessageFilter::OnTraceDataCollected,
+                              this, events_str_ptr, has_more_events));
     return;
   }
   if (events_str_ptr->data().size()) {
@@ -163,13 +164,11 @@ void ChildTraceMessageFilter::OnTraceDataCollected(
 void ChildTraceMessageFilter::OnMonitoringTraceDataCollected(
      const scoped_refptr<base::RefCountedString>& events_str_ptr,
      bool has_more_events) {
-  if (!ipc_message_loop_->BelongsToCurrentThread()) {
-    ipc_message_loop_->PostTask(FROM_HERE,
-        base::Bind(&ChildTraceMessageFilter::
-                   OnMonitoringTraceDataCollected,
-                   this,
-                   events_str_ptr,
-                   has_more_events));
+  if (!ipc_task_runner_->BelongsToCurrentThread()) {
+    ipc_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&ChildTraceMessageFilter::OnMonitoringTraceDataCollected,
+                   this, events_str_ptr, has_more_events));
     return;
   }
   sender_->Send(new TracingHostMsg_MonitoringTraceDataCollected(
diff --git a/components/tracing/child_trace_message_filter.h b/components/tracing/child_trace_message_filter.h
index a6453a3..d380b4a 100644
--- a/components/tracing/child_trace_message_filter.h
+++ b/components/tracing/child_trace_message_filter.h
@@ -11,7 +11,7 @@
 #include "ipc/message_filter.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace tracing {
@@ -19,7 +19,8 @@ namespace tracing {
 // This class sends and receives trace messages on child processes.
 class ChildTraceMessageFilter : public IPC::MessageFilter {
  public:
-  explicit ChildTraceMessageFilter(base::MessageLoopProxy* ipc_message_loop);
+  explicit ChildTraceMessageFilter(
+      base::SingleThreadTaskRunner* ipc_task_runner);
 
   // IPC::MessageFilter implementation.
   void OnFilterAdded(IPC::Sender* sender) override;
@@ -30,7 +31,9 @@ class ChildTraceMessageFilter : public IPC::MessageFilter {
       const base::trace_event::MemoryDumpRequestArgs& args,
       const base::trace_event::MemoryDumpCallback& callback);
 
-  base::MessageLoopProxy* ipc_message_loop() const { return ipc_message_loop_; }
+  base::SingleThreadTaskRunner* ipc_task_runner() const {
+    return ipc_task_runner_;
+  }
 
  protected:
   ~ChildTraceMessageFilter() override;
@@ -67,7 +70,7 @@ class ChildTraceMessageFilter : public IPC::MessageFilter {
   void OnProcessMemoryDumpDone(uint64 dump_guid, bool success);
 
   IPC::Sender* sender_;
-  base::MessageLoopProxy* ipc_message_loop_;
+  base::SingleThreadTaskRunner* ipc_task_runner_;
 
   // guid of the outstanding request (to the Browser's MemoryDumpManager), if
   // any. 0 if there is no request pending.
diff --git a/content/child/blink_platform_impl.cc b/content/child/blink_platform_impl.cc
index 18b62cb..5a747aa 100644
--- a/content/child/blink_platform_impl.cc
+++ b/content/child/blink_platform_impl.cc
@@ -11,12 +11,14 @@
 #include "base/allocator/allocator_extension.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
+#include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/process/process_metrics.h"
 #include "base/rand_util.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ -424,8 +426,12 @@ static int ToMessageID(WebLocalizedString::Name name) {
   return -1;
 }
 
+// TODO(skyostil): Ensure that we always have an active task runner when
+// constructing the platform.
 BlinkPlatformImpl::BlinkPlatformImpl()
-    : main_thread_task_runner_(base::MessageLoopProxy::current()),
+    : main_thread_task_runner_(base::ThreadTaskRunnerHandle::IsSet()
+                                   ? base::ThreadTaskRunnerHandle::Get()
+                                   : nullptr),
       shared_timer_func_(NULL),
       shared_timer_fire_time_(0.0),
       shared_timer_fire_time_was_set_while_suspended_(false),
@@ -1365,7 +1371,7 @@ BlinkPlatformImpl::MainTaskRunnerForCurrentThread() {
       main_thread_task_runner_->BelongsToCurrentThread()) {
     return main_thread_task_runner_;
   } else {
-    return base::MessageLoopProxy::current();
+    return base::ThreadTaskRunnerHandle::Get();
   }
 }
 
diff --git a/content/child/child_histogram_message_filter.cc b/content/child/child_histogram_message_filter.cc
index 3e778d5..dbf2dd2 100644
--- a/content/child/child_histogram_message_filter.cc
+++ b/content/child/child_histogram_message_filter.cc
@@ -7,8 +7,9 @@
 #include <ctype.h>
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop.h"
+#include "base/location.h"
 #include "base/metrics/histogram_delta_serialization.h"
+#include "base/single_thread_task_runner.h"
 #include "content/child/child_process.h"
 #include "content/common/child_process_messages.h"
 #include "ipc/ipc_sender.h"
@@ -17,7 +18,7 @@ namespace content {
 
 ChildHistogramMessageFilter::ChildHistogramMessageFilter()
     : sender_(NULL),
-      io_message_loop_(ChildProcess::current()->io_message_loop_proxy()) {
+      io_task_runner_(ChildProcess::current()->io_task_runner()) {
 }
 
 ChildHistogramMessageFilter::~ChildHistogramMessageFilter() {
@@ -42,7 +43,7 @@ bool ChildHistogramMessageFilter::OnMessageReceived(
 }
 
 void ChildHistogramMessageFilter::SendHistograms(int sequence_number) {
-  io_message_loop_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ChildHistogramMessageFilter::UploadAllHistograms,
                             this, sequence_number));
 }
diff --git a/content/child/child_histogram_message_filter.h b/content/child/child_histogram_message_filter.h
index ed01890..a88f892c 100644
--- a/content/child/child_histogram_message_filter.h
+++ b/content/child/child_histogram_message_filter.h
@@ -14,7 +14,7 @@
 
 namespace base {
 class HistogramDeltaSerialization;
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace content {
@@ -44,7 +44,7 @@ class ChildHistogramMessageFilter : public IPC::MessageFilter {
 
   IPC::Sender* sender_;
 
-  scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // Prepares histogram deltas for transmission.
   scoped_ptr<base::HistogramDeltaSerialization> histogram_delta_serialization_;
diff --git a/content/child/child_process.h b/content/child/child_process.h
index cf3173f..32d5638 100644
--- a/content/child/child_process.h
+++ b/content/child/child_process.h
@@ -43,8 +43,8 @@ class CONTENT_EXPORT ChildProcess {
   void set_main_thread(ChildThreadImpl* thread);
 
   base::MessageLoop* io_message_loop() { return io_thread_.message_loop(); }
-  base::MessageLoopProxy* io_message_loop_proxy() {
-    return io_thread_.message_loop_proxy().get();
+  base::SingleThreadTaskRunner* io_task_runner() {
+    return io_thread_.task_runner().get();
   }
 
   // A global event object that is signalled when the main thread's message
diff --git a/content/child/child_thread_impl.cc b/content/child/child_thread_impl.cc
index 08d4135..ca970ec 100644
--- a/content/child/child_thread_impl.cc
+++ b/content/child/child_thread_impl.cc
@@ -15,16 +15,18 @@
 #include "base/debug/leak_annotations.h"
 #include "base/debug/profiler.h"
 #include "base/lazy_instance.h"
+#include "base/location.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop.h"
 #include "base/message_loop/timer_slack.h"
 #include "base/metrics/field_trial.h"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_local.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/tracked_objects.h"
@@ -292,7 +294,7 @@ ChildThreadImpl::ChildThreadImpl(const Options& options)
 scoped_refptr<base::SequencedTaskRunner> ChildThreadImpl::GetIOTaskRunner() {
   if (IsInBrowserProcess())
     return browser_process_io_runner_;
-  return ChildProcess::current()->io_message_loop_proxy();
+  return ChildProcess::current()->io_task_runner();
 }
 
 void ChildThreadImpl::ConnectChannel(bool use_mojo_channel) {
@@ -323,9 +325,9 @@ void ChildThreadImpl::Init(const Options& options) {
   // the logger, and the logger does not like being created on the IO thread.
   IPC::Logging::GetInstance();
 #endif
-  channel_ = IPC::SyncChannel::Create(
-      this, ChildProcess::current()->io_message_loop_proxy(),
-      ChildProcess::current()->GetShutDownEvent());
+  channel_ =
+      IPC::SyncChannel::Create(this, ChildProcess::current()->io_task_runner(),
+                               ChildProcess::current()->GetShutDownEvent());
 #ifdef IPC_MESSAGE_LOG_ENABLED
   if (!IsInBrowserProcess())
     IPC::Logging::GetInstance()->SetIPCSender(this);
@@ -336,7 +338,7 @@ void ChildThreadImpl::Init(const Options& options) {
   sync_message_filter_ =
       new IPC::SyncMessageFilter(ChildProcess::current()->GetShutDownEvent());
   thread_safe_sender_ = new ThreadSafeSender(
-      base::MessageLoopProxy::current().get(), sync_message_filter_.get());
+      message_loop_->task_runner(), sync_message_filter_.get());
 
   resource_dispatcher_.reset(new ResourceDispatcher(
       this, message_loop()->task_runner()));
@@ -379,7 +381,7 @@ void ChildThreadImpl::Init(const Options& options) {
     // In single process mode, browser-side tracing will cover the whole
     // process including renderers.
     channel_->AddFilter(new tracing::ChildTraceMessageFilter(
-        ChildProcess::current()->io_message_loop_proxy()));
+        ChildProcess::current()->io_task_runner()));
   }
 
   // In single process mode we may already have a power monitor
@@ -416,10 +418,9 @@ void ChildThreadImpl::Init(const Options& options) {
       connection_timeout = temp;
   }
 
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&ChildThreadImpl::EnsureConnected,
-                 channel_connected_factory_.GetWeakPtr()),
+  message_loop_->task_runner()->PostDelayedTask(
+      FROM_HERE, base::Bind(&ChildThreadImpl::EnsureConnected,
+                            channel_connected_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(connection_timeout));
 
 #if defined(OS_ANDROID)
@@ -428,7 +429,7 @@ void ChildThreadImpl::Init(const Options& options) {
 
 #if defined(TCMALLOC_TRACE_MEMORY_SUPPORTED)
   trace_memory_controller_.reset(new base::trace_event::TraceMemoryController(
-      message_loop_->message_loop_proxy(), ::HeapProfilerWithPseudoStackStart,
+      message_loop_->task_runner(), ::HeapProfilerWithPseudoStackStart,
       ::HeapProfilerStop, ::GetHeapProfile));
 #endif
 
diff --git a/content/child/fileapi/file_system_dispatcher.cc b/content/child/fileapi/file_system_dispatcher.cc
index 1a742db..8d5a42c 100644
--- a/content/child/fileapi/file_system_dispatcher.cc
+++ b/content/child/fileapi/file_system_dispatcher.cc
@@ -6,7 +6,6 @@
 
 #include "base/callback.h"
 #include "base/files/file_util.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/process/process.h"
 #include "content/child/child_thread_impl.h"
 #include "content/common/fileapi/file_system_messages.h"
diff --git a/content/child/fileapi/webfilesystem_impl.cc b/content/child/fileapi/webfilesystem_impl.cc
index c791e8d..f724271 100644
--- a/content/child/fileapi/webfilesystem_impl.cc
+++ b/content/child/fileapi/webfilesystem_impl.cc
@@ -7,7 +7,6 @@
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
diff --git a/content/child/fileapi/webfilewriter_impl.h b/content/child/fileapi/webfilewriter_impl.h
index 40ef0a3..43ac63d 100644
--- a/content/child/fileapi/webfilewriter_impl.h
+++ b/content/child/fileapi/webfilewriter_impl.h
@@ -9,7 +9,6 @@
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "content/child/fileapi/webfilewriter_base.h"
 
 namespace content {
diff --git a/content/child/indexed_db/indexed_db_dispatcher_unittest.cc b/content/child/indexed_db/indexed_db_dispatcher_unittest.cc
index 94b9cca..7e146e7 100644
--- a/content/child/indexed_db/indexed_db_dispatcher_unittest.cc
+++ b/content/child/indexed_db/indexed_db_dispatcher_unittest.cc
@@ -3,7 +3,8 @@
 // found in the LICENSE file.
 
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "content/child/indexed_db/indexed_db_dispatcher.h"
 #include "content/child/indexed_db/webidbcursor_impl.h"
@@ -64,16 +65,16 @@ class MockDispatcher : public IndexedDBDispatcher {
 class IndexedDBDispatcherTest : public testing::Test {
  public:
   IndexedDBDispatcherTest()
-      : message_loop_proxy_(base::MessageLoopProxy::current()),
+      : task_runner_(base::ThreadTaskRunnerHandle::Get()),
         sync_message_filter_(new IPC::SyncMessageFilter(NULL)),
-        thread_safe_sender_(new ThreadSafeSender(message_loop_proxy_.get(),
+        thread_safe_sender_(new ThreadSafeSender(task_runner_.get(),
                                                  sync_message_filter_.get())) {}
 
   void TearDown() override { blink::WebHeap::collectAllGarbageForTesting(); }
 
  protected:
   base::MessageLoop message_loop_;
-  scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<IPC::SyncMessageFilter> sync_message_filter_;
   scoped_refptr<ThreadSafeSender> thread_safe_sender_;
 
diff --git a/content/child/indexed_db/indexed_db_message_filter.h b/content/child/indexed_db/indexed_db_message_filter.h
index 08e3998..6ed9466 100644
--- a/content/child/indexed_db/indexed_db_message_filter.h
+++ b/content/child/indexed_db/indexed_db_message_filter.h
@@ -11,10 +11,6 @@
 struct IndexedDBDatabaseMetadata;
 struct IndexedDBMsg_CallbacksUpgradeNeeded_Params;
 
-namespace base {
-class MessageLoopProxy;
-}
-
 namespace content {
 
 class IndexedDBMessageFilter : public WorkerThreadMessageFilter {
diff --git a/content/child/indexed_db/webidbcursor_impl_unittest.cc b/content/child/indexed_db/webidbcursor_impl_unittest.cc
index dfc277e..a21babd 100644
--- a/content/child/indexed_db/webidbcursor_impl_unittest.cc
+++ b/content/child/indexed_db/webidbcursor_impl_unittest.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "base/memory/scoped_ptr.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "content/child/indexed_db/indexed_db_dispatcher.h"
 #include "content/child/indexed_db/indexed_db_key_builders.h"
@@ -122,7 +123,7 @@ class WebIDBCursorImplTest : public testing::Test {
     null_key_.assignNull();
     sync_message_filter_ = new IPC::SyncMessageFilter(NULL);
     thread_safe_sender_ = new ThreadSafeSender(
-        base::MessageLoopProxy::current(), sync_message_filter_.get());
+        base::ThreadTaskRunnerHandle::Get(), sync_message_filter_.get());
     dispatcher_ =
         make_scoped_ptr(new MockDispatcher(thread_safe_sender_.get()));
   }
diff --git a/content/child/npapi/np_channel_base.cc b/content/child/npapi/np_channel_base.cc
index c39ff4c..c227c88 100644
--- a/content/child/npapi/np_channel_base.cc
+++ b/content/child/npapi/np_channel_base.cc
@@ -8,6 +8,7 @@
 #include "base/containers/hash_tables.h"
 #include "base/files/scoped_file.h"
 #include "base/lazy_instance.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_local.h"
 #include "ipc/ipc_sync_message.h"
@@ -62,9 +63,12 @@ ChannelMap* GetChannelMap() {
 }  // namespace
 
 NPChannelBase* NPChannelBase::GetChannel(
-    const IPC::ChannelHandle& channel_handle, IPC::Channel::Mode mode,
-    ChannelFactory factory, base::MessageLoopProxy* ipc_message_loop,
-    bool create_pipe_now, base::WaitableEvent* shutdown_event) {
+    const IPC::ChannelHandle& channel_handle,
+    IPC::Channel::Mode mode,
+    ChannelFactory factory,
+    base::SingleThreadTaskRunner* ipc_task_runner,
+    bool create_pipe_now,
+    base::WaitableEvent* shutdown_event) {
 #if defined(OS_POSIX)
   // On POSIX the channel_handle conveys an FD (socket) which is duped by the
   // kernel during the IPC message exchange (via the SCM_RIGHTS mechanism).
@@ -94,7 +98,7 @@ NPChannelBase* NPChannelBase::GetChannel(
           IPC::Channel::GenerateVerifiedChannelID(channel_key);
     }
     channel->mode_ = mode;
-    if (channel->Init(ipc_message_loop, create_pipe_now, shutdown_event)) {
+    if (channel->Init(ipc_task_runner, create_pipe_now, shutdown_event)) {
       (*GetChannelMap())[channel_key] = channel;
     } else {
       channel = NULL;
@@ -168,7 +172,7 @@ base::WaitableEvent* NPChannelBase::GetModalDialogEvent(int render_view_id) {
   return NULL;
 }
 
-bool NPChannelBase::Init(base::MessageLoopProxy* ipc_message_loop,
+bool NPChannelBase::Init(base::SingleThreadTaskRunner* ipc_task_runner,
                          bool create_pipe_now,
                          base::WaitableEvent* shutdown_event) {
 #if defined(OS_POSIX)
@@ -178,9 +182,9 @@ bool NPChannelBase::Init(base::MessageLoopProxy* ipc_message_loop,
     return false;
 #endif
 
-  channel_ = IPC::SyncChannel::Create(
-      channel_handle_, mode_, this, ipc_message_loop, create_pipe_now,
-      shutdown_event);
+  channel_ =
+      IPC::SyncChannel::Create(channel_handle_, mode_, this, ipc_task_runner,
+                               create_pipe_now, shutdown_event);
 
 #if defined(OS_POSIX)
   // Check the validity of fd for bug investigation.  Remove after fixed.
diff --git a/content/child/npapi/np_channel_base.h b/content/child/npapi/np_channel_base.h
index d718936..3a8c9e3 100644
--- a/content/child/npapi/np_channel_base.h
+++ b/content/child/npapi/np_channel_base.h
@@ -18,7 +18,7 @@
 #include "ipc/ipc_sync_channel.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace content {
@@ -100,9 +100,12 @@ class NPChannelBase : public IPC::Listener,
   // must still ref count the returned value.  When there are no more routes
   // on the channel and its ref count is 0, the object deletes itself.
   static NPChannelBase* GetChannel(
-      const IPC::ChannelHandle& channel_handle, IPC::Channel::Mode mode,
-      ChannelFactory factory, base::MessageLoopProxy* ipc_message_loop,
-      bool create_pipe_now, base::WaitableEvent* shutdown_event);
+      const IPC::ChannelHandle& channel_handle,
+      IPC::Channel::Mode mode,
+      ChannelFactory factory,
+      base::SingleThreadTaskRunner* ipc_task_runner,
+      bool create_pipe_now,
+      base::WaitableEvent* shutdown_event);
 
   // Sends a message to all instances.
   static void Broadcast(IPC::Message* message);
@@ -124,7 +127,7 @@ class NPChannelBase : public IPC::Listener,
     send_unblocking_only_during_unblock_dispatch_ = true;
   }
 
-  virtual bool Init(base::MessageLoopProxy* ipc_message_loop,
+  virtual bool Init(base::SingleThreadTaskRunner* ipc_task_runner,
                     bool create_pipe_now,
                     base::WaitableEvent* shutdown_event);
 
diff --git a/content/child/npapi/plugin_instance.cc b/content/child/npapi/plugin_instance.cc
index 6a10cc8..2200470 100644
--- a/content/child/npapi/plugin_instance.cc
+++ b/content/child/npapi/plugin_instance.cc
@@ -7,9 +7,11 @@
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
-#include "base/message_loop/message_loop.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/child/npapi/plugin_host.h"
 #include "content/child/npapi/plugin_lib.h"
@@ -53,7 +55,7 @@ PluginInstance::PluginInstance(PluginLib* plugin, const std::string& mime_type)
 #endif
       currently_handled_event_(NULL),
 #endif
-      message_loop_(base::MessageLoop::current()),
+      task_runner_(base::ThreadTaskRunnerHandle::Get()),
       load_manually_(false),
       in_close_streams_(false),
       next_timer_id_(1),
@@ -68,7 +70,6 @@ PluginInstance::PluginInstance(PluginLib* plugin, const std::string& mime_type)
     transparent_ = false;
 
   memset(&zero_padding_, 0, sizeof(zero_padding_));
-  DCHECK(message_loop_);
 }
 
 PluginInstance::~PluginInstance() {
@@ -438,7 +439,7 @@ void PluginInstance::DidManualLoadFail() {
 
 void PluginInstance::PluginThreadAsyncCall(void (*func)(void*),
                                            void* user_data) {
-  message_loop_->PostTask(
+  task_runner_->PostTask(
       FROM_HERE, base::Bind(&PluginInstance::OnPluginThreadAsyncCall, this,
                             func, user_data));
 }
@@ -466,7 +467,7 @@ uint32 PluginInstance::ScheduleTimer(uint32 interval,
   timers_[timer_id] = info;
 
   // Schedule the callback.
-  base::MessageLoop::current()->PostDelayedTask(
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&PluginInstance::OnTimerCall, this, func, npp_, timer_id),
       base::TimeDelta::FromMilliseconds(interval));
@@ -508,7 +509,7 @@ void PluginInstance::OnTimerCall(void (*func)(NPP id, uint32 timer_id),
   // Reschedule repeating timers after invoking the callback so callback is not
   // re-entered if it pumps the message loop.
   if (info.repeat) {
-    base::MessageLoop::current()->PostDelayedTask(
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PluginInstance::OnTimerCall, this, func, npp_, timer_id),
         base::TimeDelta::FromMilliseconds(info.interval));
diff --git a/content/child/npapi/plugin_instance.h b/content/child/npapi/plugin_instance.h
index 16fe60c..9558930 100644
--- a/content/child/npapi/plugin_instance.h
+++ b/content/child/npapi/plugin_instance.h
@@ -24,7 +24,7 @@
 #include "url/gurl.h"
 
 namespace base {
-class MessageLoop;
+class SingleThreadTaskRunner;
 }
 
 namespace content {
@@ -305,7 +305,7 @@ class PluginInstance : public base::RefCountedThreadSafe<PluginInstance> {
   gfx::Rect                                containing_window_frame_;
   NPCocoaEvent*                            currently_handled_event_;  // weak
 #endif
-  base::MessageLoop*                       message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<PluginStreamUrl>           plugin_data_stream_;
 
   // This flag if true indicates that the plugin data would be passed from
diff --git a/content/child/npapi/plugin_lib.cc b/content/child/npapi/plugin_lib.cc
index 1d7ebe9..38b27fe 100644
--- a/content/child/npapi/plugin_lib.cc
+++ b/content/child/npapi/plugin_lib.cc
@@ -5,9 +5,11 @@
 #include "content/child/npapi/plugin_lib.h"
 
 #include "base/bind.h"
+#include "base/location.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "content/child/npapi/plugin_host.h"
 #include "content/child/npapi/plugin_instance.h"
 #include "content/common/plugin_list.h"
@@ -289,12 +291,10 @@ void PluginLib::Unload() {
       LOG_IF(ERROR, PluginList::DebugPluginLoading())
           << "Scheduling delayed unload for plugin "
           << web_plugin_info_.path.value();
-      base::MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(&FreePluginLibraryHelper,
-                     web_plugin_info_.path,
-                     skip_unload_ ? NULL : library_,
-                     entry_points_.np_shutdown));
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::Bind(&FreePluginLibraryHelper, web_plugin_info_.path,
+                                skip_unload_ ? NULL : library_,
+                                entry_points_.np_shutdown));
     } else {
       Shutdown();
       if (!skip_unload_) {
diff --git a/content/child/npapi/plugin_stream.cc b/content/child/npapi/plugin_stream.cc
index b069c26..4066dce 100644
--- a/content/child/npapi/plugin_stream.cc
+++ b/content/child/npapi/plugin_stream.cc
@@ -11,9 +11,11 @@
 #include <algorithm>
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "content/child/npapi/plugin_instance.h"
 #include "net/base/mime_util.h"
 #include "url/gurl.h"
@@ -163,7 +165,7 @@ bool PluginStream::WriteToPlugin(const char* buf, const int length,
     delivery_data_.resize(previous_size + remaining);
     data_offset_ = data_offset;
     memcpy(&delivery_data_[previous_size], buf + written, remaining);
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&PluginStream::OnDelayDelivery, this));
   }
 
diff --git a/content/child/power_monitor_broadcast_source.cc b/content/child/power_monitor_broadcast_source.cc
index 0fa5889..061890a 100644
--- a/content/child/power_monitor_broadcast_source.cc
+++ b/content/child/power_monitor_broadcast_source.cc
@@ -4,7 +4,9 @@
 
 #include "content/child/power_monitor_broadcast_source.h"
 
-#include "base/message_loop/message_loop.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "content/common/power_monitor_messages.h"
 #include "ipc/message_filter.h"
 
@@ -12,12 +14,9 @@ namespace content {
 
 class PowerMessageFilter : public IPC::MessageFilter {
  public:
-  PowerMessageFilter(
-      PowerMonitorBroadcastSource* source,
-      scoped_refptr<base::MessageLoopProxy> message_loop)
-      : source_(source),
-        message_loop_(message_loop) {
-  }
+  PowerMessageFilter(PowerMonitorBroadcastSource* source,
+                     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+      : source_(source), task_runner_(task_runner) {}
 
   bool OnMessageReceived(const IPC::Message& message) override {
     bool handled = true;
@@ -40,17 +39,17 @@ class PowerMessageFilter : public IPC::MessageFilter {
   ~PowerMessageFilter() override{};
 
   void OnPowerStateChange(bool on_battery_power) {
-    message_loop_->PostTask(FROM_HERE,
-        base::Bind(&PowerMessageFilter::NotifySourcePowerStateChange, this,
-            on_battery_power));
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(&PowerMessageFilter::NotifySourcePowerStateChange,
+                              this, on_battery_power));
   }
   void OnSuspend() {
-    message_loop_->PostTask(FROM_HERE,
-        base::Bind(&PowerMessageFilter::NotifySourceSuspend, this));
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(&PowerMessageFilter::NotifySourceSuspend, this));
   }
   void OnResume() {
-    message_loop_->PostTask(FROM_HERE,
-        base::Bind(&PowerMessageFilter::NotifySourceResume, this));
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(&PowerMessageFilter::NotifySourceResume, this));
   }
 
   void NotifySourcePowerStateChange(bool on_battery_power) {
@@ -69,15 +68,15 @@ class PowerMessageFilter : public IPC::MessageFilter {
   // source_ should only be accessed on the thread associated with
   // message_loop_.
   PowerMonitorBroadcastSource* source_;
-  scoped_refptr<base::MessageLoopProxy> message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerMessageFilter);
 };
 
 PowerMonitorBroadcastSource::PowerMonitorBroadcastSource()
     : last_reported_battery_power_state_(false) {
-  message_filter_ = new PowerMessageFilter(this,
-      base::MessageLoopProxy::current());
+  message_filter_ =
+      new PowerMessageFilter(this, base::ThreadTaskRunnerHandle::Get());
 }
 
 PowerMonitorBroadcastSource::~PowerMonitorBroadcastSource() {
diff --git a/content/child/scoped_child_process_reference.cc b/content/child/scoped_child_process_reference.cc
index f7d35fb..7571957 100644
--- a/content/child/scoped_child_process_reference.cc
+++ b/content/child/scoped_child_process_reference.cc
@@ -5,6 +5,9 @@
 #include "content/child/scoped_child_process_reference.h"
 
 #include "base/bind.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/child/child_process.h"
 
@@ -23,10 +26,9 @@ ScopedChildProcessReference::~ScopedChildProcessReference() {
 void ScopedChildProcessReference::ReleaseWithDelay(
     const base::TimeDelta& delay) {
   DCHECK(has_reference_);
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&ChildProcess::ReleaseProcess,
-                 base::Unretained(ChildProcess::current())),
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, base::Bind(&ChildProcess::ReleaseProcess,
+                            base::Unretained(ChildProcess::current())),
       delay);
   has_reference_ = false;
 }
diff --git a/content/child/service_worker/service_worker_dispatcher.cc b/content/child/service_worker/service_worker_dispatcher.cc
index dfbcfc1..e68f644 100644
--- a/content/child/service_worker/service_worker_dispatcher.cc
+++ b/content/child/service_worker/service_worker_dispatcher.cc
@@ -6,6 +6,7 @@
 
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_local.h"
 #include "base/trace_event/trace_event.h"
 #include "content/child/child_thread_impl.h"
@@ -636,9 +637,9 @@ void ServiceWorkerDispatcher::OnPostMessage(
   }
 
   blink::WebMessagePortChannelArray ports =
-      WebMessagePortChannelImpl::CreatePorts(sent_message_ports,
-                                             new_routing_ids,
-                                             base::MessageLoopProxy::current());
+      WebMessagePortChannelImpl::CreatePorts(
+          sent_message_ports, new_routing_ids,
+          base::ThreadTaskRunnerHandle::Get());
 
   found->second->dispatchMessageEvent(message, ports);
 }
diff --git a/content/child/service_worker/service_worker_dispatcher_unittest.cc b/content/child/service_worker/service_worker_dispatcher_unittest.cc
index 9b8a33a..eaca487 100644
--- a/content/child/service_worker/service_worker_dispatcher_unittest.cc
+++ b/content/child/service_worker/service_worker_dispatcher_unittest.cc
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/message_loop/message_loop_proxy.h"
 #include "content/child/service_worker/service_worker_dispatcher.h"
 #include "content/child/service_worker/web_service_worker_impl.h"
 #include "content/child/service_worker/web_service_worker_registration_impl.h"
diff --git a/content/child/service_worker/service_worker_provider_context.cc b/content/child/service_worker/service_worker_provider_context.cc
index d8273aa..c606d06d 100644
--- a/content/child/service_worker/service_worker_provider_context.cc
+++ b/content/child/service_worker/service_worker_provider_context.cc
@@ -5,8 +5,9 @@
 #include "content/child/service_worker/service_worker_provider_context.h"
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/location.h"
 #include "base/stl_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "content/child/child_thread_impl.h"
 #include "content/child/service_worker/service_worker_dispatcher.h"
 #include "content/child/service_worker/service_worker_handle_reference.h"
@@ -19,7 +20,7 @@ namespace content {
 
 ServiceWorkerProviderContext::ServiceWorkerProviderContext(int provider_id)
     : provider_id_(provider_id),
-      main_thread_loop_proxy_(base::MessageLoopProxy::current()) {
+      main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
   if (!ChildThreadImpl::current())
     return;  // May be null in some tests.
   thread_safe_sender_ = ChildThreadImpl::current()->thread_safe_sender();
@@ -39,7 +40,7 @@ ServiceWorkerProviderContext::~ServiceWorkerProviderContext() {
 }
 
 ServiceWorkerHandleReference* ServiceWorkerProviderContext::controller() {
-  DCHECK(main_thread_loop_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
   return controller_.get();
 }
 
@@ -64,7 +65,7 @@ void ServiceWorkerProviderContext::SetVersionAttributes(
     ChangedVersionAttributesMask mask,
     const ServiceWorkerVersionAttributes& attrs) {
   base::AutoLock lock(lock_);
-  DCHECK(main_thread_loop_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(registration_);
 
   if (mask.installing_changed()) {
@@ -85,7 +86,7 @@ void ServiceWorkerProviderContext::OnAssociateRegistration(
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   base::AutoLock lock(lock_);
-  DCHECK(main_thread_loop_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!registration_);
   DCHECK_NE(kInvalidServiceWorkerRegistrationId, info.registration_id);
   DCHECK_NE(kInvalidServiceWorkerRegistrationHandleId, info.handle_id);
@@ -102,7 +103,7 @@ void ServiceWorkerProviderContext::OnAssociateRegistration(
 
 void ServiceWorkerProviderContext::OnDisassociateRegistration() {
   base::AutoLock lock(lock_);
-  DCHECK(main_thread_loop_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
 
   controller_.reset();
   active_.reset();
@@ -115,7 +116,7 @@ void ServiceWorkerProviderContext::OnServiceWorkerStateChanged(
     int handle_id,
     blink::WebServiceWorkerState state) {
   base::AutoLock lock(lock_);
-  DCHECK(main_thread_loop_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
 
   ServiceWorkerHandleReference* which = NULL;
   if (handle_id == controller_handle_id())
@@ -139,7 +140,7 @@ void ServiceWorkerProviderContext::OnServiceWorkerStateChanged(
 
 void ServiceWorkerProviderContext::OnSetControllerServiceWorker(
     const ServiceWorkerObjectInfo& info) {
-  DCHECK(main_thread_loop_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(registration_);
 
   // This context is is the primary owner of this handle, keeps the
@@ -152,38 +153,38 @@ void ServiceWorkerProviderContext::OnSetControllerServiceWorker(
 }
 
 int ServiceWorkerProviderContext::installing_handle_id() const {
-  DCHECK(main_thread_loop_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
   return installing_ ? installing_->info().handle_id
                      : kInvalidServiceWorkerHandleId;
 }
 
 int ServiceWorkerProviderContext::waiting_handle_id() const {
-  DCHECK(main_thread_loop_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
   return waiting_ ? waiting_->info().handle_id
                   : kInvalidServiceWorkerHandleId;
 }
 
 int ServiceWorkerProviderContext::active_handle_id() const {
-  DCHECK(main_thread_loop_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
   return active_ ? active_->info().handle_id
                  : kInvalidServiceWorkerHandleId;
 }
 
 int ServiceWorkerProviderContext::controller_handle_id() const {
-  DCHECK(main_thread_loop_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
   return controller_ ? controller_->info().handle_id
                      : kInvalidServiceWorkerHandleId;
 }
 
 int ServiceWorkerProviderContext::registration_handle_id() const {
-  DCHECK(main_thread_loop_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
   return registration_ ? registration_->info().handle_id
                        : kInvalidServiceWorkerRegistrationHandleId;
 }
 
 void ServiceWorkerProviderContext::DestructOnMainThread() const {
-  if (!main_thread_loop_proxy_->RunsTasksOnCurrentThread() &&
-      main_thread_loop_proxy_->DeleteSoon(FROM_HERE, this)) {
+  if (!main_thread_task_runner_->RunsTasksOnCurrentThread() &&
+      main_thread_task_runner_->DeleteSoon(FROM_HERE, this)) {
     return;
   }
   delete this;
diff --git a/content/child/service_worker/service_worker_provider_context.h b/content/child/service_worker/service_worker_provider_context.h
index b54c799..8f8f1b8 100644
--- a/content/child/service_worker/service_worker_provider_context.h
+++ b/content/child/service_worker/service_worker_provider_context.h
@@ -14,7 +14,7 @@
 #include "content/common/service_worker/service_worker_types.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace IPC {
@@ -90,7 +90,7 @@ class ServiceWorkerProviderContext
   void DestructOnMainThread() const;
 
   const int provider_id_;
-  scoped_refptr<base::MessageLoopProxy> main_thread_loop_proxy_;
+  scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
   scoped_refptr<ThreadSafeSender> thread_safe_sender_;
 
   // Protects (installing, waiting, active) worker and registration references.
diff --git a/content/child/thread_safe_sender.cc b/content/child/thread_safe_sender.cc
index 95f9713..2542f22 100644
--- a/content/child/thread_safe_sender.cc
+++ b/content/child/thread_safe_sender.cc
@@ -4,7 +4,7 @@
 
 #include "content/child/thread_safe_sender.h"
 
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "content/child/child_thread_impl.h"
 #include "ipc/ipc_sync_message_filter.h"
 
@@ -14,13 +14,13 @@ ThreadSafeSender::~ThreadSafeSender() {
 }
 
 ThreadSafeSender::ThreadSafeSender(
-    const scoped_refptr<base::MessageLoopProxy>& main_loop,
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
     const scoped_refptr<IPC::SyncMessageFilter>& sync_filter)
-    : main_loop_(main_loop), sync_filter_(sync_filter) {
+    : main_task_runner_(main_task_runner), sync_filter_(sync_filter) {
 }
 
 bool ThreadSafeSender::Send(IPC::Message* msg) {
-  if (main_loop_->BelongsToCurrentThread())
+  if (main_task_runner_->BelongsToCurrentThread())
     return ChildThreadImpl::current()->Send(msg);
   return sync_filter_->Send(msg);
 }
diff --git a/content/child/thread_safe_sender.h b/content/child/thread_safe_sender.h
index a6605aa..0d35f26 100644
--- a/content/child/thread_safe_sender.h
+++ b/content/child/thread_safe_sender.h
@@ -11,7 +11,7 @@
 #include "ipc/ipc_sender.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace IPC {
@@ -29,8 +29,9 @@ class CONTENT_EXPORT ThreadSafeSender
   bool Send(IPC::Message* msg) override;
 
  protected:
-  ThreadSafeSender(const scoped_refptr<base::MessageLoopProxy>& main_loop,
-                   const scoped_refptr<IPC::SyncMessageFilter>& sync_filter);
+  ThreadSafeSender(
+      const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
+      const scoped_refptr<IPC::SyncMessageFilter>& sync_filter);
   ~ThreadSafeSender() override;
 
  private:
@@ -39,7 +40,7 @@ class CONTENT_EXPORT ThreadSafeSender
   friend class WebIDBCursorImplTest;
   friend class base::RefCountedThreadSafe<ThreadSafeSender>;
 
-  scoped_refptr<base::MessageLoopProxy> main_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   scoped_refptr<IPC::SyncMessageFilter> sync_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadSafeSender);
diff --git a/content/child/threaded_data_provider.cc b/content/child/threaded_data_provider.cc
index eea420a..5e0fe97 100644
--- a/content/child/threaded_data_provider.cc
+++ b/content/child/threaded_data_provider.cc
@@ -4,6 +4,8 @@
 
 #include "content/child/threaded_data_provider.h"
 
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
 #include "components/scheduler/child/webthread_impl_for_worker_scheduler.h"
 #include "content/child/child_process.h"
 #include "content/child/child_thread_impl.h"
@@ -21,7 +23,7 @@ namespace {
 class DataProviderMessageFilter : public IPC::MessageFilter {
  public:
   DataProviderMessageFilter(
-      const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
+      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
       const scheduler::WebThreadImplForWorkerScheduler& background_thread,
       const base::WeakPtr<ThreadedDataProvider>&
@@ -39,7 +41,7 @@ class DataProviderMessageFilter : public IPC::MessageFilter {
   void OnReceivedData(int request_id, int data_offset, int data_length,
                       int encoded_data_length);
 
-  const scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
   const scheduler::WebThreadImplForWorkerScheduler& background_thread_;
   // This weakptr can only be dereferenced on the background thread.
@@ -52,14 +54,14 @@ class DataProviderMessageFilter : public IPC::MessageFilter {
 };
 
 DataProviderMessageFilter::DataProviderMessageFilter(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
     const scheduler::WebThreadImplForWorkerScheduler& background_thread,
     const base::WeakPtr<ThreadedDataProvider>&
         background_thread_resource_provider,
     const base::WeakPtr<ThreadedDataProvider>& main_thread_resource_provider,
     int request_id)
-    : io_message_loop_(io_message_loop),
+    : io_task_runner_(io_task_runner),
       main_thread_task_runner_(main_thread_task_runner),
       background_thread_(background_thread),
       background_thread_resource_provider_(background_thread_resource_provider),
@@ -69,7 +71,7 @@ DataProviderMessageFilter::DataProviderMessageFilter(
 }
 
 void DataProviderMessageFilter::OnFilterAdded(IPC::Sender* sender) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   main_thread_task_runner_->PostTask(
       FROM_HERE,
@@ -79,7 +81,7 @@ void DataProviderMessageFilter::OnFilterAdded(IPC::Sender* sender) {
 
 bool DataProviderMessageFilter::OnMessageReceived(
     const IPC::Message& message) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (message.type() != ResourceMsg_DataReceived::ID)
     return false;
@@ -107,7 +109,7 @@ void DataProviderMessageFilter::OnReceivedData(int request_id,
                                                int data_offset,
                                                int data_length,
                                                int encoded_data_length) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   background_thread_.TaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadedDataProvider::OnReceivedDataOnBackgroundThread,
@@ -143,9 +145,8 @@ ThreadedDataProvider::ThreadedDataProvider(
       new base::WeakPtrFactory<ThreadedDataProvider>(this));
 
   filter_ = new DataProviderMessageFilter(
-      ChildProcess::current()->io_message_loop_proxy(),
-      main_thread_task_runner_, background_thread_,
-      background_thread_weak_factory_->GetWeakPtr(),
+      ChildProcess::current()->io_task_runner(), main_thread_task_runner_,
+      background_thread_, background_thread_weak_factory_->GetWeakPtr(),
       main_thread_weak_factory_.GetWeakPtr(), request_id);
 
   ChildThreadImpl::current()->channel()->AddFilter(filter_.get());
diff --git a/content/child/web_data_consumer_handle_impl_unittest.cc b/content/child/web_data_consumer_handle_impl_unittest.cc
index 4aaa4dc..fd250ec 100644
--- a/content/child/web_data_consumer_handle_impl_unittest.cc
+++ b/content/child/web_data_consumer_handle_impl_unittest.cc
@@ -7,10 +7,12 @@
 #include <algorithm>
 #include <string>
 #include "base/bind.h"
+#include "base/location.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/mojo/src/mojo/public/cpp/system/data_pipe.h"
@@ -41,10 +43,9 @@ class ClientImpl final : public WebDataConsumerHandle::Client {
       : operation_(operation) {}
 
   void didGetReadable() override {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&ReadDataOperationBase::ReadMore,
-                   base::Unretained(operation_)));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&ReadDataOperationBase::ReadMore,
+                              base::Unretained(operation_)));
   }
 
  private:
@@ -93,7 +94,7 @@ class ReadDataOperation : public ReadDataOperationBase {
     }
 
     // The operation is done.
-    main_message_loop_->PostTask(FROM_HERE, on_done_);
+    main_message_loop_->task_runner()->PostTask(FROM_HERE, on_done_);
   }
 
  private:
@@ -140,7 +141,7 @@ class TwoPhaseReadDataOperation : public ReadDataOperationBase {
       if (rv != kOk) {
         // Something is wrong.
         result_ = "error";
-        main_message_loop_->PostTask(FROM_HERE, on_done_);
+        main_message_loop_->task_runner()->PostTask(FROM_HERE, on_done_);
         return;
       }
     }
@@ -156,7 +157,7 @@ class TwoPhaseReadDataOperation : public ReadDataOperationBase {
     }
 
     // The operation is done.
-    main_message_loop_->PostTask(FROM_HERE, on_done_);
+    main_message_loop_->task_runner()->PostTask(FROM_HERE, on_done_);
   }
 
  private:
@@ -227,10 +228,9 @@ TEST_F(WebDataConsumerHandleImplTest, ReadData) {
   base::Thread t("DataConsumerHandle test thread");
   ASSERT_TRUE(t.Start());
 
-  t.message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&ReadDataOperation::ReadData,
-                 base::Unretained(operation.get())));
+  t.task_runner()->PostTask(FROM_HERE,
+                            base::Bind(&ReadDataOperation::ReadData,
+                                       base::Unretained(operation.get())));
 
   std::string expected = ProduceData(24 * 1024);
   producer_.reset();
@@ -251,10 +251,9 @@ TEST_F(WebDataConsumerHandleImplTest, TwoPhaseReadData) {
   base::Thread t("DataConsumerHandle test thread");
   ASSERT_TRUE(t.Start());
 
-  t.message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&TwoPhaseReadDataOperation::ReadData,
-                 base::Unretained(operation.get())));
+  t.task_runner()->PostTask(FROM_HERE,
+                            base::Bind(&TwoPhaseReadDataOperation::ReadData,
+                                       base::Unretained(operation.get())));
 
   std::string expected = ProduceData(24 * 1024);
   producer_.reset();
diff --git a/content/child/webmessageportchannel_impl.cc b/content/child/webmessageportchannel_impl.cc
index 7db904da..1e10a24 100644
--- a/content/child/webmessageportchannel_impl.cc
+++ b/content/child/webmessageportchannel_impl.cc
@@ -5,7 +5,6 @@
 #include "content/child/webmessageportchannel_impl.h"
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/values.h"
 #include "content/child/child_process.h"
 #include "content/child/child_thread_impl.h"
diff --git a/content/gpu/gpu_child_thread.cc b/content/gpu/gpu_child_thread.cc
index 3d26c84..7a630e2 100644
--- a/content/gpu/gpu_child_thread.cc
+++ b/content/gpu/gpu_child_thread.cc
@@ -178,12 +178,10 @@ void GpuChildThread::OnInitialize() {
   // Defer creation of the render thread. This is to prevent it from handling
   // IPC messages before the sandbox has been enabled and all other necessary
   // initialization has succeeded.
-  gpu_channel_manager_.reset(
-      new GpuChannelManager(GetRouter(),
-                            watchdog_thread_.get(),
-                            ChildProcess::current()->io_message_loop_proxy(),
-                            ChildProcess::current()->GetShutDownEvent(),
-                            channel()));
+  gpu_channel_manager_.reset(new GpuChannelManager(
+      GetRouter(), watchdog_thread_.get(),
+      ChildProcess::current()->io_task_runner(),
+      ChildProcess::current()->GetShutDownEvent(), channel()));
 
 #if defined(USE_OZONE)
   ui::OzonePlatform::GetInstance()
diff --git a/content/plugin/plugin_channel.cc b/content/plugin/plugin_channel.cc
index d94863ae..1f21c84 100644
--- a/content/plugin/plugin_channel.cc
+++ b/content/plugin/plugin_channel.cc
@@ -140,7 +140,7 @@ class PluginChannel::MessageFilter : public IPC::MessageFilter {
 };
 
 PluginChannel* PluginChannel::GetPluginChannel(
-    int renderer_id, base::MessageLoopProxy* ipc_message_loop) {
+    int renderer_id, base::SingleThreadTaskRunner* ipc_task_runner) {
   // Map renderer ID to a (single) channel to that process.
   std::string channel_key = base::StringPrintf(
       "%d.r%d", base::GetCurrentProcId(), renderer_id);
@@ -150,7 +150,7 @@ PluginChannel* PluginChannel::GetPluginChannel(
           channel_key,
           IPC::Channel::MODE_SERVER,
           ClassFactory,
-          ipc_message_loop,
+          ipc_task_runner,
           false,
           ChildProcess::current()->GetShutDownEvent()));
 
@@ -226,10 +226,10 @@ void PluginChannel::CleanUp() {
   }
 }
 
-bool PluginChannel::Init(base::MessageLoopProxy* ipc_message_loop,
+bool PluginChannel::Init(base::SingleThreadTaskRunner* ipc_task_runner,
                          bool create_pipe_now,
                          base::WaitableEvent* shutdown_event) {
-  if (!NPChannelBase::Init(ipc_message_loop, create_pipe_now, shutdown_event))
+  if (!NPChannelBase::Init(ipc_task_runner, create_pipe_now, shutdown_event))
     return false;
 
   channel_->AddFilter(filter_.get());
diff --git a/content/plugin/plugin_channel.h b/content/plugin/plugin_channel.h
index d3106b3..ee01023 100644
--- a/content/plugin/plugin_channel.h
+++ b/content/plugin/plugin_channel.h
@@ -27,7 +27,7 @@ class PluginChannel : public NPChannelBase {
   // given renderer process. The renderer ID is an opaque unique ID generated
   // by the browser.
   static PluginChannel* GetPluginChannel(
-      int renderer_id, base::MessageLoopProxy* ipc_message_loop);
+      int renderer_id, base::SingleThreadTaskRunner* ipc_task_runner);
 
   // Send a message to all renderers that the process is going to shutdown.
   static void NotifyRenderersOfPendingShutdown();
@@ -61,7 +61,7 @@ class PluginChannel : public NPChannelBase {
 
   // NPChannelBase::
   void CleanUp() override;
-  bool Init(base::MessageLoopProxy* ipc_message_loop,
+  bool Init(base::SingleThreadTaskRunner* ipc_task_runner,
             bool create_pipe_now,
             base::WaitableEvent* shutdown_event) override;
 
diff --git a/content/plugin/plugin_thread.cc b/content/plugin/plugin_thread.cc
index 7fd9bdd..7625109 100644
--- a/content/plugin/plugin_thread.cc
+++ b/content/plugin/plugin_thread.cc
@@ -138,7 +138,7 @@ bool PluginThread::OnControlMessageReceived(const IPC::Message& msg) {
 void PluginThread::OnCreateChannel(int renderer_id,
                                    bool incognito) {
   scoped_refptr<PluginChannel> channel(PluginChannel::GetPluginChannel(
-      renderer_id, ChildProcess::current()->io_message_loop_proxy()));
+      renderer_id, ChildProcess::current()->io_task_runner()));
   IPC::ChannelHandle channel_handle;
   if (channel.get()) {
     channel_handle.name = channel->channel_handle().name;
diff --git a/content/ppapi_plugin/ppapi_thread.cc b/content/ppapi_plugin/ppapi_thread.cc
index 13babb4..a02b64d 100644
--- a/content/ppapi_plugin/ppapi_thread.cc
+++ b/content/ppapi_plugin/ppapi_thread.cc
@@ -175,8 +175,8 @@ void PpapiThread::OnChannelConnected(int32 peer_pid) {
 #endif
 }
 
-base::MessageLoopProxy* PpapiThread::GetIPCMessageLoop() {
-  return ChildProcess::current()->io_message_loop_proxy();
+base::SingleThreadTaskRunner* PpapiThread::GetIPCTaskRunner() {
+  return ChildProcess::current()->io_task_runner();
 }
 
 base::WaitableEvent* PpapiThread::GetShutdownEvent() {
diff --git a/content/ppapi_plugin/ppapi_thread.h b/content/ppapi_plugin/ppapi_thread.h
index 8b4f522..190cfd8 100644
--- a/content/ppapi_plugin/ppapi_thread.h
+++ b/content/ppapi_plugin/ppapi_thread.h
@@ -74,7 +74,7 @@ class PpapiThread : public ChildThreadImpl,
 
   // PluginDispatcher::PluginDelegate implementation.
   std::set<PP_Instance>* GetGloballySeenInstanceIDSet() override;
-  base::MessageLoopProxy* GetIPCMessageLoop() override;
+  base::SingleThreadTaskRunner* GetIPCTaskRunner() override;
   base::WaitableEvent* GetShutdownEvent() override;
   IPC::PlatformFileForTransit ShareHandleWithRemote(
       base::PlatformFile handle,
diff --git a/content/public/renderer/render_thread.h b/content/public/renderer/render_thread.h
index 407128b..d22126c 100644
--- a/content/public/renderer/render_thread.h
+++ b/content/public/renderer/render_thread.h
@@ -54,7 +54,8 @@ class CONTENT_EXPORT RenderThread : virtual public ChildThread {
   virtual IPC::SyncChannel* GetChannel() = 0;
   virtual std::string GetLocale() = 0;
   virtual IPC::SyncMessageFilter* GetSyncMessageFilter() = 0;
-  virtual scoped_refptr<base::MessageLoopProxy> GetIOMessageLoopProxy() = 0;
+  virtual scoped_refptr<base::SingleThreadTaskRunner>
+  GetIOMessageLoopProxy() = 0;
 
   // Called to add or remove a listener for a particular message routing ID.
   // These methods normally get delegated to a MessageRouter.
diff --git a/content/public/test/mock_render_thread.cc b/content/public/test/mock_render_thread.cc
index 34cabd7..40b3046 100644
--- a/content/public/test/mock_render_thread.cc
+++ b/content/public/test/mock_render_thread.cc
@@ -78,9 +78,9 @@ IPC::SyncMessageFilter* MockRenderThread::GetSyncMessageFilter() {
   return NULL;
 }
 
-scoped_refptr<base::MessageLoopProxy>
-    MockRenderThread::GetIOMessageLoopProxy() {
-  return scoped_refptr<base::MessageLoopProxy>();
+scoped_refptr<base::SingleThreadTaskRunner>
+MockRenderThread::GetIOMessageLoopProxy() {
+  return scoped_refptr<base::SingleThreadTaskRunner>();
 }
 
 void MockRenderThread::AddRoute(int32 routing_id, IPC::Listener* listener) {
diff --git a/content/public/test/mock_render_thread.h b/content/public/test/mock_render_thread.h
index 3623ab5..5b34c52 100644
--- a/content/public/test/mock_render_thread.h
+++ b/content/public/test/mock_render_thread.h
@@ -44,7 +44,7 @@ class MockRenderThread : public RenderThread {
   IPC::SyncChannel* GetChannel() override;
   std::string GetLocale() override;
   IPC::SyncMessageFilter* GetSyncMessageFilter() override;
-  scoped_refptr<base::MessageLoopProxy> GetIOMessageLoopProxy() override;
+  scoped_refptr<base::SingleThreadTaskRunner> GetIOMessageLoopProxy() override;
   void AddRoute(int32 routing_id, IPC::Listener* listener) override;
   void RemoveRoute(int32 routing_id) override;
   int GenerateRoutingID() override;
diff --git a/content/renderer/devtools/devtools_agent_filter.cc b/content/renderer/devtools/devtools_agent_filter.cc
index f070c1f..127abb0 100644
--- a/content/renderer/devtools/devtools_agent_filter.cc
+++ b/content/renderer/devtools/devtools_agent_filter.cc
@@ -42,8 +42,9 @@ class MessageImpl : public WebDevToolsAgent::MessageDescriptor {
 
 DevToolsAgentFilter::DevToolsAgentFilter()
     : render_thread_loop_(base::MessageLoop::current()),
-      io_message_loop_proxy_(ChildProcess::current()->io_message_loop_proxy()),
-      current_routing_id_(0) {}
+      io_task_runner_(ChildProcess::current()->io_task_runner()),
+      current_routing_id_(0) {
+}
 
 bool DevToolsAgentFilter::OnMessageReceived(const IPC::Message& message) {
   // Dispatch debugger commands directly from IO.
@@ -73,18 +74,16 @@ void DevToolsAgentFilter::OnDispatchOnInspectorBackend(
 }
 
 void DevToolsAgentFilter::AddEmbeddedWorkerRouteOnMainThread(int32 routing_id) {
-  io_message_loop_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(
-          &DevToolsAgentFilter::AddEmbeddedWorkerRoute, this, routing_id));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&DevToolsAgentFilter::AddEmbeddedWorkerRoute, this,
+                            routing_id));
 }
 
 void DevToolsAgentFilter::RemoveEmbeddedWorkerRouteOnMainThread(
     int32 routing_id) {
-  io_message_loop_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(
-          &DevToolsAgentFilter::RemoveEmbeddedWorkerRoute, this, routing_id));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&DevToolsAgentFilter::RemoveEmbeddedWorkerRoute,
+                            this, routing_id));
 }
 
 void DevToolsAgentFilter::AddEmbeddedWorkerRoute(int32 routing_id) {
diff --git a/content/renderer/devtools/devtools_agent_filter.h b/content/renderer/devtools/devtools_agent_filter.h
index 5f2ce64..c8ba687 100644
--- a/content/renderer/devtools/devtools_agent_filter.h
+++ b/content/renderer/devtools/devtools_agent_filter.h
@@ -14,7 +14,7 @@ struct DevToolsMessageData;
 
 namespace base {
 class MessageLoop;
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace content {
@@ -50,8 +50,7 @@ class DevToolsAgentFilter : public IPC::MessageFilter {
   void RemoveEmbeddedWorkerRoute(int32 routing_id);
 
   base::MessageLoop* render_thread_loop_;
-  // Proxy to the IO message loop.
-  scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   int current_routing_id_;
 
   std::set<int32> embedded_worker_routes_;
diff --git a/content/renderer/media/aec_dump_message_filter.cc b/content/renderer/media/aec_dump_message_filter.cc
index ed6aa4a..3788e18 100644
--- a/content/renderer/media/aec_dump_message_filter.cc
+++ b/content/renderer/media/aec_dump_message_filter.cc
@@ -4,7 +4,7 @@
 
 #include "content/renderer/media/aec_dump_message_filter.h"
 
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "content/common/media/aec_dump_messages.h"
 #include "content/renderer/media/webrtc_logging.h"
 #include "ipc/ipc_logging.h"
@@ -19,12 +19,12 @@ namespace content {
 AecDumpMessageFilter* AecDumpMessageFilter::g_filter = NULL;
 
 AecDumpMessageFilter::AecDumpMessageFilter(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
-    const scoped_refptr<base::MessageLoopProxy>& main_message_loop)
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner)
     : sender_(NULL),
       delegate_id_counter_(0),
-      io_message_loop_(io_message_loop),
-      main_message_loop_(main_message_loop) {
+      io_task_runner_(io_task_runner),
+      main_task_runner_(main_task_runner) {
   DCHECK(!g_filter);
   g_filter = this;
 }
@@ -41,40 +41,34 @@ scoped_refptr<AecDumpMessageFilter> AecDumpMessageFilter::Get() {
 
 void AecDumpMessageFilter::AddDelegate(
     AecDumpMessageFilter::AecDumpDelegate* delegate) {
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(delegate);
   DCHECK_EQ(kInvalidDelegateId, GetIdForDelegate(delegate));
 
   int id = delegate_id_counter_++;
   delegates_[id] = delegate;
 
-  io_message_loop_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(
-          &AecDumpMessageFilter::RegisterAecDumpConsumer,
-          this,
-          id));
+      base::Bind(&AecDumpMessageFilter::RegisterAecDumpConsumer, this, id));
 }
 
 void AecDumpMessageFilter::RemoveDelegate(
     AecDumpMessageFilter::AecDumpDelegate* delegate) {
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(delegate);
 
   int id = GetIdForDelegate(delegate);
   DCHECK_NE(kInvalidDelegateId, id);
   delegates_.erase(id);
 
-  io_message_loop_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(
-          &AecDumpMessageFilter::UnregisterAecDumpConsumer,
-          this,
-          id));
+      base::Bind(&AecDumpMessageFilter::UnregisterAecDumpConsumer, this, id));
 }
 
 void AecDumpMessageFilter::Send(IPC::Message* message) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (sender_)
     sender_->Send(message);
   else
@@ -90,7 +84,7 @@ void AecDumpMessageFilter::UnregisterAecDumpConsumer(int id) {
 }
 
 bool AecDumpMessageFilter::OnMessageReceived(const IPC::Message& message) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AecDumpMessageFilter, message)
     IPC_MESSAGE_HANDLER(AecDumpMsg_EnableAecDump, OnEnableAecDump)
@@ -101,12 +95,12 @@ bool AecDumpMessageFilter::OnMessageReceived(const IPC::Message& message) {
 }
 
 void AecDumpMessageFilter::OnFilterAdded(IPC::Sender* sender) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   sender_ = sender;
 }
 
 void AecDumpMessageFilter::OnFilterRemoved() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   // Once removed, a filter will not be used again.  At this time the
   // observer must be notified so it releases its reference.
@@ -114,41 +108,32 @@ void AecDumpMessageFilter::OnFilterRemoved() {
 }
 
 void AecDumpMessageFilter::OnChannelClosing() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   sender_ = NULL;
-  main_message_loop_->PostTask(
+  main_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(
-          &AecDumpMessageFilter::DoChannelClosingOnDelegates,
-          this));
+      base::Bind(&AecDumpMessageFilter::DoChannelClosingOnDelegates, this));
 }
 
 void AecDumpMessageFilter::OnEnableAecDump(
     int id,
     IPC::PlatformFileForTransit file_handle) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
-  main_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(
-          &AecDumpMessageFilter::DoEnableAecDump,
-          this,
-          id,
-          file_handle));
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  main_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&AecDumpMessageFilter::DoEnableAecDump, this, id,
+                            file_handle));
 }
 
 void AecDumpMessageFilter::OnDisableAecDump() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
-  main_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(
-          &AecDumpMessageFilter::DoDisableAecDump,
-          this));
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  main_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&AecDumpMessageFilter::DoDisableAecDump, this));
 }
 
 void AecDumpMessageFilter::DoEnableAecDump(
     int id,
     IPC::PlatformFileForTransit file_handle) {
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DelegateMap::iterator it = delegates_.find(id);
   if (it != delegates_.end()) {
     it->second->OnAecDumpFile(file_handle);
@@ -161,7 +146,7 @@ void AecDumpMessageFilter::DoEnableAecDump(
 }
 
 void AecDumpMessageFilter::DoDisableAecDump() {
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   for (DelegateMap::iterator it = delegates_.begin();
        it != delegates_.end(); ++it) {
     it->second->OnDisableAecDump();
@@ -169,7 +154,7 @@ void AecDumpMessageFilter::DoDisableAecDump() {
 }
 
 void AecDumpMessageFilter::DoChannelClosingOnDelegates() {
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   for (DelegateMap::iterator it = delegates_.begin();
        it != delegates_.end(); ++it) {
     it->second->OnIpcClosing();
@@ -179,7 +164,7 @@ void AecDumpMessageFilter::DoChannelClosingOnDelegates() {
 
 int AecDumpMessageFilter::GetIdForDelegate(
     AecDumpMessageFilter::AecDumpDelegate* delegate) {
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   for (DelegateMap::iterator it = delegates_.begin();
        it != delegates_.end(); ++it) {
     if (it->second == delegate)
diff --git a/content/renderer/media/aec_dump_message_filter.h b/content/renderer/media/aec_dump_message_filter.h
index 7d7a3bf..548d59f 100644
--- a/content/renderer/media/aec_dump_message_filter.h
+++ b/content/renderer/media/aec_dump_message_filter.h
@@ -13,7 +13,7 @@
 #include "ipc/message_filter.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace content {
@@ -31,8 +31,8 @@ class CONTENT_EXPORT AecDumpMessageFilter : public IPC::MessageFilter {
   };
 
   AecDumpMessageFilter(
-      const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
-      const scoped_refptr<base::MessageLoopProxy>& main_message_loop);
+      const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
+      const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner);
 
   // Getter for the one AecDumpMessageFilter object.
   static scoped_refptr<AecDumpMessageFilter> Get();
@@ -43,9 +43,9 @@ class CONTENT_EXPORT AecDumpMessageFilter : public IPC::MessageFilter {
   // Removes a delegate.
   void RemoveDelegate(AecDumpMessageFilter::AecDumpDelegate* delegate);
 
-  // IO message loop associated with this message filter.
-  scoped_refptr<base::MessageLoopProxy> io_message_loop() const {
-    return io_message_loop_;
+  // IO task runner associated with this message filter.
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner() const {
+    return io_task_runner_;
   }
 
  protected:
@@ -63,39 +63,39 @@ class CONTENT_EXPORT AecDumpMessageFilter : public IPC::MessageFilter {
   // Unregisters a consumer of AEC dump in the browser process.
   void UnregisterAecDumpConsumer(int id);
 
-  // IPC::MessageFilter override. Called on |io_message_loop|.
+  // IPC::MessageFilter override. Called on |io_task_runner|.
   bool OnMessageReceived(const IPC::Message& message) override;
   void OnFilterAdded(IPC::Sender* sender) override;
   void OnFilterRemoved() override;
   void OnChannelClosing() override;
 
-  // Accessed on |io_message_loop|.
+  // Accessed on |io_task_runner_|.
   void OnEnableAecDump(int id, IPC::PlatformFileForTransit file_handle);
   void OnDisableAecDump();
 
-  // Accessed on |main_message_loop_|.
+  // Accessed on |main_task_runner_|.
   void DoEnableAecDump(int id, IPC::PlatformFileForTransit file_handle);
   void DoDisableAecDump();
   void DoChannelClosingOnDelegates();
   int GetIdForDelegate(AecDumpMessageFilter::AecDumpDelegate* delegate);
 
-  // Accessed on |io_message_loop_|.
+  // Accessed on |io_task_runner_|.
   IPC::Sender* sender_;
 
   // The delgates for this filter. Must only be accessed on
-  // |main_message_loop_|.
+  // |main_task_runner_|.
   typedef std::map<int, AecDumpMessageFilter::AecDumpDelegate*> DelegateMap;
   DelegateMap delegates_;
 
   // Counter for generating unique IDs to delegates. Accessed on
-  // |main_message_loop_|.
+  // |main_task_runner_|.
   int delegate_id_counter_;
 
-  // Message loop on which IPC calls are driven.
-  const scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  // Task runner which IPC calls are executed.
+  const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
-  // Main message loop.
-  const scoped_refptr<base::MessageLoopProxy> main_message_loop_;
+  // Main task runner.
+  const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 
   // The singleton instance for this filter.
   static AecDumpMessageFilter* g_filter;
diff --git a/content/renderer/media/audio_device_factory.cc b/content/renderer/media/audio_device_factory.cc
index 6d0dd1d..0cd9d4c 100644
--- a/content/renderer/media/audio_device_factory.cc
+++ b/content/renderer/media/audio_device_factory.cc
@@ -27,7 +27,7 @@ scoped_refptr<media::AudioOutputDevice> AudioDeviceFactory::NewOutputDevice(
 
   AudioMessageFilter* const filter = AudioMessageFilter::Get();
   return new media::AudioOutputDevice(
-      filter->CreateAudioOutputIPC(render_frame_id), filter->io_message_loop());
+      filter->CreateAudioOutputIPC(render_frame_id), filter->io_task_runner());
 }
 
 // static
@@ -42,7 +42,7 @@ scoped_refptr<media::AudioInputDevice> AudioDeviceFactory::NewInputDevice(
 
   AudioInputMessageFilter* const filter = AudioInputMessageFilter::Get();
   return new media::AudioInputDevice(
-      filter->CreateAudioInputIPC(render_frame_id), filter->io_message_loop());
+      filter->CreateAudioInputIPC(render_frame_id), filter->io_task_runner());
 }
 
 AudioDeviceFactory::AudioDeviceFactory() {
diff --git a/content/renderer/media/audio_input_message_filter.cc b/content/renderer/media/audio_input_message_filter.cc
index 6c2906f..286c89e 100644
--- a/content/renderer/media/audio_input_message_filter.cc
+++ b/content/renderer/media/audio_input_message_filter.cc
@@ -5,7 +5,7 @@
 #include "content/renderer/media/audio_input_message_filter.h"
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "content/common/media/audio_messages.h"
 #include "content/renderer/media/webrtc_logging.h"
@@ -53,9 +53,8 @@ class AudioInputMessageFilter::AudioInputIPCImpl
 AudioInputMessageFilter* AudioInputMessageFilter::g_filter = NULL;
 
 AudioInputMessageFilter::AudioInputMessageFilter(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
-    : sender_(NULL),
-      io_message_loop_(io_message_loop) {
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
+    : sender_(NULL), io_task_runner_(io_task_runner) {
   DCHECK(!g_filter);
   g_filter = this;
 }
@@ -71,7 +70,7 @@ AudioInputMessageFilter* AudioInputMessageFilter::Get() {
 }
 
 void AudioInputMessageFilter::Send(IPC::Message* message) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (!sender_) {
     delete message;
   } else {
@@ -80,7 +79,7 @@ void AudioInputMessageFilter::Send(IPC::Message* message) {
 }
 
 bool AudioInputMessageFilter::OnMessageReceived(const IPC::Message& message) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AudioInputMessageFilter, message)
     IPC_MESSAGE_HANDLER(AudioInputMsg_NotifyStreamCreated,
@@ -94,14 +93,14 @@ bool AudioInputMessageFilter::OnMessageReceived(const IPC::Message& message) {
 }
 
 void AudioInputMessageFilter::OnFilterAdded(IPC::Sender* sender) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   // Captures the sender for IPC.
   sender_ = sender;
 }
 
 void AudioInputMessageFilter::OnFilterRemoved() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   // Once removed, a filter will not be used again.  At this time all
   // delegates must be notified so they release their reference.
@@ -109,7 +108,7 @@ void AudioInputMessageFilter::OnFilterRemoved() {
 }
 
 void AudioInputMessageFilter::OnChannelClosing() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   sender_ = NULL;
 
   DLOG_IF(WARNING, !delegates_.IsEmpty())
@@ -129,7 +128,7 @@ void AudioInputMessageFilter::OnStreamCreated(
     base::SyncSocket::TransitDescriptor socket_descriptor,
     uint32 length,
     uint32 total_segments) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   LogMessage(stream_id, "OnStreamCreated");
 
   base::SyncSocket::Handle socket_handle =
@@ -147,7 +146,7 @@ void AudioInputMessageFilter::OnStreamCreated(
 }
 
 void AudioInputMessageFilter::OnStreamVolume(int stream_id, double volume) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   media::AudioInputIPCDelegate* delegate = delegates_.Lookup(stream_id);
   if (!delegate) {
     DLOG(WARNING) << "Got audio stream event for a non-existent or removed"
@@ -159,7 +158,7 @@ void AudioInputMessageFilter::OnStreamVolume(int stream_id, double volume) {
 
 void AudioInputMessageFilter::OnStreamStateChanged(
     int stream_id, media::AudioInputIPCDelegate::State state) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   media::AudioInputIPCDelegate* delegate = delegates_.Lookup(stream_id);
   if (!delegate) {
     DLOG(WARNING) << "Got audio stream event for a non-existent or removed"
@@ -192,7 +191,7 @@ void AudioInputMessageFilter::AudioInputIPCImpl::CreateStream(
     const media::AudioParameters& params,
     bool automatic_gain_control,
     uint32 total_segments) {
-  DCHECK(filter_->io_message_loop_->BelongsToCurrentThread());
+  DCHECK(filter_->io_task_runner_->BelongsToCurrentThread());
   DCHECK(delegate);
 
   stream_id_ = filter_->delegates_.Add(delegate);
@@ -220,7 +219,7 @@ void AudioInputMessageFilter::AudioInputIPCImpl::SetVolume(double volume) {
 }
 
 void AudioInputMessageFilter::AudioInputIPCImpl::CloseStream() {
-  DCHECK(filter_->io_message_loop_->BelongsToCurrentThread());
+  DCHECK(filter_->io_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(stream_id_, kStreamIDNotSet);
   LogMessage(stream_id_, "CloseStream");
   filter_->Send(new AudioInputHostMsg_CloseStream(stream_id_));
diff --git a/content/renderer/media/audio_input_message_filter.h b/content/renderer/media/audio_input_message_filter.h
index 0b29cbc..ad60114 100644
--- a/content/renderer/media/audio_input_message_filter.h
+++ b/content/renderer/media/audio_input_message_filter.h
@@ -14,7 +14,7 @@
 #include "media/audio/audio_input_ipc.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace content {
@@ -26,7 +26,7 @@ namespace content {
 class CONTENT_EXPORT AudioInputMessageFilter : public IPC::MessageFilter {
  public:
   explicit AudioInputMessageFilter(
-      const scoped_refptr<base::MessageLoopProxy>& io_message_loop);
+      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner);
 
   // Getter for the one AudioInputMessageFilter object.
   static AudioInputMessageFilter* Get();
@@ -35,11 +35,11 @@ class CONTENT_EXPORT AudioInputMessageFilter : public IPC::MessageFilter {
   // refers to the RenderFrame containing the entity consuming the audio.
   //
   // The returned object is not thread-safe, and must be used on
-  // |io_message_loop|.
+  // |io_task_runner|.
   scoped_ptr<media::AudioInputIPC> CreateAudioInputIPC(int render_frame_id);
 
-  scoped_refptr<base::MessageLoopProxy> io_message_loop() const {
-    return io_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner() const {
+    return io_task_runner_;
   }
 
  private:
@@ -52,7 +52,7 @@ class CONTENT_EXPORT AudioInputMessageFilter : public IPC::MessageFilter {
   // Sends an IPC message using |channel_|.
   void Send(IPC::Message* message);
 
-  // IPC::MessageFilter override. Called on |io_message_loop_|.
+  // IPC::MessageFilter override. Called on |io_task_runner_|.
   bool OnMessageReceived(const IPC::Message& message) override;
   void OnFilterAdded(IPC::Sender* sender) override;
   void OnFilterRemoved() override;
@@ -80,11 +80,11 @@ class CONTENT_EXPORT AudioInputMessageFilter : public IPC::MessageFilter {
   // A map of stream ids to delegates.
   IDMap<media::AudioInputIPCDelegate> delegates_;
 
-  // IPC sender for Send(), must only be accesed on |io_message_loop_|.
+  // IPC sender for Send(), must only be accesed on |io_task_runner_|.
   IPC::Sender* sender_;
 
-  // Message loop on which IPC calls are driven.
-  const scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  // Task runner on which IPC calls are executed.
+  const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // The singleton instance for this filter.
   static AudioInputMessageFilter* g_filter;
diff --git a/content/renderer/media/audio_message_filter.cc b/content/renderer/media/audio_message_filter.cc
index ce26c13..f2ef3a3 100644
--- a/content/renderer/media/audio_message_filter.cc
+++ b/content/renderer/media/audio_message_filter.cc
@@ -5,7 +5,7 @@
 #include "content/renderer/media/audio_message_filter.h"
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "content/common/media/audio_messages.h"
 #include "content/renderer/media/webrtc_logging.h"
@@ -43,9 +43,8 @@ class AudioMessageFilter::AudioOutputIPCImpl
 AudioMessageFilter* AudioMessageFilter::g_filter = NULL;
 
 AudioMessageFilter::AudioMessageFilter(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
-    : sender_(NULL),
-      io_message_loop_(io_message_loop) {
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
+    : sender_(NULL), io_task_runner_(io_task_runner) {
   DCHECK(!g_filter);
   g_filter = this;
 }
@@ -80,7 +79,7 @@ void AudioMessageFilter::AudioOutputIPCImpl::CreateStream(
     media::AudioOutputIPCDelegate* delegate,
     const media::AudioParameters& params,
     int session_id) {
-  DCHECK(filter_->io_message_loop_->BelongsToCurrentThread());
+  DCHECK(filter_->io_task_runner_->BelongsToCurrentThread());
   DCHECK(delegate);
   DCHECK_EQ(stream_id_, kStreamIDNotSet);
   stream_id_ = filter_->delegates_.Add(delegate);
@@ -99,7 +98,7 @@ void AudioMessageFilter::AudioOutputIPCImpl::PauseStream() {
 }
 
 void AudioMessageFilter::AudioOutputIPCImpl::CloseStream() {
-  DCHECK(filter_->io_message_loop_->BelongsToCurrentThread());
+  DCHECK(filter_->io_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(stream_id_, kStreamIDNotSet);
   filter_->Send(new AudioHostMsg_CloseStream(stream_id_));
   filter_->delegates_.Remove(stream_id_);
@@ -112,7 +111,7 @@ void AudioMessageFilter::AudioOutputIPCImpl::SetVolume(double volume) {
 }
 
 void AudioMessageFilter::Send(IPC::Message* message) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (!sender_) {
     delete message;
   } else {
@@ -121,7 +120,7 @@ void AudioMessageFilter::Send(IPC::Message* message) {
 }
 
 bool AudioMessageFilter::OnMessageReceived(const IPC::Message& message) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AudioMessageFilter, message)
     IPC_MESSAGE_HANDLER(AudioMsg_NotifyStreamCreated, OnStreamCreated)
@@ -132,12 +131,12 @@ bool AudioMessageFilter::OnMessageReceived(const IPC::Message& message) {
 }
 
 void AudioMessageFilter::OnFilterAdded(IPC::Sender* sender) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   sender_ = sender;
 }
 
 void AudioMessageFilter::OnFilterRemoved() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   // Once removed, a filter will not be used again.  At this time all
   // delegates must be notified so they release their reference.
@@ -145,7 +144,7 @@ void AudioMessageFilter::OnFilterRemoved() {
 }
 
 void AudioMessageFilter::OnChannelClosing() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   sender_ = NULL;
 
   DLOG_IF(WARNING, !delegates_.IsEmpty())
@@ -164,7 +163,7 @@ void AudioMessageFilter::OnStreamCreated(
     base::SharedMemoryHandle handle,
     base::SyncSocket::TransitDescriptor socket_descriptor,
     uint32 length) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   WebRtcLogMessage(base::StringPrintf(
       "AMF::OnStreamCreated. stream_id=%d",
@@ -186,7 +185,7 @@ void AudioMessageFilter::OnStreamCreated(
 
 void AudioMessageFilter::OnStreamStateChanged(
     int stream_id, media::AudioOutputIPCDelegate::State state) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   media::AudioOutputIPCDelegate* delegate = delegates_.Lookup(stream_id);
   if (!delegate) {
     DLOG(WARNING) << "Got OnStreamStateChanged() event for a non-existent or"
diff --git a/content/renderer/media/audio_message_filter.h b/content/renderer/media/audio_message_filter.h
index 2404ca0..36ec380 100644
--- a/content/renderer/media/audio_message_filter.h
+++ b/content/renderer/media/audio_message_filter.h
@@ -17,7 +17,7 @@
 #include "media/base/audio_hardware_config.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace content {
@@ -29,7 +29,7 @@ namespace content {
 class CONTENT_EXPORT AudioMessageFilter : public IPC::MessageFilter {
  public:
   explicit AudioMessageFilter(
-      const scoped_refptr<base::MessageLoopProxy>& io_message_loop);
+      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner);
 
   // Getter for the one AudioMessageFilter object.
   static AudioMessageFilter* Get();
@@ -38,12 +38,12 @@ class CONTENT_EXPORT AudioMessageFilter : public IPC::MessageFilter {
   // the RenderFrame containing the entity producing the audio.
   //
   // The returned object is not thread-safe, and must be used on
-  // |io_message_loop|.
+  // |io_task_runner|.
   scoped_ptr<media::AudioOutputIPC> CreateAudioOutputIPC(int render_frame_id);
 
-  // IO message loop associated with this message filter.
-  scoped_refptr<base::MessageLoopProxy> io_message_loop() const {
-    return io_message_loop_;
+  // IO task runner associated with this message filter.
+  base::SingleThreadTaskRunner* io_task_runner() const {
+    return io_task_runner_.get();
   }
 
  protected:
@@ -60,7 +60,7 @@ class CONTENT_EXPORT AudioMessageFilter : public IPC::MessageFilter {
   // Sends an IPC message using |sender_|.
   void Send(IPC::Message* message);
 
-  // IPC::MessageFilter override. Called on |io_message_loop|.
+  // IPC::MessageFilter override. Called on |io_task_runner_|.
   bool OnMessageReceived(const IPC::Message& message) override;
   void OnFilterAdded(IPC::Sender* sender) override;
   void OnFilterRemoved() override;
@@ -76,15 +76,15 @@ class CONTENT_EXPORT AudioMessageFilter : public IPC::MessageFilter {
   void OnStreamStateChanged(int stream_id,
                             media::AudioOutputIPCDelegate::State state);
 
-  // IPC sender for Send(); must only be accesed on |io_message_loop_|.
+  // IPC sender for Send(); must only be accesed on |io_task_runner_|.
   IPC::Sender* sender_;
 
   // A map of stream ids to delegates; must only be accessed on
-  // |io_message_loop_|.
+  // |io_task_runner_|.
   IDMap<media::AudioOutputIPCDelegate> delegates_;
 
-  // Message loop on which IPC calls are driven.
-  const scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  // Task runner on which IPC calls are executed.
+  const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // The singleton instance for this filter.
   static AudioMessageFilter* g_filter;
diff --git a/content/renderer/media/media_stream_video_source.cc b/content/renderer/media/media_stream_video_source.cc
index c4b0c22..f0555ad 100644
--- a/content/renderer/media/media_stream_video_source.cc
+++ b/content/renderer/media/media_stream_video_source.cc
@@ -351,8 +351,8 @@ bool MediaStreamVideoSource::IsConstraintSupported(const std::string& name) {
 
 MediaStreamVideoSource::MediaStreamVideoSource()
     : state_(NEW),
-      track_adapter_(new VideoTrackAdapter(
-          ChildProcess::current()->io_message_loop_proxy())),
+      track_adapter_(
+          new VideoTrackAdapter(ChildProcess::current()->io_task_runner())),
       weak_factory_(this) {
 }
 
@@ -441,10 +441,9 @@ void MediaStreamVideoSource::RemoveTrack(MediaStreamVideoTrack* video_track) {
     StopSource();
 }
 
-const scoped_refptr<base::MessageLoopProxy>&
-MediaStreamVideoSource::io_message_loop() const {
+base::SingleThreadTaskRunner* MediaStreamVideoSource::io_task_runner() const {
   DCHECK(CalledOnValidThread());
-  return track_adapter_->io_message_loop();
+  return track_adapter_->io_task_runner();
 }
 
 void MediaStreamVideoSource::DoStopSource() {
diff --git a/content/renderer/media/media_stream_video_source.h b/content/renderer/media/media_stream_video_source.h
index 496bb85..52771c7 100644
--- a/content/renderer/media/media_stream_video_source.h
+++ b/content/renderer/media/media_stream_video_source.h
@@ -63,7 +63,7 @@ class CONTENT_EXPORT MediaStreamVideoSource
   static bool IsConstraintSupported(const std::string& name);
 
   // Returns the MessageLoopProxy where video frames will be delivered on.
-  const scoped_refptr<base::MessageLoopProxy>& io_message_loop() const;
+  base::SingleThreadTaskRunner* io_task_runner() const;
 
   // Constraint keys used by a video source.
   // Specified by draft-alvestrand-constraints-resolution-00b
diff --git a/content/renderer/media/media_stream_video_track.cc b/content/renderer/media/media_stream_video_track.cc
index 751f764..a782018 100644
--- a/content/renderer/media/media_stream_video_track.cc
+++ b/content/renderer/media/media_stream_video_track.cc
@@ -34,9 +34,8 @@ class MediaStreamVideoTrack::FrameDeliverer
  public:
   typedef MediaStreamVideoSink* VideoSinkId;
 
-  FrameDeliverer(
-      const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
-      bool enabled);
+  FrameDeliverer(scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+                 bool enabled);
 
   void SetEnabled(bool enabled);
 
@@ -62,7 +61,7 @@ class MediaStreamVideoTrack::FrameDeliverer
                        const VideoCaptureDeliverFrameCB& callback);
   void RemoveCallbackOnIO(
       VideoSinkId id,
-      const scoped_refptr<base::MessageLoopProxy>& message_loop);
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
 
   void SetEnabledOnIO(bool enabled);
   // Returns a black frame where the size and time stamp is set to the same as
@@ -73,7 +72,7 @@ class MediaStreamVideoTrack::FrameDeliverer
   // Used to DCHECK that AddCallback and RemoveCallback are called on the main
   // Render Thread.
   base::ThreadChecker main_render_thread_checker_;
-  const scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   bool enabled_;
   scoped_refptr<media::VideoFrame> black_frame_;
@@ -86,10 +85,10 @@ class MediaStreamVideoTrack::FrameDeliverer
 };
 
 MediaStreamVideoTrack::FrameDeliverer::FrameDeliverer(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop, bool enabled)
-    : io_message_loop_(io_message_loop),
-      enabled_(enabled) {
-  DCHECK(io_message_loop_.get());
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+    bool enabled)
+    : io_task_runner_(io_task_runner), enabled_(enabled) {
+  DCHECK(io_task_runner_.get());
 }
 
 MediaStreamVideoTrack::FrameDeliverer::~FrameDeliverer() {
@@ -100,31 +99,29 @@ void MediaStreamVideoTrack::FrameDeliverer::AddCallback(
     VideoSinkId id,
     const VideoCaptureDeliverFrameCB& callback) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
-  io_message_loop_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&FrameDeliverer::AddCallbackOnIO,
-                 this, id, callback));
+      base::Bind(&FrameDeliverer::AddCallbackOnIO, this, id, callback));
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::AddCallbackOnIO(
     VideoSinkId id,
     const VideoCaptureDeliverFrameCB& callback) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   callbacks_.push_back(std::make_pair(id, callback));
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::RemoveCallback(VideoSinkId id) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&FrameDeliverer::RemoveCallbackOnIO,
-                 this, id, base::MessageLoopProxy::current()));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&FrameDeliverer::RemoveCallbackOnIO, this, id,
+                            base::MessageLoopProxy::current()));
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::RemoveCallbackOnIO(
     VideoSinkId id,
-    const scoped_refptr<base::MessageLoopProxy>& message_loop) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   std::vector<VideoIdCallbackPair>::iterator it = callbacks_.begin();
   for (; it != callbacks_.end(); ++it) {
     if (it->first == id) {
@@ -132,7 +129,7 @@ void MediaStreamVideoTrack::FrameDeliverer::RemoveCallbackOnIO(
       scoped_ptr<VideoCaptureDeliverFrameCB> callback;
       callback.reset(new VideoCaptureDeliverFrameCB(it->second));
       callbacks_.erase(it);
-      message_loop->PostTask(
+      task_runner->PostTask(
           FROM_HERE, base::Bind(&ResetCallback, base::Passed(&callback)));
       return;
     }
@@ -141,14 +138,12 @@ void MediaStreamVideoTrack::FrameDeliverer::RemoveCallbackOnIO(
 
 void MediaStreamVideoTrack::FrameDeliverer::SetEnabled(bool enabled) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&FrameDeliverer::SetEnabledOnIO,
-                 this, enabled));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&FrameDeliverer::SetEnabledOnIO, this, enabled));
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::SetEnabledOnIO(bool enabled) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   enabled_ = enabled;
   if (enabled_)
     black_frame_ = NULL;
@@ -157,7 +152,7 @@ void MediaStreamVideoTrack::FrameDeliverer::SetEnabledOnIO(bool enabled) {
 void MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO(
     const scoped_refptr<media::VideoFrame>& frame,
     const base::TimeTicks& estimated_capture_time) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   const scoped_refptr<media::VideoFrame>& video_frame =
       enabled_ ? frame : GetBlackFrame(frame);
   for (const auto& entry : callbacks_)
@@ -167,7 +162,7 @@ void MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO(
 scoped_refptr<media::VideoFrame>
 MediaStreamVideoTrack::FrameDeliverer::GetBlackFrame(
     const scoped_refptr<media::VideoFrame>& reference_frame) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (!black_frame_.get() ||
       black_frame_->natural_size() != reference_frame->natural_size())
     black_frame_ =
@@ -213,7 +208,7 @@ MediaStreamVideoTrack::MediaStreamVideoTrack(
     bool enabled)
     : MediaStreamTrack(true),
       frame_deliverer_(
-          new MediaStreamVideoTrack::FrameDeliverer(source->io_message_loop(),
+          new MediaStreamVideoTrack::FrameDeliverer(source->io_task_runner(),
                                                     enabled)),
       constraints_(constraints),
       source_(source) {
diff --git a/content/renderer/media/midi_message_filter.cc b/content/renderer/media/midi_message_filter.cc
index 07b8543..ceb4f08 100644
--- a/content/renderer/media/midi_message_filter.cc
+++ b/content/renderer/media/midi_message_filter.cc
@@ -7,7 +7,7 @@
 #include <algorithm>
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/media/midi_messages.h"
@@ -25,10 +25,10 @@ namespace content {
 
 // TODO(crbug.com/425389): Rewrite this class as a RenderFrameObserver.
 MidiMessageFilter::MidiMessageFilter(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
     : sender_(nullptr),
-      io_message_loop_(io_message_loop),
-      main_message_loop_(base::MessageLoopProxy::current()),
+      io_task_runner_(io_task_runner),
+      main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       session_result_(media::midi::MIDI_NOT_INITIALIZED),
       unacknowledged_bytes_sent_(0u) {
 }
@@ -36,19 +36,20 @@ MidiMessageFilter::MidiMessageFilter(
 MidiMessageFilter::~MidiMessageFilter() {}
 
 void MidiMessageFilter::AddClient(blink::WebMIDIAccessorClient* client) {
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT0("midi", "MidiMessageFilter::AddClient");
   clients_waiting_session_queue_.push_back(client);
   if (session_result_ != media::midi::MIDI_NOT_INITIALIZED) {
     HandleClientAdded(session_result_);
   } else if (clients_waiting_session_queue_.size() == 1u) {
-    io_message_loop_->PostTask(FROM_HERE,
+    io_task_runner_->PostTask(
+        FROM_HERE,
         base::Bind(&MidiMessageFilter::StartSessionOnIOThread, this));
   }
 }
 
 void MidiMessageFilter::RemoveClient(blink::WebMIDIAccessorClient* client) {
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   clients_.erase(client);
   ClientsQueue::iterator it = std::find(clients_waiting_session_queue_.begin(),
                                         clients_waiting_session_queue_.end(),
@@ -59,8 +60,8 @@ void MidiMessageFilter::RemoveClient(blink::WebMIDIAccessorClient* client) {
     session_result_ = media::midi::MIDI_NOT_INITIALIZED;
     inputs_.clear();
     outputs_.clear();
-    io_message_loop_->PostTask(FROM_HERE,
-        base::Bind(&MidiMessageFilter::EndSessionOnIOThread, this));
+    io_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&MidiMessageFilter::EndSessionOnIOThread, this));
   }
 }
 
@@ -68,7 +69,7 @@ void MidiMessageFilter::SendMidiData(uint32 port,
                                      const uint8* data,
                                      size_t length,
                                      double timestamp) {
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   if ((kMaxUnacknowledgedBytesSent - unacknowledged_bytes_sent_) < length) {
     // TODO(toyoshim): buffer up the data to send at a later time.
     // For now we're just dropping these bytes on the floor.
@@ -77,30 +78,31 @@ void MidiMessageFilter::SendMidiData(uint32 port,
 
   unacknowledged_bytes_sent_ += length;
   std::vector<uint8> v(data, data + length);
-  io_message_loop_->PostTask(FROM_HERE, base::Bind(
-        &MidiMessageFilter::SendMidiDataOnIOThread, this, port, v, timestamp));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&MidiMessageFilter::SendMidiDataOnIOThread, this,
+                            port, v, timestamp));
 }
 
 void MidiMessageFilter::StartSessionOnIOThread() {
   TRACE_EVENT0("midi", "MidiMessageFilter::StartSessionOnIOThread");
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   Send(new MidiHostMsg_StartSession());
 }
 
 void MidiMessageFilter::SendMidiDataOnIOThread(uint32 port,
                                                const std::vector<uint8>& data,
                                                double timestamp) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   Send(new MidiHostMsg_SendData(port, data, timestamp));
 }
 
 void MidiMessageFilter::EndSessionOnIOThread() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   Send(new MidiHostMsg_EndSession());
 }
 
 void MidiMessageFilter::Send(IPC::Message* message) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (!sender_) {
     delete message;
   } else {
@@ -109,7 +111,7 @@ void MidiMessageFilter::Send(IPC::Message* message) {
 }
 
 bool MidiMessageFilter::OnMessageReceived(const IPC::Message& message) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(MidiMessageFilter, message)
     IPC_MESSAGE_HANDLER(MidiMsg_SessionStarted, OnSessionStarted)
@@ -125,86 +127,82 @@ bool MidiMessageFilter::OnMessageReceived(const IPC::Message& message) {
 }
 
 void MidiMessageFilter::OnFilterAdded(IPC::Sender* sender) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   sender_ = sender;
 }
 
 void MidiMessageFilter::OnFilterRemoved() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   // Once removed, a filter will not be used again.  At this time all
   // delegates must be notified so they release their reference.
   OnChannelClosing();
 }
 
 void MidiMessageFilter::OnChannelClosing() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   sender_ = nullptr;
 }
 
 void MidiMessageFilter::OnSessionStarted(media::midi::MidiResult result) {
   TRACE_EVENT0("midi", "MidiMessageFilter::OnSessionStarted");
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   // Handle on the main JS thread.
-  main_message_loop_->PostTask(
+  main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MidiMessageFilter::HandleClientAdded, this, result));
 }
 
 void MidiMessageFilter::OnAddInputPort(media::midi::MidiPortInfo info) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
-  main_message_loop_->PostTask(
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MidiMessageFilter::HandleAddInputPort, this, info));
 }
 
 void MidiMessageFilter::OnAddOutputPort(media::midi::MidiPortInfo info) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
-  main_message_loop_->PostTask(
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MidiMessageFilter::HandleAddOutputPort, this, info));
 }
 
 void MidiMessageFilter::OnSetInputPortState(uint32 port,
                                             media::midi::MidiPortState state) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
-  main_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&MidiMessageFilter::HandleSetInputPortState,
-                 this, port, state));
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  main_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&MidiMessageFilter::HandleSetInputPortState, this,
+                            port, state));
 }
 
 void MidiMessageFilter::OnSetOutputPortState(uint32 port,
                                              media::midi::MidiPortState state) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
-  main_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&MidiMessageFilter::HandleSetOutputPortState,
-                 this, port, state));
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  main_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&MidiMessageFilter::HandleSetOutputPortState, this,
+                            port, state));
 }
 
 void MidiMessageFilter::OnDataReceived(uint32 port,
                                        const std::vector<uint8>& data,
                                        double timestamp) {
   TRACE_EVENT0("midi", "MidiMessageFilter::OnDataReceived");
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   // Handle on the main JS thread.
-  main_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&MidiMessageFilter::HandleDataReceived, this, port, data,
-                 timestamp));
+  main_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&MidiMessageFilter::HandleDataReceived, this, port,
+                            data, timestamp));
 }
 
 void MidiMessageFilter::OnAcknowledgeSentData(size_t bytes_sent) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
-  main_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&MidiMessageFilter::HandleAckknowledgeSentData, this,
-                 bytes_sent));
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  main_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&MidiMessageFilter::HandleAckknowledgeSentData,
+                            this, bytes_sent));
 }
 
 void MidiMessageFilter::HandleClientAdded(media::midi::MidiResult result) {
   TRACE_EVENT0("midi", "MidiMessageFilter::HandleClientAdded");
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   session_result_ = result;
   std::string error;
   std::string message;
@@ -258,7 +256,7 @@ void MidiMessageFilter::HandleClientAdded(media::midi::MidiResult result) {
 }
 
 void MidiMessageFilter::HandleAddInputPort(media::midi::MidiPortInfo info) {
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   inputs_.push_back(info);
   const base::string16 id = base::UTF8ToUTF16(info.id);
   const base::string16 manufacturer = base::UTF8ToUTF16(info.manufacturer);
@@ -271,7 +269,7 @@ void MidiMessageFilter::HandleAddInputPort(media::midi::MidiPortInfo info) {
 }
 
 void MidiMessageFilter::HandleAddOutputPort(media::midi::MidiPortInfo info) {
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   outputs_.push_back(info);
   const base::string16 id = base::UTF8ToUTF16(info.id);
   const base::string16 manufacturer = base::UTF8ToUTF16(info.manufacturer);
@@ -287,7 +285,7 @@ void MidiMessageFilter::HandleDataReceived(uint32 port,
                                            const std::vector<uint8>& data,
                                            double timestamp) {
   TRACE_EVENT0("midi", "MidiMessageFilter::HandleDataReceived");
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(!data.empty());
 
   for (auto client : clients_)
@@ -295,7 +293,7 @@ void MidiMessageFilter::HandleDataReceived(uint32 port,
 }
 
 void MidiMessageFilter::HandleAckknowledgeSentData(size_t bytes_sent) {
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_GE(unacknowledged_bytes_sent_, bytes_sent);
   if (unacknowledged_bytes_sent_ >= bytes_sent)
     unacknowledged_bytes_sent_ -= bytes_sent;
@@ -304,7 +302,7 @@ void MidiMessageFilter::HandleAckknowledgeSentData(size_t bytes_sent) {
 void MidiMessageFilter::HandleSetInputPortState(
     uint32 port,
     media::midi::MidiPortState state) {
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   inputs_[port].state = state;
   for (auto client : clients_)
     client->didSetInputPortState(port, ToBlinkState(state));
@@ -313,7 +311,7 @@ void MidiMessageFilter::HandleSetInputPortState(
 void MidiMessageFilter::HandleSetOutputPortState(
     uint32 port,
     media::midi::MidiPortState state) {
-  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   outputs_[port].state = state;
   for (auto client : clients_)
     client->didSetOutputPortState(port, ToBlinkState(state));
diff --git a/content/renderer/media/midi_message_filter.h b/content/renderer/media/midi_message_filter.h
index 8aa6bf8..26f12b9 100644
--- a/content/renderer/media/midi_message_filter.h
+++ b/content/renderer/media/midi_message_filter.h
@@ -16,7 +16,7 @@
 #include "third_party/WebKit/public/platform/WebMIDIAccessorClient.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace content {
@@ -25,7 +25,7 @@ namespace content {
 class CONTENT_EXPORT MidiMessageFilter : public IPC::MessageFilter {
  public:
   explicit MidiMessageFilter(
-      const scoped_refptr<base::MessageLoopProxy>& io_message_loop);
+      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner);
 
   // Each client registers for MIDI access here.
   // If permission is granted, then the client's
@@ -39,9 +39,9 @@ class CONTENT_EXPORT MidiMessageFilter : public IPC::MessageFilter {
                     size_t length,
                     double timestamp);
 
-  // IO message loop associated with this message filter.
-  scoped_refptr<base::MessageLoopProxy> io_message_loop() const {
-    return io_message_loop_;
+  // IO task runner associated with this message filter.
+  base::SingleThreadTaskRunner* io_task_runner() const {
+    return io_task_runner_.get();
   }
 
   static blink::WebMIDIAccessorClient::MIDIPortState ToBlinkState(
@@ -67,7 +67,7 @@ class CONTENT_EXPORT MidiMessageFilter : public IPC::MessageFilter {
   // Sends an IPC message using |sender_|.
   void Send(IPC::Message* message);
 
-  // IPC::MessageFilter override. Called on |io_message_loop|.
+  // IPC::MessageFilter override. Called on |io_task_runner|.
   bool OnMessageReceived(const IPC::Message& message) override;
   void OnFilterAdded(IPC::Sender* sender) override;
   void OnFilterRemoved() override;
@@ -102,7 +102,7 @@ class CONTENT_EXPORT MidiMessageFilter : public IPC::MessageFilter {
   // sending too much data before knowing how much has already been sent.
   void OnAcknowledgeSentData(size_t bytes_sent);
 
-  // Following methods, Handle*, run on |main_message_loop_|.
+  // Following methods, Handle*, run on |main_task_runner_|.
   void HandleClientAdded(media::midi::MidiResult result);
 
   void HandleAddInputPort(media::midi::MidiPortInfo info);
@@ -116,18 +116,18 @@ class CONTENT_EXPORT MidiMessageFilter : public IPC::MessageFilter {
 
   void HandleAckknowledgeSentData(size_t bytes_sent);
 
-  // IPC sender for Send(); must only be accessed on |io_message_loop_|.
+  // IPC sender for Send(); must only be accessed on |io_task_runner_|.
   IPC::Sender* sender_;
 
-  // Message loop on which IPC calls are driven.
-  const scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  // Task runner on which IPC calls are driven.
+  const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
-  // Main thread's message loop.
-  scoped_refptr<base::MessageLoopProxy> main_message_loop_;
+  // Main task runner.
+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 
   /*
    * Notice: Following members are designed to be accessed only on
-   * |main_message_loop_|.
+   * |main_task_runner_|.
    */
   // Keeps track of all MIDI clients. This should be std::set so that various
   // for-loops work correctly. To change the type, make sure that the new type
diff --git a/content/renderer/media/mock_media_stream_video_source.cc b/content/renderer/media/mock_media_stream_video_source.cc
index cf9f685..bd32430 100644
--- a/content/renderer/media/mock_media_stream_video_source.cc
+++ b/content/renderer/media/mock_media_stream_video_source.cc
@@ -77,9 +77,8 @@ void MockMediaStreamVideoSource::StopSourceImpl() {
 void MockMediaStreamVideoSource::DeliverVideoFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
   DCHECK(!frame_callback_.is_null());
-  io_message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(frame_callback_, frame, base::TimeTicks()));
+  io_task_runner()->PostTask(
+      FROM_HERE, base::Bind(frame_callback_, frame, base::TimeTicks()));
 }
 
 }  // namespace content
diff --git a/content/renderer/media/video_capture_impl_manager.cc b/content/renderer/media/video_capture_impl_manager.cc
index f72f313..3b687ec9 100644
--- a/content/renderer/media/video_capture_impl_manager.cc
+++ b/content/renderer/media/video_capture_impl_manager.cc
@@ -47,12 +47,10 @@ VideoCaptureImplManager::~VideoCaptureImplManager() {
   // Forcibly release all video capture resources.
   for (const auto& device : devices_) {
     VideoCaptureImpl* const impl = device.second.second;
-    ChildProcess::current()->io_message_loop_proxy()->PostTask(
+    ChildProcess::current()->io_task_runner()->PostTask(
         FROM_HERE,
-        base::Bind(&VideoCaptureImpl::DeInit,
-                   base::Unretained(impl)));
-    ChildProcess::current()->io_message_loop_proxy()->DeleteSoon(FROM_HERE,
-                                                                 impl);
+        base::Bind(&VideoCaptureImpl::DeInit, base::Unretained(impl)));
+    ChildProcess::current()->io_task_runner()->DeleteSoon(FROM_HERE, impl);
   }
   devices_.clear();
 }
@@ -68,10 +66,8 @@ base::Closure VideoCaptureImplManager::UseDevice(
     if (!impl)
       impl = new VideoCaptureImpl(id, filter_.get());
     devices_[id] = std::make_pair(1, impl);
-    ChildProcess::current()->io_message_loop_proxy()->PostTask(
-        FROM_HERE,
-        base::Bind(&VideoCaptureImpl::Init,
-                   base::Unretained(impl)));
+    ChildProcess::current()->io_task_runner()->PostTask(
+        FROM_HERE, base::Bind(&VideoCaptureImpl::Init, base::Unretained(impl)));
   } else {
     ++it->second.first;
   }
@@ -92,14 +88,10 @@ base::Closure VideoCaptureImplManager::StartCapture(
   // This ID is used to identify a client of VideoCaptureImpl.
   const int client_id = ++next_client_id_;
 
-  ChildProcess::current()->io_message_loop_proxy()->PostTask(
+  ChildProcess::current()->io_task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&VideoCaptureImpl::StartCapture,
-                 base::Unretained(impl),
-                 client_id,
-                 params,
-                 state_update_cb,
-                 deliver_frame_cb));
+      base::Bind(&VideoCaptureImpl::StartCapture, base::Unretained(impl),
+                 client_id, params, state_update_cb, deliver_frame_cb));
   return base::Bind(&VideoCaptureImplManager::StopCapture,
                     weak_factory_.GetWeakPtr(),
                     client_id, id);
@@ -112,10 +104,9 @@ void VideoCaptureImplManager::GetDeviceSupportedFormats(
   const VideoCaptureDeviceMap::const_iterator it = devices_.find(id);
   DCHECK(it != devices_.end());
   VideoCaptureImpl* const impl = it->second.second;
-  ChildProcess::current()->io_message_loop_proxy()->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoCaptureImpl::GetDeviceSupportedFormats,
-                 base::Unretained(impl), callback));
+  ChildProcess::current()->io_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&VideoCaptureImpl::GetDeviceSupportedFormats,
+                            base::Unretained(impl), callback));
 }
 
 void VideoCaptureImplManager::GetDeviceFormatsInUse(
@@ -125,10 +116,9 @@ void VideoCaptureImplManager::GetDeviceFormatsInUse(
   const VideoCaptureDeviceMap::const_iterator it = devices_.find(id);
   DCHECK(it != devices_.end());
   VideoCaptureImpl* const impl = it->second.second;
-  ChildProcess::current()->io_message_loop_proxy()->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoCaptureImpl::GetDeviceFormatsInUse,
-                 base::Unretained(impl), callback));
+  ChildProcess::current()->io_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&VideoCaptureImpl::GetDeviceFormatsInUse,
+                            base::Unretained(impl), callback));
 }
 
 VideoCaptureImpl*
@@ -144,10 +134,9 @@ void VideoCaptureImplManager::StopCapture(int client_id,
   const VideoCaptureDeviceMap::const_iterator it = devices_.find(id);
   DCHECK(it != devices_.end());
   VideoCaptureImpl* const impl = it->second.second;
-  ChildProcess::current()->io_message_loop_proxy()->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoCaptureImpl::StopCapture,
-                 base::Unretained(impl), client_id));
+  ChildProcess::current()->io_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&VideoCaptureImpl::StopCapture,
+                            base::Unretained(impl), client_id));
 }
 
 void VideoCaptureImplManager::UnrefDevice(
@@ -162,12 +151,10 @@ void VideoCaptureImplManager::UnrefDevice(
   --it->second.first;
   if (!it->second.first) {
     devices_.erase(id);
-    ChildProcess::current()->io_message_loop_proxy()->PostTask(
+    ChildProcess::current()->io_task_runner()->PostTask(
         FROM_HERE,
-        base::Bind(&VideoCaptureImpl::DeInit,
-                   base::Unretained(impl)));
-    ChildProcess::current()->io_message_loop_proxy()->DeleteSoon(FROM_HERE,
-                                                                 impl);
+        base::Bind(&VideoCaptureImpl::DeInit, base::Unretained(impl)));
+    ChildProcess::current()->io_task_runner()->DeleteSoon(FROM_HERE, impl);
   }
 }
 
@@ -175,7 +162,7 @@ void VideoCaptureImplManager::SuspendDevices(bool suspend) {
   DCHECK(render_main_message_loop_->BelongsToCurrentThread());
   for (const auto& device : devices_) {
     VideoCaptureImpl* const impl = device.second.second;
-    ChildProcess::current()->io_message_loop_proxy()->PostTask(
+    ChildProcess::current()->io_task_runner()->PostTask(
         FROM_HERE, base::Bind(&VideoCaptureImpl::SuspendCapture,
                               base::Unretained(impl), suspend));
   }
diff --git a/content/renderer/media/video_capture_impl_manager_unittest.cc b/content/renderer/media/video_capture_impl_manager_unittest.cc
index 39c9e8e..a777d65 100644
--- a/content/renderer/media/video_capture_impl_manager_unittest.cc
+++ b/content/renderer/media/video_capture_impl_manager_unittest.cc
@@ -77,14 +77,12 @@ class VideoCaptureImplManagerTest : public ::testing::Test {
   }
 
   void FakeChannelSetup() {
-    scoped_refptr<base::MessageLoopProxy> loop =
-        child_process_->io_message_loop_proxy();
-    if (!loop->BelongsToCurrentThread()) {
-      loop->PostTask(
-          FROM_HERE,
-          base::Bind(
-              &VideoCaptureImplManagerTest::FakeChannelSetup,
-              base::Unretained(this)));
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner =
+        child_process_->io_task_runner();
+    if (!task_runner->BelongsToCurrentThread()) {
+      task_runner->PostTask(
+          FROM_HERE, base::Bind(&VideoCaptureImplManagerTest::FakeChannelSetup,
+                                base::Unretained(this)));
       return;
     }
     manager_->video_capture_message_filter()->OnFilterAdded(NULL);
diff --git a/content/renderer/media/video_track_adapter.cc b/content/renderer/media/video_track_adapter.cc
index 453e10c..aa4e401 100644
--- a/content/renderer/media/video_track_adapter.cc
+++ b/content/renderer/media/video_track_adapter.cc
@@ -358,14 +358,14 @@ bool VideoTrackAdapter::VideoFrameResolutionAdapter::MaybeDropFrame(
 }
 
 VideoTrackAdapter::VideoTrackAdapter(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
-    : io_message_loop_(io_message_loop),
-      renderer_task_runner_(base::MessageLoopProxy::current()),
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
+    : io_task_runner_(io_task_runner),
+      renderer_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       monitoring_frame_rate_(false),
       muted_state_(false),
       frame_counter_(0),
       source_frame_rate_(0.0f) {
-  DCHECK(io_message_loop_.get());
+  DCHECK(io_task_runner);
 }
 
 VideoTrackAdapter::~VideoTrackAdapter() {
@@ -381,11 +381,11 @@ void VideoTrackAdapter::AddTrack(const MediaStreamVideoTrack* track,
                                  double max_frame_rate) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  io_message_loop_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&VideoTrackAdapter::AddTrackOnIO,
-                 this, track, frame_callback, gfx::Size(max_width, max_height),
-                 min_aspect_ratio, max_aspect_ratio, max_frame_rate));
+      base::Bind(&VideoTrackAdapter::AddTrackOnIO, this, track, frame_callback,
+                 gfx::Size(max_width, max_height), min_aspect_ratio,
+                 max_aspect_ratio, max_frame_rate));
 }
 
 void VideoTrackAdapter::AddTrackOnIO(const MediaStreamVideoTrack* track,
@@ -394,7 +394,7 @@ void VideoTrackAdapter::AddTrackOnIO(const MediaStreamVideoTrack* track,
                                      double min_aspect_ratio,
                                      double max_aspect_ratio,
                                      double max_frame_rate) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   scoped_refptr<VideoFrameResolutionAdapter> adapter;
   for (const auto& frame_adapter : adapters_) {
     if (frame_adapter->ConstraintsMatch(max_frame_size, min_aspect_ratio,
@@ -417,9 +417,8 @@ void VideoTrackAdapter::AddTrackOnIO(const MediaStreamVideoTrack* track,
 
 void VideoTrackAdapter::RemoveTrack(const MediaStreamVideoTrack* track) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoTrackAdapter::RemoveTrackOnIO, this, track));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoTrackAdapter::RemoveTrackOnIO, this, track));
 }
 
 void VideoTrackAdapter::StartFrameMonitoring(
@@ -430,23 +429,21 @@ void VideoTrackAdapter::StartFrameMonitoring(
   VideoTrackAdapter::OnMutedCallback bound_on_muted_callback =
       media::BindToCurrentLoop(on_muted_callback);
 
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoTrackAdapter::StartFrameMonitoringOnIO,
-                 this, bound_on_muted_callback, source_frame_rate));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoTrackAdapter::StartFrameMonitoringOnIO, this,
+                            bound_on_muted_callback, source_frame_rate));
 }
 
 void VideoTrackAdapter::StopFrameMonitoring() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoTrackAdapter::StopFrameMonitoringOnIO, this));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoTrackAdapter::StopFrameMonitoringOnIO, this));
 }
 
 void VideoTrackAdapter::StartFrameMonitoringOnIO(
     const OnMutedCallback& on_muted_callback,
     double source_frame_rate) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   DCHECK(!monitoring_frame_rate_);
 
   monitoring_frame_rate_ = true;
@@ -457,20 +454,20 @@ void VideoTrackAdapter::StartFrameMonitoringOnIO(
   source_frame_rate_ = source_frame_rate;
   DVLOG(1) << "Monitoring frame creation, first (large) delay: "
       << (kFirstFrameTimeoutInFrameIntervals / source_frame_rate_) << "s";
-  io_message_loop_->PostDelayedTask(FROM_HERE,
-       base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
-                  on_muted_callback, frame_counter_),
-       base::TimeDelta::FromSecondsD(kFirstFrameTimeoutInFrameIntervals /
-                                     source_frame_rate_));
+  io_task_runner_->PostDelayedTask(
+      FROM_HERE, base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
+                            on_muted_callback, frame_counter_),
+      base::TimeDelta::FromSecondsD(kFirstFrameTimeoutInFrameIntervals /
+                                    source_frame_rate_));
 }
 
 void VideoTrackAdapter::StopFrameMonitoringOnIO() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   monitoring_frame_rate_ = false;
 }
 
 void VideoTrackAdapter::RemoveTrackOnIO(const MediaStreamVideoTrack* track) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   for (FrameAdapters::iterator it = adapters_.begin();
        it != adapters_.end(); ++it) {
     (*it)->RemoveCallback(track);
@@ -484,7 +481,7 @@ void VideoTrackAdapter::RemoveTrackOnIO(const MediaStreamVideoTrack* track) {
 void VideoTrackAdapter::DeliverFrameOnIO(
     const scoped_refptr<media::VideoFrame>& frame,
     const base::TimeTicks& estimated_capture_time) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT0("video", "VideoTrackAdapter::DeliverFrameOnIO");
   ++frame_counter_;
   for (const auto& adapter : adapters_)
@@ -494,7 +491,7 @@ void VideoTrackAdapter::DeliverFrameOnIO(
 void VideoTrackAdapter::CheckFramesReceivedOnIO(
     const OnMutedCallback& set_muted_state_callback,
     uint64 old_frame_counter_snapshot) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (!monitoring_frame_rate_)
     return;
@@ -508,9 +505,9 @@ void VideoTrackAdapter::CheckFramesReceivedOnIO(
     muted_state_ = muted_state;
   }
 
-  io_message_loop_->PostDelayedTask(FROM_HERE,
-      base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
-          set_muted_state_callback, frame_counter_),
+  io_task_runner_->PostDelayedTask(
+      FROM_HERE, base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
+                            set_muted_state_callback, frame_counter_),
       base::TimeDelta::FromSecondsD(kNormalFrameTimeoutInFrameIntervals /
                                     source_frame_rate_));
 }
diff --git a/content/renderer/media/video_track_adapter.h b/content/renderer/media/video_track_adapter.h
index 56aaa6a..179deb8 100644
--- a/content/renderer/media/video_track_adapter.h
+++ b/content/renderer/media/video_track_adapter.h
@@ -30,7 +30,7 @@ class VideoTrackAdapter
   typedef base::Callback<void(bool mute_state)> OnMutedCallback;
 
   explicit VideoTrackAdapter(
-      const scoped_refptr<base::MessageLoopProxy>& io_message_loop);
+      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner);
 
   // Register |track| to receive video frames in |frame_callback| with
   // a resolution within the boundaries of the arguments.
@@ -52,9 +52,9 @@ class VideoTrackAdapter
       const scoped_refptr<media::VideoFrame>& frame,
       const base::TimeTicks& estimated_capture_time);
 
-  const scoped_refptr<base::MessageLoopProxy>& io_message_loop() {
+  base::SingleThreadTaskRunner* io_task_runner() const {
     DCHECK(thread_checker_.CalledOnValidThread());
-    return io_message_loop_;
+    return io_task_runner_.get();
   }
 
   // Start monitor that frames are delivered to this object. I.E, that
@@ -90,7 +90,7 @@ class VideoTrackAdapter
   // |thread_checker_| is bound to the main render thread.
   base::ThreadChecker thread_checker_;
 
-  const scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // |renderer_task_runner_| is used to ensure that
   // VideoCaptureDeliverFrameCB is released on the main render thread.
diff --git a/content/renderer/media/webrtc/media_stream_remote_video_source.cc b/content/renderer/media/webrtc/media_stream_remote_video_source.cc
index 9fa3e5d..e2d69247 100644
--- a/content/renderer/media/webrtc/media_stream_remote_video_source.cc
+++ b/content/renderer/media/webrtc/media_stream_remote_video_source.cc
@@ -7,7 +7,6 @@
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/threading/thread_checker.h"
 #include "base/trace_event/trace_event.h"
 #include "content/renderer/media/webrtc/track_observer.h"
@@ -25,7 +24,7 @@ class MediaStreamRemoteVideoSource::RemoteVideoSourceDelegate
       public webrtc::VideoRendererInterface {
  public:
   RemoteVideoSourceDelegate(
-      const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
+      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       const VideoCaptureDeliverFrameCB& new_frame_callback);
 
  protected:
@@ -44,18 +43,17 @@ class MediaStreamRemoteVideoSource::RemoteVideoSourceDelegate
   // Bound to the render thread.
   base::ThreadChecker thread_checker_;
 
-  scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // |frame_callback_| is accessed on the IO thread.
   VideoCaptureDeliverFrameCB frame_callback_;
 };
 
-MediaStreamRemoteVideoSource::
-RemoteVideoSourceDelegate::RemoteVideoSourceDelegate(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
-    const VideoCaptureDeliverFrameCB& new_frame_callback)
-    : io_message_loop_(io_message_loop),
-      frame_callback_(new_frame_callback) {
+MediaStreamRemoteVideoSource::RemoteVideoSourceDelegate::
+    RemoteVideoSourceDelegate(
+        scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+        const VideoCaptureDeliverFrameCB& new_frame_callback)
+    : io_task_runner_(io_task_runner), frame_callback_(new_frame_callback) {
 }
 
 MediaStreamRemoteVideoSource::
@@ -97,16 +95,15 @@ void MediaStreamRemoteVideoSource::RemoteVideoSourceDelegate::RenderFrame(
         base::Bind(&base::DeletePointer<cricket::VideoFrame>, frame->Copy()));
   }
 
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&RemoteVideoSourceDelegate::DoRenderFrameOnIOThread,
-                 this, video_frame));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&RemoteVideoSourceDelegate::DoRenderFrameOnIOThread,
+                            this, video_frame));
 }
 
 void MediaStreamRemoteVideoSource::
 RemoteVideoSourceDelegate::DoRenderFrameOnIOThread(
     const scoped_refptr<media::VideoFrame>& video_frame) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT0("webrtc", "RemoteVideoSourceDelegate::DoRenderFrameOnIOThread");
   // TODO(hclam): Give the estimated capture time.
   frame_callback_.Run(video_frame, base::TimeTicks());
@@ -143,7 +140,7 @@ void MediaStreamRemoteVideoSource::StartSourceImpl(
     const VideoCaptureDeliverFrameCB& frame_callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!delegate_.get());
-  delegate_ = new RemoteVideoSourceDelegate(io_message_loop(), frame_callback);
+  delegate_ = new RemoteVideoSourceDelegate(io_task_runner(), frame_callback);
   scoped_refptr<webrtc::VideoTrackInterface> video_track(
       static_cast<webrtc::VideoTrackInterface*>(observer_->track().get()));
   video_track->AddRenderer(delegate_.get());
diff --git a/content/renderer/media/webrtc/video_destination_handler.cc b/content/renderer/media/webrtc/video_destination_handler.cc
index febc4e0..d80f3e7 100644
--- a/content/renderer/media/webrtc/video_destination_handler.cc
+++ b/content/renderer/media/webrtc/video_destination_handler.cc
@@ -29,7 +29,7 @@ class PpFrameWriter::FrameWriterDelegate
     : public base::RefCountedThreadSafe<FrameWriterDelegate> {
  public:
   FrameWriterDelegate(
-      const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy,
+      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       const VideoCaptureDeliverFrameCB& new_frame_callback);
 
   void DeliverFrame(const scoped_refptr<media::VideoFrame>& frame);
@@ -39,15 +39,14 @@ class PpFrameWriter::FrameWriterDelegate
 
   void DeliverFrameOnIO(const scoped_refptr<media::VideoFrame>& frame);
 
-  scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   VideoCaptureDeliverFrameCB new_frame_callback_;
 };
 
 PpFrameWriter::FrameWriterDelegate::FrameWriterDelegate(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     const VideoCaptureDeliverFrameCB& new_frame_callback)
-    : io_message_loop_(io_message_loop_proxy),
-      new_frame_callback_(new_frame_callback) {
+    : io_task_runner_(io_task_runner), new_frame_callback_(new_frame_callback) {
 }
 
 PpFrameWriter::FrameWriterDelegate::~FrameWriterDelegate() {
@@ -55,14 +54,14 @@ PpFrameWriter::FrameWriterDelegate::~FrameWriterDelegate() {
 
 void PpFrameWriter::FrameWriterDelegate::DeliverFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
-  io_message_loop_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&FrameWriterDelegate::DeliverFrameOnIO, this, frame));
 }
 
 void PpFrameWriter::FrameWriterDelegate::DeliverFrameOnIO(
      const scoped_refptr<media::VideoFrame>& frame) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   // The local time when this frame is generated is unknown so give a null
   // value to |estimated_capture_time|.
   new_frame_callback_.Run(frame, base::TimeTicks());
@@ -96,7 +95,7 @@ void PpFrameWriter::StartSourceImpl(
   DCHECK(CalledOnValidThread());
   DCHECK(!delegate_.get());
   DVLOG(3) << "PpFrameWriter::StartSourceImpl()";
-  delegate_ = new FrameWriterDelegate(io_message_loop(), frame_callback);
+  delegate_ = new FrameWriterDelegate(io_task_runner(), frame_callback);
   OnStartDone(MEDIA_DEVICE_OK);
 }
 
diff --git a/content/renderer/npapi/plugin_channel_host.cc b/content/renderer/npapi/plugin_channel_host.cc
index 679288f5..d552ff8 100644
--- a/content/renderer/npapi/plugin_channel_host.cc
+++ b/content/renderer/npapi/plugin_channel_host.cc
@@ -60,15 +60,11 @@ bool* PluginChannelHost::GetRemoveTrackingFlag() {
 // static
 PluginChannelHost* PluginChannelHost::GetPluginChannelHost(
     const IPC::ChannelHandle& channel_handle,
-    base::MessageLoopProxy* ipc_message_loop) {
+    base::SingleThreadTaskRunner* ipc_task_runner) {
   PluginChannelHost* result =
       static_cast<PluginChannelHost*>(NPChannelBase::GetChannel(
-          channel_handle,
-          IPC::Channel::MODE_CLIENT,
-          ClassFactory,
-          ipc_message_loop,
-          true,
-          ChildProcess::current()->GetShutDownEvent()));
+          channel_handle, IPC::Channel::MODE_CLIENT, ClassFactory,
+          ipc_task_runner, true, ChildProcess::current()->GetShutDownEvent()));
   return result;
 }
 
@@ -78,10 +74,10 @@ PluginChannelHost::PluginChannelHost() : expecting_shutdown_(false) {
 PluginChannelHost::~PluginChannelHost() {
 }
 
-bool PluginChannelHost::Init(base::MessageLoopProxy* ipc_message_loop,
+bool PluginChannelHost::Init(base::SingleThreadTaskRunner* ipc_task_runner,
                              bool create_pipe_now,
                              base::WaitableEvent* shutdown_event) {
-  return NPChannelBase::Init(ipc_message_loop, create_pipe_now, shutdown_event);
+  return NPChannelBase::Init(ipc_task_runner, create_pipe_now, shutdown_event);
 }
 
 int PluginChannelHost::GenerateRouteID() {
diff --git a/content/renderer/npapi/plugin_channel_host.h b/content/renderer/npapi/plugin_channel_host.h
index a76f824..6c6f8e2 100644
--- a/content/renderer/npapi/plugin_channel_host.h
+++ b/content/renderer/npapi/plugin_channel_host.h
@@ -23,9 +23,9 @@ class PluginChannelHost : public NPChannelBase {
 #endif
   static PluginChannelHost* GetPluginChannelHost(
       const IPC::ChannelHandle& channel_handle,
-      base::MessageLoopProxy* ipc_message_loop);
+      base::SingleThreadTaskRunner* ipc_task_runner);
 
-  bool Init(base::MessageLoopProxy* ipc_message_loop,
+  bool Init(base::SingleThreadTaskRunner* ipc_task_runner,
             bool create_pipe_now,
             base::WaitableEvent* shutdown_event) override;
 
diff --git a/content/renderer/npapi/webplugin_delegate_proxy.cc b/content/renderer/npapi/webplugin_delegate_proxy.cc
index 8e83b86..e5566bc 100644
--- a/content/renderer/npapi/webplugin_delegate_proxy.cc
+++ b/content/renderer/npapi/webplugin_delegate_proxy.cc
@@ -321,9 +321,8 @@ bool WebPluginDelegateProxy::Initialize(
       return false;
     }
 
-    channel_host =
-        PluginChannelHost::GetPluginChannelHost(
-            channel_handle, ChildProcess::current()->io_message_loop_proxy());
+    channel_host = PluginChannelHost::GetPluginChannelHost(
+        channel_handle, ChildProcess::current()->io_task_runner());
     if (!channel_host.get()) {
       LOG(ERROR) << "Couldn't get PluginChannelHost";
       continue;
diff --git a/content/renderer/p2p/host_address_request.cc b/content/renderer/p2p/host_address_request.cc
index e21e0aa..6c7f262 100644
--- a/content/renderer/p2p/host_address_request.cc
+++ b/content/renderer/p2p/host_address_request.cc
@@ -16,7 +16,7 @@ namespace content {
 P2PAsyncAddressResolver::P2PAsyncAddressResolver(
     P2PSocketDispatcher* dispatcher)
     : dispatcher_(dispatcher),
-      ipc_message_loop_(dispatcher->message_loop()),
+      ipc_task_runner_(dispatcher->task_runner()),
       delegate_message_loop_(base::MessageLoopProxy::current()),
       state_(STATE_CREATED),
       request_id_(0),
@@ -35,8 +35,9 @@ void P2PAsyncAddressResolver::Start(const rtc::SocketAddress& host_name,
   DCHECK_EQ(STATE_CREATED, state_);
 
   state_ = STATE_SENT;
-  ipc_message_loop_->PostTask(FROM_HERE, base::Bind(
-      &P2PAsyncAddressResolver::DoSendRequest, this, host_name, done_callback));
+  ipc_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&P2PAsyncAddressResolver::DoSendRequest, this,
+                            host_name, done_callback));
 }
 
 void P2PAsyncAddressResolver::Cancel() {
@@ -44,8 +45,8 @@ void P2PAsyncAddressResolver::Cancel() {
 
   if (state_ != STATE_FINISHED) {
     state_ = STATE_FINISHED;
-    ipc_message_loop_->PostTask(FROM_HERE, base::Bind(
-        &P2PAsyncAddressResolver::DoUnregister, this));
+    ipc_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&P2PAsyncAddressResolver::DoUnregister, this));
   }
   done_callback_.Reset();
 }
@@ -53,7 +54,7 @@ void P2PAsyncAddressResolver::Cancel() {
 void P2PAsyncAddressResolver::DoSendRequest(
     const rtc::SocketAddress& host_name,
     const DoneCallback& done_callback) {
-  DCHECK(ipc_message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
 
   done_callback_ = done_callback;
   request_id_ = dispatcher_->RegisterHostAddressRequest(this);
@@ -63,7 +64,7 @@ void P2PAsyncAddressResolver::DoSendRequest(
 }
 
 void P2PAsyncAddressResolver::DoUnregister() {
-  DCHECK(ipc_message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   if (registered_) {
     dispatcher_->UnregisterHostAddressRequest(request_id_);
     registered_ = false;
@@ -71,7 +72,7 @@ void P2PAsyncAddressResolver::DoUnregister() {
 }
 
 void P2PAsyncAddressResolver::OnResponse(const net::IPAddressList& addresses) {
-  DCHECK(ipc_message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   DCHECK(registered_);
 
   dispatcher_->UnregisterHostAddressRequest(request_id_);
diff --git a/content/renderer/p2p/host_address_request.h b/content/renderer/p2p/host_address_request.h
index ab45486..4197ebe 100644
--- a/content/renderer/p2p/host_address_request.h
+++ b/content/renderer/p2p/host_address_request.h
@@ -16,6 +16,7 @@
 namespace base {
 class MessageLoop;
 class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace content {
@@ -56,7 +57,7 @@ class P2PAsyncAddressResolver
   void DeliverResponse(const net::IPAddressList& address);
 
   P2PSocketDispatcher* dispatcher_;
-  scoped_refptr<base::MessageLoopProxy> ipc_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner_;
   scoped_refptr<base::MessageLoopProxy> delegate_message_loop_;
 
   // State must be accessed from delegate thread only.
diff --git a/content/renderer/p2p/socket_client_impl.cc b/content/renderer/p2p/socket_client_impl.cc
index 2dc0c7c..7994cb0 100644
--- a/content/renderer/p2p/socket_client_impl.cc
+++ b/content/renderer/p2p/socket_client_impl.cc
@@ -28,9 +28,10 @@ namespace content {
 
 P2PSocketClientImpl::P2PSocketClientImpl(P2PSocketDispatcher* dispatcher)
     : dispatcher_(dispatcher),
-      ipc_message_loop_(dispatcher->message_loop()),
+      ipc_task_runner_(dispatcher->task_runner()),
       delegate_message_loop_(base::MessageLoopProxy::current()),
-      socket_id_(0), delegate_(NULL),
+      socket_id_(0),
+      delegate_(NULL),
       state_(STATE_UNINITIALIZED),
       random_socket_id_(0),
       next_packet_id_(0) {
@@ -51,12 +52,9 @@ void P2PSocketClientImpl::Init(
   // |delegate_| is only accessesed on |delegate_message_loop_|.
   delegate_ = delegate;
 
-  ipc_message_loop_->PostTask(
-      FROM_HERE, base::Bind(&P2PSocketClientImpl::DoInit,
-                            this,
-                            type,
-                            local_address,
-                            remote_address));
+  ipc_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&P2PSocketClientImpl::DoInit, this, type,
+                            local_address, remote_address));
 }
 
 void P2PSocketClientImpl::DoInit(P2PSocketType type,
@@ -73,8 +71,8 @@ uint64_t P2PSocketClientImpl::Send(const net::IPEndPoint& address,
                                    const std::vector<char>& data,
                                    const rtc::PacketOptions& options) {
   uint64_t unique_id = GetUniqueId(random_socket_id_, ++next_packet_id_);
-  if (!ipc_message_loop_->BelongsToCurrentThread()) {
-    ipc_message_loop_->PostTask(
+  if (!ipc_task_runner_->BelongsToCurrentThread()) {
+    ipc_task_runner_->PostTask(
         FROM_HERE, base::Bind(&P2PSocketClientImpl::SendWithPacketId, this,
                               address, data, options, unique_id));
     return unique_id;
@@ -100,10 +98,10 @@ void P2PSocketClientImpl::SendWithPacketId(const net::IPEndPoint& address,
 
 void P2PSocketClientImpl::SetOption(P2PSocketOption option,
                                     int value) {
-  if (!ipc_message_loop_->BelongsToCurrentThread()) {
-    ipc_message_loop_->PostTask(
-        FROM_HERE, base::Bind(
-            &P2PSocketClientImpl::SetOption, this, option, value));
+  if (!ipc_task_runner_->BelongsToCurrentThread()) {
+    ipc_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&P2PSocketClientImpl::SetOption, this, option, value));
     return;
   }
 
@@ -119,12 +117,12 @@ void P2PSocketClientImpl::Close() {
 
   delegate_ = NULL;
 
-  ipc_message_loop_->PostTask(
-      FROM_HERE, base::Bind(&P2PSocketClientImpl::DoClose, this));
+  ipc_task_runner_->PostTask(FROM_HERE,
+                             base::Bind(&P2PSocketClientImpl::DoClose, this));
 }
 
 void P2PSocketClientImpl::DoClose() {
-  DCHECK(ipc_message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   if (dispatcher_) {
     if (state_ == STATE_OPEN || state_ == STATE_OPENING ||
         state_ == STATE_ERROR) {
@@ -148,7 +146,7 @@ void P2PSocketClientImpl::SetDelegate(P2PSocketClientDelegate* delegate) {
 void P2PSocketClientImpl::OnSocketCreated(
     const net::IPEndPoint& local_address,
     const net::IPEndPoint& remote_address) {
-  DCHECK(ipc_message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_OPENING);
   state_ = STATE_OPEN;
 
@@ -168,7 +166,7 @@ void P2PSocketClientImpl::DeliverOnSocketCreated(
 
 void P2PSocketClientImpl::OnIncomingTcpConnection(
     const net::IPEndPoint& address) {
-  DCHECK(ipc_message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_OPEN);
 
   scoped_refptr<P2PSocketClientImpl> new_client =
@@ -200,7 +198,7 @@ void P2PSocketClientImpl::DeliverOnIncomingTcpConnection(
 
 void P2PSocketClientImpl::OnSendComplete(
     const P2PSendPacketMetrics& send_metrics) {
-  DCHECK(ipc_message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
 
   delegate_message_loop_->PostTask(
       FROM_HERE, base::Bind(&P2PSocketClientImpl::DeliverOnSendComplete, this,
@@ -215,7 +213,7 @@ void P2PSocketClientImpl::DeliverOnSendComplete(
 }
 
 void P2PSocketClientImpl::OnError() {
-  DCHECK(ipc_message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   state_ = STATE_ERROR;
 
   delegate_message_loop_->PostTask(
@@ -231,7 +229,7 @@ void P2PSocketClientImpl::DeliverOnError() {
 void P2PSocketClientImpl::OnDataReceived(const net::IPEndPoint& address,
                                          const std::vector<char>& data,
                                          const base::TimeTicks& timestamp) {
-  DCHECK(ipc_message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(STATE_OPEN, state_);
   delegate_message_loop_->PostTask(
       FROM_HERE,
@@ -251,7 +249,7 @@ void P2PSocketClientImpl::DeliverOnDataReceived(
 }
 
 void P2PSocketClientImpl::Detach() {
-  DCHECK(ipc_message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   dispatcher_ = NULL;
   OnError();
 }
diff --git a/content/renderer/p2p/socket_client_impl.h b/content/renderer/p2p/socket_client_impl.h
index 868f612..3fde54e 100644
--- a/content/renderer/p2p/socket_client_impl.h
+++ b/content/renderer/p2p/socket_client_impl.h
@@ -13,7 +13,7 @@
 #include "net/base/ip_endpoint.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 class TimeTicks;
 }  // namespace base
 
@@ -110,7 +110,7 @@ class P2PSocketClientImpl : public P2PSocketClient {
   void Detach();
 
   P2PSocketDispatcher* dispatcher_;
-  scoped_refptr<base::MessageLoopProxy> ipc_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner_;
   scoped_refptr<base::MessageLoopProxy> delegate_message_loop_;
   int socket_id_;
   P2PSocketClientDelegate* delegate_;
diff --git a/content/renderer/p2p/socket_dispatcher.cc b/content/renderer/p2p/socket_dispatcher.cc
index 06f6b1e..2e81c6d 100644
--- a/content/renderer/p2p/socket_dispatcher.cc
+++ b/content/renderer/p2p/socket_dispatcher.cc
@@ -6,7 +6,6 @@
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "content/child/child_process.h"
 #include "content/common/p2p_messages.h"
 #include "content/renderer/p2p/host_address_request.h"
@@ -18,8 +17,8 @@
 namespace content {
 
 P2PSocketDispatcher::P2PSocketDispatcher(
-    base::MessageLoopProxy* ipc_message_loop)
-    : message_loop_(ipc_message_loop),
+    base::SingleThreadTaskRunner* ipc_task_runner)
+    : ipc_task_runner_(ipc_task_runner),
       network_notifications_started_(false),
       network_list_observers_(
           new ObserverListThreadSafe<NetworkListObserver>()),
@@ -47,7 +46,7 @@ void P2PSocketDispatcher::RemoveNetworkListObserver(
 }
 
 void P2PSocketDispatcher::Send(IPC::Message* message) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   if (!sender_) {
     DLOG(WARNING) << "P2PSocketDispatcher::Send() - Sender closed.";
     delete message;
@@ -85,25 +84,24 @@ void P2PSocketDispatcher::OnChannelClosing() {
   sender_ = NULL;
 }
 
-base::MessageLoopProxy* P2PSocketDispatcher::message_loop() {
-  return message_loop_.get();
+base::SingleThreadTaskRunner* P2PSocketDispatcher::task_runner() {
+  return ipc_task_runner_.get();
 }
 
 int P2PSocketDispatcher::RegisterClient(P2PSocketClientImpl* client) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   return clients_.Add(client);
 }
 
 void P2PSocketDispatcher::UnregisterClient(int id) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   clients_.Remove(id);
 }
 
 void P2PSocketDispatcher::SendP2PMessage(IPC::Message* msg) {
-  if (!message_loop_->BelongsToCurrentThread()) {
-    message_loop_->PostTask(FROM_HERE,
-                            base::Bind(&P2PSocketDispatcher::Send,
-                                       this, msg));
+  if (!ipc_task_runner_->BelongsToCurrentThread()) {
+    ipc_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&P2PSocketDispatcher::Send, this, msg));
     return;
   }
   Send(msg);
@@ -111,12 +109,12 @@ void P2PSocketDispatcher::SendP2PMessage(IPC::Message* msg) {
 
 int P2PSocketDispatcher::RegisterHostAddressRequest(
     P2PAsyncAddressResolver* request) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   return host_address_requests_.Add(request);
 }
 
 void P2PSocketDispatcher::UnregisterHostAddressRequest(int id) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   host_address_requests_.Remove(id);
 }
 
diff --git a/content/renderer/p2p/socket_dispatcher.h b/content/renderer/p2p/socket_dispatcher.h
index 0b180ec..ac8db56 100644
--- a/content/renderer/p2p/socket_dispatcher.h
+++ b/content/renderer/p2p/socket_dispatcher.h
@@ -35,7 +35,7 @@
 #include "net/base/net_util.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace net {
@@ -52,7 +52,7 @@ class RenderViewImpl;
 class CONTENT_EXPORT P2PSocketDispatcher : public IPC::MessageFilter,
                                            public NetworkListManager {
  public:
-  explicit P2PSocketDispatcher(base::MessageLoopProxy* ipc_message_loop);
+  explicit P2PSocketDispatcher(base::SingleThreadTaskRunner* ipc_task_runner);
 
   // NetworkListManager interface:
   void AddNetworkListObserver(
@@ -76,8 +76,7 @@ class CONTENT_EXPORT P2PSocketDispatcher : public IPC::MessageFilter,
   void OnFilterRemoved() override;
   void OnChannelClosing() override;
 
-  // Returns the IO message loop.
-  base::MessageLoopProxy* message_loop();
+  base::SingleThreadTaskRunner* task_runner();
 
   // Called by P2PSocketClient.
   int RegisterClient(P2PSocketClientImpl* client);
@@ -104,7 +103,7 @@ class CONTENT_EXPORT P2PSocketDispatcher : public IPC::MessageFilter,
 
   P2PSocketClientImpl* GetClient(int socket_id);
 
-  scoped_refptr<base::MessageLoopProxy> message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner_;
   IDMap<P2PSocketClientImpl> clients_;
 
   IDMap<P2PAsyncAddressResolver> host_address_requests_;
diff --git a/content/renderer/pepper/pepper_hung_plugin_filter.cc b/content/renderer/pepper/pepper_hung_plugin_filter.cc
index 942dd6e..b43606c 100644
--- a/content/renderer/pepper/pepper_hung_plugin_filter.cc
+++ b/content/renderer/pepper/pepper_hung_plugin_filter.cc
@@ -32,10 +32,11 @@ PepperHungPluginFilter::PepperHungPluginFilter(
       frame_routing_id_(frame_routing_id),
       plugin_child_id_(plugin_child_id),
       filter_(RenderThread::Get()->GetSyncMessageFilter()),
-      io_loop_(ChildProcess::current()->io_message_loop_proxy()),
+      io_task_runner_(ChildProcess::current()->io_task_runner()),
       pending_sync_message_count_(0),
       hung_plugin_showing_(false),
-      timer_task_pending_(false) {}
+      timer_task_pending_(false) {
+}
 
 void PepperHungPluginFilter::BeginBlockOnSyncMessage() {
   base::AutoLock lock(lock_);
@@ -83,9 +84,8 @@ void PepperHungPluginFilter::EnsureTimerScheduled() {
     return;
 
   timer_task_pending_ = true;
-  io_loop_->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&PepperHungPluginFilter::OnHangTimer, this),
+  io_task_runner_->PostDelayedTask(
+      FROM_HERE, base::Bind(&PepperHungPluginFilter::OnHangTimer, this),
       base::TimeDelta::FromSeconds(kHungThresholdSec));
 }
 
@@ -140,9 +140,8 @@ void PepperHungPluginFilter::OnHangTimer() {
     // would not have scheduled one (we only have one out-standing timer at
     // a time).
     timer_task_pending_ = true;
-    io_loop_->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&PepperHungPluginFilter::OnHangTimer, this),
+    io_task_runner_->PostDelayedTask(
+        FROM_HERE, base::Bind(&PepperHungPluginFilter::OnHangTimer, this),
         delay);
     return;
   }
diff --git a/content/renderer/pepper/pepper_hung_plugin_filter.h b/content/renderer/pepper/pepper_hung_plugin_filter.h
index 286fdfa..9da4f5a 100644
--- a/content/renderer/pepper/pepper_hung_plugin_filter.h
+++ b/content/renderer/pepper/pepper_hung_plugin_filter.h
@@ -84,7 +84,7 @@ class PepperHungPluginFilter
   // We don't actually use the "sync" feature of this filter.
   scoped_refptr<IPC::SyncMessageFilter> filter_;
 
-  scoped_refptr<base::MessageLoopProxy> io_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // The time when we start being blocked on a sync message. If there are
   // nested ones, this is the time of the outermost one.
diff --git a/content/renderer/pepper/pepper_media_stream_video_track_host.cc b/content/renderer/pepper/pepper_media_stream_video_track_host.cc
index 14c6731..779ab10 100644
--- a/content/renderer/pepper/pepper_media_stream_video_track_host.cc
+++ b/content/renderer/pepper/pepper_media_stream_video_track_host.cc
@@ -182,9 +182,8 @@ namespace content {
 class PepperMediaStreamVideoTrackHost::FrameDeliverer
     : public base::RefCountedThreadSafe<FrameDeliverer> {
  public:
-  FrameDeliverer(
-      const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy,
-      const VideoCaptureDeliverFrameCB& new_frame_callback);
+  FrameDeliverer(scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+                 const VideoCaptureDeliverFrameCB& new_frame_callback);
 
   void DeliverVideoFrame(const scoped_refptr<media::VideoFrame>& frame);
 
@@ -194,17 +193,16 @@ class PepperMediaStreamVideoTrackHost::FrameDeliverer
 
   void DeliverFrameOnIO(const scoped_refptr<media::VideoFrame>& frame);
 
-  scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   VideoCaptureDeliverFrameCB new_frame_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameDeliverer);
 };
 
 PepperMediaStreamVideoTrackHost::FrameDeliverer::FrameDeliverer(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     const VideoCaptureDeliverFrameCB& new_frame_callback)
-    : io_message_loop_(io_message_loop_proxy),
-      new_frame_callback_(new_frame_callback) {
+    : io_task_runner_(io_task_runner), new_frame_callback_(new_frame_callback) {
 }
 
 PepperMediaStreamVideoTrackHost::FrameDeliverer::~FrameDeliverer() {
@@ -212,14 +210,13 @@ PepperMediaStreamVideoTrackHost::FrameDeliverer::~FrameDeliverer() {
 
 void PepperMediaStreamVideoTrackHost::FrameDeliverer::DeliverVideoFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&FrameDeliverer::DeliverFrameOnIO, this, frame));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&FrameDeliverer::DeliverFrameOnIO, this, frame));
 }
 
 void PepperMediaStreamVideoTrackHost::FrameDeliverer::DeliverFrameOnIO(
      const scoped_refptr<media::VideoFrame>& frame) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   // The time when this frame is generated is unknown so give a null value to
   // |estimated_capture_time|.
   new_frame_callback_.Run(frame, base::TimeTicks());
@@ -436,7 +433,7 @@ void PepperMediaStreamVideoTrackHost::StartSourceImpl(
     const blink::WebMediaConstraints& constraints,
     const VideoCaptureDeliverFrameCB& frame_callback) {
   output_started_ = true;
-  frame_deliverer_ = new FrameDeliverer(io_message_loop(), frame_callback);
+  frame_deliverer_ = new FrameDeliverer(io_task_runner(), frame_callback);
 }
 
 void PepperMediaStreamVideoTrackHost::StopSourceImpl() {
diff --git a/content/renderer/pepper/pepper_platform_audio_input.cc b/content/renderer/pepper/pepper_platform_audio_input.cc
index 04c14a7..28919df 100644
--- a/content/renderer/pepper/pepper_platform_audio_input.cc
+++ b/content/renderer/pepper/pepper_platform_audio_input.cc
@@ -48,7 +48,7 @@ PepperPlatformAudioInput* PepperPlatformAudioInput::Create(
 void PepperPlatformAudioInput::StartCapture() {
   DCHECK(main_message_loop_proxy_->BelongsToCurrentThread());
 
-  io_message_loop_proxy_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PepperPlatformAudioInput::StartCaptureOnIOThread, this));
 }
@@ -56,7 +56,7 @@ void PepperPlatformAudioInput::StartCapture() {
 void PepperPlatformAudioInput::StopCapture() {
   DCHECK(main_message_loop_proxy_->BelongsToCurrentThread());
 
-  io_message_loop_proxy_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PepperPlatformAudioInput::StopCaptureOnIOThread, this));
 }
@@ -71,7 +71,7 @@ void PepperPlatformAudioInput::ShutDown() {
   // Called on the main thread to stop all audio callbacks. We must only change
   // the client on the main thread, and the delegates from the I/O thread.
   client_ = NULL;
-  io_message_loop_proxy_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PepperPlatformAudioInput::ShutDownOnIOThread, this));
 }
@@ -139,11 +139,12 @@ PepperPlatformAudioInput::~PepperPlatformAudioInput() {
 PepperPlatformAudioInput::PepperPlatformAudioInput()
     : client_(NULL),
       main_message_loop_proxy_(base::MessageLoopProxy::current()),
-      io_message_loop_proxy_(ChildProcess::current()->io_message_loop_proxy()),
+      io_task_runner_(ChildProcess::current()->io_task_runner()),
       render_frame_id_(MSG_ROUTING_NONE),
       create_stream_sent_(false),
       pending_open_device_(false),
-      pending_open_device_id_(-1) {}
+      pending_open_device_id_(-1) {
+}
 
 bool PepperPlatformAudioInput::Initialize(
     int render_frame_id,
@@ -189,7 +190,7 @@ bool PepperPlatformAudioInput::Initialize(
 }
 
 void PepperPlatformAudioInput::InitializeOnIOThread(int session_id) {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (!ipc_)
     return;
@@ -200,14 +201,14 @@ void PepperPlatformAudioInput::InitializeOnIOThread(int session_id) {
 }
 
 void PepperPlatformAudioInput::StartCaptureOnIOThread() {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (ipc_)
     ipc_->RecordStream();
 }
 
 void PepperPlatformAudioInput::StopCaptureOnIOThread() {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   // TODO(yzshen): We cannot re-start capturing if the stream is closed.
   if (ipc_ && create_stream_sent_) {
@@ -217,7 +218,7 @@ void PepperPlatformAudioInput::StopCaptureOnIOThread() {
 }
 
 void PepperPlatformAudioInput::ShutDownOnIOThread() {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   StopCaptureOnIOThread();
 
@@ -244,11 +245,9 @@ void PepperPlatformAudioInput::OnDeviceOpened(int request_id,
     if (client_) {
       int session_id = device_manager->GetSessionID(
           PP_DEVICETYPE_DEV_AUDIOCAPTURE, label);
-      io_message_loop_proxy_->PostTask(
-          FROM_HERE,
-          base::Bind(&PepperPlatformAudioInput::InitializeOnIOThread,
-                     this,
-                     session_id));
+      io_task_runner_->PostTask(
+          FROM_HERE, base::Bind(&PepperPlatformAudioInput::InitializeOnIOThread,
+                                this, session_id));
     } else {
       // Shutdown has occurred.
       CloseDevice();
diff --git a/content/renderer/pepper/pepper_platform_audio_input.h b/content/renderer/pepper/pepper_platform_audio_input.h
index a567ed4..ae5a610 100644
--- a/content/renderer/pepper/pepper_platform_audio_input.h
+++ b/content/renderer/pepper/pepper_platform_audio_input.h
@@ -18,6 +18,7 @@
 class GURL;
 
 namespace base {
+class SingleThreadTaskRunner;
 class MessageLoopProxy;
 }
 
@@ -104,7 +105,7 @@ class PepperPlatformAudioInput
   scoped_ptr<media::AudioInputIPC> ipc_;
 
   scoped_refptr<base::MessageLoopProxy> main_message_loop_proxy_;
-  scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // The frame containing the Pepper widget.
   int render_frame_id_;
diff --git a/content/renderer/pepper/pepper_platform_audio_output.cc b/content/renderer/pepper/pepper_platform_audio_output.cc
index ce18f86..e0a990a 100644
--- a/content/renderer/pepper/pepper_platform_audio_output.cc
+++ b/content/renderer/pepper/pepper_platform_audio_output.cc
@@ -40,7 +40,7 @@ PepperPlatformAudioOutput* PepperPlatformAudioOutput::Create(
 
 bool PepperPlatformAudioOutput::StartPlayback() {
   if (ipc_) {
-    io_message_loop_proxy_->PostTask(
+    io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&PepperPlatformAudioOutput::StartPlaybackOnIOThread, this));
     return true;
@@ -50,7 +50,7 @@ bool PepperPlatformAudioOutput::StartPlayback() {
 
 bool PepperPlatformAudioOutput::StopPlayback() {
   if (ipc_) {
-    io_message_loop_proxy_->PostTask(
+    io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&PepperPlatformAudioOutput::StopPlaybackOnIOThread, this));
     return true;
@@ -62,7 +62,7 @@ void PepperPlatformAudioOutput::ShutDown() {
   // Called on the main thread to stop all audio callbacks. We must only change
   // the client on the main thread, and the delegates from the I/O thread.
   client_ = NULL;
-  io_message_loop_proxy_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PepperPlatformAudioOutput::ShutDownOnIOThread, this));
 }
@@ -112,7 +112,7 @@ PepperPlatformAudioOutput::~PepperPlatformAudioOutput() {
 PepperPlatformAudioOutput::PepperPlatformAudioOutput()
     : client_(NULL),
       main_message_loop_proxy_(base::MessageLoopProxy::current()),
-      io_message_loop_proxy_(ChildProcess::current()->io_message_loop_proxy()) {
+      io_task_runner_(ChildProcess::current()->io_task_runner()) {
 }
 
 bool PepperPlatformAudioOutput::Initialize(int sample_rate,
@@ -133,35 +133,34 @@ bool PepperPlatformAudioOutput::Initialize(int sample_rate,
                                 ppapi::kBitsPerAudioOutputSample,
                                 frames_per_buffer);
 
-  io_message_loop_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(
-          &PepperPlatformAudioOutput::InitializeOnIOThread, this, params));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&PepperPlatformAudioOutput::InitializeOnIOThread,
+                            this, params));
   return true;
 }
 
 void PepperPlatformAudioOutput::InitializeOnIOThread(
     const media::AudioParameters& params) {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   const int kSessionId = 0;
   if (ipc_)
     ipc_->CreateStream(this, params, kSessionId);
 }
 
 void PepperPlatformAudioOutput::StartPlaybackOnIOThread() {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (ipc_)
     ipc_->PlayStream();
 }
 
 void PepperPlatformAudioOutput::StopPlaybackOnIOThread() {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (ipc_)
     ipc_->PauseStream();
 }
 
 void PepperPlatformAudioOutput::ShutDownOnIOThread() {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   // Make sure we don't call shutdown more than once.
   if (!ipc_)
diff --git a/content/renderer/pepper/pepper_platform_audio_output.h b/content/renderer/pepper/pepper_platform_audio_output.h
index c0f455b..91b922b 100644
--- a/content/renderer/pepper/pepper_platform_audio_output.h
+++ b/content/renderer/pepper/pepper_platform_audio_output.h
@@ -16,6 +16,7 @@ class AudioParameters;
 
 namespace base {
 class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace content {
@@ -81,7 +82,7 @@ class PepperPlatformAudioOutput
   scoped_ptr<media::AudioOutputIPC> ipc_;
 
   scoped_refptr<base::MessageLoopProxy> main_message_loop_proxy_;
-  scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(PepperPlatformAudioOutput);
 };
diff --git a/content/renderer/pepper/pepper_proxy_channel_delegate_impl.cc b/content/renderer/pepper/pepper_proxy_channel_delegate_impl.cc
index f48e732..3cada30 100644
--- a/content/renderer/pepper/pepper_proxy_channel_delegate_impl.cc
+++ b/content/renderer/pepper/pepper_proxy_channel_delegate_impl.cc
@@ -11,10 +11,11 @@ namespace content {
 
 PepperProxyChannelDelegateImpl::~PepperProxyChannelDelegateImpl() {}
 
-base::MessageLoopProxy* PepperProxyChannelDelegateImpl::GetIPCMessageLoop() {
+base::SingleThreadTaskRunner*
+PepperProxyChannelDelegateImpl::GetIPCTaskRunner() {
   // This is called only in the renderer so we know we have a child process.
   DCHECK(ChildProcess::current()) << "Must be in the renderer.";
-  return ChildProcess::current()->io_message_loop_proxy();
+  return ChildProcess::current()->io_task_runner();
 }
 
 base::WaitableEvent* PepperProxyChannelDelegateImpl::GetShutdownEvent() {
diff --git a/content/renderer/pepper/pepper_proxy_channel_delegate_impl.h b/content/renderer/pepper/pepper_proxy_channel_delegate_impl.h
index e6b9cd5..b017be1 100644
--- a/content/renderer/pepper/pepper_proxy_channel_delegate_impl.h
+++ b/content/renderer/pepper/pepper_proxy_channel_delegate_impl.h
@@ -16,7 +16,7 @@ class PepperProxyChannelDelegateImpl
   ~PepperProxyChannelDelegateImpl() override;
 
   // ProxyChannel::Delegate implementation.
-  base::MessageLoopProxy* GetIPCMessageLoop() override;
+  base::SingleThreadTaskRunner* GetIPCTaskRunner() override;
   base::WaitableEvent* GetShutdownEvent() override;
   IPC::PlatformFileForTransit ShareHandleWithRemote(
       base::PlatformFile handle,
diff --git a/content/renderer/render_thread_impl.cc b/content/renderer/render_thread_impl.cc
index 65cc397..f4407f0 100644
--- a/content/renderer/render_thread_impl.cc
+++ b/content/renderer/render_thread_impl.cc
@@ -901,9 +901,9 @@ IPC::SyncMessageFilter* RenderThreadImpl::GetSyncMessageFilter() {
   return sync_message_filter();
 }
 
-scoped_refptr<base::MessageLoopProxy>
-    RenderThreadImpl::GetIOMessageLoopProxy() {
-  return ChildProcess::current()->io_message_loop_proxy();
+scoped_refptr<base::SingleThreadTaskRunner>
+RenderThreadImpl::GetIOMessageLoopProxy() {
+  return ChildProcess::current()->io_task_runner();
 }
 
 void RenderThreadImpl::AddRoute(int32 routing_id, IPC::Listener* listener) {
@@ -1623,7 +1623,7 @@ GpuChannelHost* RenderThreadImpl::EstablishGpuChannelSync(
 
   // Cache some variables that are needed on the compositor thread for our
   // implementation of GpuChannelHostFactory.
-  io_thread_task_runner_ = ChildProcess::current()->io_message_loop_proxy();
+  io_thread_task_runner_ = ChildProcess::current()->io_task_runner();
 
   gpu_channel_ =
       GpuChannelHost::Create(this,
diff --git a/content/renderer/render_thread_impl.h b/content/renderer/render_thread_impl.h
index 20d7084..7231634 100644
--- a/content/renderer/render_thread_impl.h
+++ b/content/renderer/render_thread_impl.h
@@ -155,7 +155,7 @@ class CONTENT_EXPORT RenderThreadImpl
   IPC::SyncChannel* GetChannel() override;
   std::string GetLocale() override;
   IPC::SyncMessageFilter* GetSyncMessageFilter() override;
-  scoped_refptr<base::MessageLoopProxy> GetIOMessageLoopProxy() override;
+  scoped_refptr<base::SingleThreadTaskRunner> GetIOMessageLoopProxy() override;
   void AddRoute(int32 routing_id, IPC::Listener* listener) override;
   void RemoveRoute(int32 routing_id) override;
   int GenerateRoutingID() override;
diff --git a/ppapi/nacl_irt/ppapi_dispatcher.cc b/ppapi/nacl_irt/ppapi_dispatcher.cc
index 343c71c..e6d0283 100644
--- a/ppapi/nacl_irt/ppapi_dispatcher.cc
+++ b/ppapi/nacl_irt/ppapi_dispatcher.cc
@@ -65,7 +65,7 @@ PpapiDispatcher::PpapiDispatcher(scoped_refptr<base::MessageLoopProxy> io_loop,
   // ensures that the filters won't miss any messages received by
   // the channel.
   channel_ =
-      IPC::SyncChannel::Create(this, GetIPCMessageLoop(), GetShutdownEvent());
+      IPC::SyncChannel::Create(this, GetIPCTaskRunner(), GetShutdownEvent());
   scoped_refptr<ppapi::proxy::PluginMessageFilter> plugin_filter(
       new ppapi::proxy::PluginMessageFilter(
           NULL, globals->resource_reply_thread_registrar()));
@@ -77,7 +77,7 @@ PpapiDispatcher::PpapiDispatcher(scoped_refptr<base::MessageLoopProxy> io_loop,
   channel_->Init(channel_handle, IPC::Channel::MODE_SERVER, true);
 }
 
-base::MessageLoopProxy* PpapiDispatcher::GetIPCMessageLoop() {
+base::SingleThreadTaskRunner* PpapiDispatcher::GetIPCTaskRunner() {
   return message_loop_.get();
 }
 
diff --git a/ppapi/nacl_irt/ppapi_dispatcher.h b/ppapi/nacl_irt/ppapi_dispatcher.h
index c03b8b0..e84d6ccf 100644
--- a/ppapi/nacl_irt/ppapi_dispatcher.h
+++ b/ppapi/nacl_irt/ppapi_dispatcher.h
@@ -52,7 +52,7 @@ class PpapiDispatcher : public proxy::PluginDispatcher::PluginDelegate,
                   int renderer_ipc_fd);
 
   // PluginDispatcher::PluginDelegate implementation.
-  base::MessageLoopProxy* GetIPCMessageLoop() override;
+  base::SingleThreadTaskRunner* GetIPCTaskRunner() override;
   base::WaitableEvent* GetShutdownEvent() override;
   IPC::PlatformFileForTransit ShareHandleWithRemote(
       base::PlatformFile handle,
diff --git a/ppapi/proxy/ppapi_proxy_test.cc b/ppapi/proxy/ppapi_proxy_test.cc
index fdd1604..949dac3 100644
--- a/ppapi/proxy/ppapi_proxy_test.cc
+++ b/ppapi/proxy/ppapi_proxy_test.cc
@@ -235,8 +235,8 @@ void PluginProxyTestHarness::CreatePluginGlobals(
   }
 }
 
-base::MessageLoopProxy*
-PluginProxyTestHarness::PluginDelegateMock::GetIPCMessageLoop() {
+base::SingleThreadTaskRunner*
+PluginProxyTestHarness::PluginDelegateMock::GetIPCTaskRunner() {
   return ipc_message_loop_;
 }
 
@@ -470,8 +470,7 @@ void HostProxyTestHarness::CreateHostGlobals() {
   }
 }
 
-base::MessageLoopProxy*
-HostProxyTestHarness::DelegateMock::GetIPCMessageLoop() {
+base::MessageLoopProxy* HostProxyTestHarness::DelegateMock::GetIPCTaskRunner() {
   return ipc_message_loop_;
 }
 
diff --git a/ppapi/proxy/ppapi_proxy_test.h b/ppapi/proxy/ppapi_proxy_test.h
index ab6c8b2..68eaa8d 100644
--- a/ppapi/proxy/ppapi_proxy_test.h
+++ b/ppapi/proxy/ppapi_proxy_test.h
@@ -133,7 +133,7 @@ class PluginProxyTestHarness : public ProxyTestHarnessBase {
     }
 
     // ProxyChannel::Delegate implementation.
-    base::MessageLoopProxy* GetIPCMessageLoop() override;
+    base::SingleThreadTaskRunner* GetIPCTaskRunner() override;
     base::WaitableEvent* GetShutdownEvent() override;
     IPC::PlatformFileForTransit ShareHandleWithRemote(
         base::PlatformFile handle,
@@ -273,7 +273,7 @@ class HostProxyTestHarness : public ProxyTestHarnessBase {
     }
 
     // ProxyChannel::Delegate implementation.
-    base::MessageLoopProxy* GetIPCMessageLoop() override;
+    base::MessageLoopProxy* GetIPCTaskRunner() override;
     base::WaitableEvent* GetShutdownEvent() override;
     IPC::PlatformFileForTransit ShareHandleWithRemote(
         base::PlatformFile handle,
diff --git a/ppapi/proxy/proxy_channel.cc b/ppapi/proxy/proxy_channel.cc
index 45c2a77..6753fbf 100644
--- a/ppapi/proxy/proxy_channel.cc
+++ b/ppapi/proxy/proxy_channel.cc
@@ -35,7 +35,7 @@ bool ProxyChannel::InitWithChannel(Delegate* delegate,
       ? IPC::Channel::MODE_CLIENT
       : IPC::Channel::MODE_SERVER;
   channel_ = IPC::SyncChannel::Create(channel_handle, mode, this,
-                                      delegate->GetIPCMessageLoop(), true,
+                                      delegate->GetIPCTaskRunner(), true,
                                       delegate->GetShutdownEvent());
   return true;
 }
diff --git a/ppapi/proxy/proxy_channel.h b/ppapi/proxy/proxy_channel.h
index ffa906e..1de6511 100644
--- a/ppapi/proxy/proxy_channel.h
+++ b/ppapi/proxy/proxy_channel.h
@@ -15,7 +15,7 @@
 #include "ppapi/proxy/ppapi_proxy_export.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 class WaitableEvent;
 }
 
@@ -34,8 +34,8 @@ class PPAPI_PROXY_EXPORT ProxyChannel
    public:
     virtual ~Delegate() {}
 
-    // Returns the dedicated message loop for processing IPC requests.
-    virtual base::MessageLoopProxy* GetIPCMessageLoop() = 0;
+    // Returns the task runner for processing IPC requests.
+    virtual base::SingleThreadTaskRunner* GetIPCTaskRunner() = 0;
 
     // Returns the event object that becomes signalled when the main thread's
     // message loop exits.