ios: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

ios/web/public/web_thread.h

 // Copyright 2014 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 IOS_WEB_PUBLIC_WEB_THREAD_H_
 #define IOS_WEB_PUBLIC_WEB_THREAD_H_
 
 #include <string>
 
 #include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/task_runner_util.h"
 
 namespace base {
 class MessageLoop;
 class SequencedWorkerPool;
 }
 
 namespace tracked_objects {
 class Location;
 }
@@ skipping 52 matching lines @@
     // This is the thread to handle slow HTTP cache operations.
     CACHE,
 
     // This is the thread that processes non-blocking IO, i.e. IPC and network.
     // Blocking IO should happen on other threads like DB, FILE,
     // FILE_USER_BLOCKING and CACHE depending on the usage.
     IO,
 
     // NOTE: do not add new threads here that are only used by a small number of
     // files. Instead you should just use a Thread class and pass its
-    // MessageLoopProxy around. Named threads there are only for threads that
-    // are used in many places.
+    // SingleThreadTaskRunner around. Named threads there are only for threads
+    // that are used in many places.
 
     // This identifier does not represent a thread.  Instead it counts the
     // number of well-known threads.  Insert new well-known threads before this
     // identifier.
     ID_COUNT
   };
 
   // These are the same methods as in message_loop.h, but are guaranteed to
   // either get posted to the MessageLoop if it's still alive, or be deleted
   // otherwise.
@@ skipping 18 matching lines @@
                                const tracked_objects::Location& from_here,
                                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::MessageLoopProxy> message_loop_proxy =
-        GetMessageLoopProxyForThread(identifier);
-    return base::PostTaskAndReplyWithResult(message_loop_proxy.get(), from_here,
-                                            task, reply);
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner =
+        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);
   }
 
   // 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 46 matching lines @@
 
   // Callable on any thread.  Returns whether the threads message loop is valid.
   // 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.
   static bool GetCurrentThreadIdentifier(ID* identifier) WARN_UNUSED_RESULT;
 
-  // Callers can hold on to a refcounted MessageLoopProxy beyond the lifetime
-  // of the thread.
-  static scoped_refptr<base::MessageLoopProxy> GetMessageLoopProxyForThread(
+  // Callers can hold on to a refcounted SingleThreadTaskRunner beyond the
+  // lifetime of the thread.
+  static scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunnerForThread(
       ID identifier);
 
   // Returns an appropriate error message for when
   // DCHECK_CURRENTLY_ON_WEB_THREAD() fails.
   static std::string GetDCheckCurrentlyOnErrorMessage(ID expected);
 
  private:
   friend class WebThreadImpl;
 
   WebThread() {}
   DISALLOW_COPY_AND_ASSIGN(WebThread);
 };
 
 }  // namespace web
 
 #endif  // IOS_WEB_PUBLIC_WEB_THREAD_H_