Remove all remaining traces of MessageLoopProxy.

content/browser/browser_thread_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/browser_thread_impl.h"
 
 #include <string.h>
 
 #include <string>
 
@@ skipping 475 matching lines @@
   return BrowserThreadImpl::PostTaskHelper(
       identifier, from_here, task, delay, false);
 }
 
 // static
 bool BrowserThread::PostTaskAndReply(
     ID identifier,
     const tracked_objects::Location& from_here,
     const base::Closure& task,
     const base::Closure& reply) {
-  return GetMessageLoopProxyForThread(identifier)->PostTaskAndReply(from_here,
-                                                                    task,
-                                                                    reply);
+  return GetTaskRunnerForThread(identifier)
+      ->PostTaskAndReply(from_here, task, reply);
 }
 
 // static
 bool BrowserThread::GetCurrentThreadIdentifier(ID* identifier) {
   if (g_globals == NULL)
     return false;
 
   base::MessageLoop* cur_message_loop = base::MessageLoop::current();
   BrowserThreadGlobals& globals = g_globals.Get();
   // Profiler to track potential contention on |globals.lock|. This only does
   // real work on canary and local dev builds, so the cost of having this here
   // should be minimal.
   tracked_objects::ScopedTracker tracking_profile(FROM_HERE);
   base::AutoLock lock(globals.lock);
   for (int i = 0; i < ID_COUNT; ++i) {
     if (globals.threads[i] &&
         globals.threads[i]->message_loop() == cur_message_loop) {
       *identifier = globals.threads[i]->identifier_;
       return true;
     }
   }
 
   return false;
 }
 
 // static
 scoped_refptr<base::SingleThreadTaskRunner>
-BrowserThread::GetMessageLoopProxyForThread(ID identifier) {
+BrowserThread::GetTaskRunnerForThread(ID identifier) {
   return g_task_runners.Get().proxies[identifier];
 }
 
 // static
 base::MessageLoop* BrowserThread::UnsafeGetMessageLoopForThread(ID identifier) {
   if (g_globals == NULL)
     return NULL;
 
   BrowserThreadGlobals& globals = g_globals.Get();
   base::AutoLock lock(globals.lock);
@@ skipping 11 matching lines @@
   AtomicWord* storage = reinterpret_cast<AtomicWord*>(
       &globals.thread_delegates[identifier]);
   AtomicWord old_pointer = base::subtle::NoBarrier_AtomicExchange(
       storage, reinterpret_cast<AtomicWord>(delegate));
 
   // This catches registration when previously registered.
   DCHECK(!delegate || !old_pointer);
 }
 
 }  // namespace content