Remove all remaining traces of MessageLoopProxy.

content/public/browser/browser_thread.h

 // 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.
 
 #ifndef CONTENT_PUBLIC_BROWSER_BROWSER_THREAD_H_
 #define CONTENT_PUBLIC_BROWSER_BROWSER_THREAD_H_
 
 #include <string>
 
 #include "base/callback.h"
@@ skipping 113 matching lines @@
       const base::Closure& task,
       const base::Closure& reply);
 
   template <typename ReturnType, typename ReplyArgType>
   static bool PostTaskAndReplyWithResult(
       ID identifier,
       const tracked_objects::Location& from_here,
       const base::Callback<ReturnType(void)>& task,
       const base::Callback<void(ReplyArgType)>& reply) {
     scoped_refptr<base::SingleThreadTaskRunner> task_runner =
-        GetMessageLoopProxyForThread(identifier);
+        GetTaskRunnerForThread(identifier);
     return base::PostTaskAndReplyWithResult(task_runner.get(), from_here, task,
                                             reply);
   }
 
   template <class T>
   static bool DeleteSoon(ID identifier,
                          const tracked_objects::Location& from_here,
                          const T* object) {
-    return GetMessageLoopProxyForThread(identifier)->DeleteSoon(
-        from_here, object);
+    return GetTaskRunnerForThread(identifier)->DeleteSoon(from_here, object);
   }
 
   template <class T>
   static bool ReleaseSoon(ID identifier,
                           const tracked_objects::Location& from_here,
                           const T* object) {
-    return GetMessageLoopProxyForThread(identifier)->ReleaseSoon(
-        from_here, object);
+    return GetTaskRunnerForThread(identifier)->ReleaseSoon(from_here, object);
   }
 
   // Simplified wrappers for posting to the blocking thread pool. Use this
   // for doing things like blocking I/O.
   //
   // The first variant will run the task in the pool with no sequencing
   // semantics, so may get run in parallel with other posted tasks. The second
   // variant will all post a task with no sequencing semantics, and will post a
   // reply task to the origin TaskRunner upon completion.  The third variant
   // provides sequencing between tasks with the same sequence token name.
@@ skipping 48 matching lines @@
   // If this returns false it means the thread is in the process of shutting
   // down.
   static bool IsMessageLoopValid(ID identifier) WARN_UNUSED_RESULT;
 
   // If the current message loop is one of the known threads, returns true and
   // sets identifier to its ID.  Otherwise returns false.
   static bool GetCurrentThreadIdentifier(ID* identifier) WARN_UNUSED_RESULT;
 
   // Callers can hold on to a refcounted task runner beyond the lifetime
   // of the thread.
-  static scoped_refptr<base::SingleThreadTaskRunner>
-  GetMessageLoopProxyForThread(ID identifier);
+  static scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunnerForThread(
+      ID identifier);
 
   // Returns a pointer to the thread's message loop, which will become
   // invalid during shutdown, so you probably shouldn't hold onto it.
   //
   // This must not be called before the thread is started, or after
   // the thread is stopped, or it will DCHECK.
   //
   // Ownership remains with the BrowserThread implementation, so you
   // must not delete the pointer.
   static base::MessageLoop* UnsafeGetMessageLoopForThread(ID identifier);
@@ skipping 64 matching lines @@
  private:
   friend class BrowserThreadImpl;
 
   BrowserThread() {}
   DISALLOW_COPY_AND_ASSIGN(BrowserThread);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_BROWSER_THREAD_H_