ios: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

ios/web/web_thread_impl.cc

 // 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.
 
 #include "ios/web/web_thread_impl.h"
 
 #include <string>
 
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "ios/web/public/web_thread_delegate.h"
 #include "net/disk_cache/simple/simple_backend_impl.h"
 #include "net/url_request/url_fetcher.h"
 
 namespace web {
 
 namespace {
 
 // Friendly names for the well-known threads.
 const char* g_web_thread_names[WebThread::ID_COUNT] = {
     "Web_UIThread",                // UI
     "Web_DBThread",                // DB
     "Web_FileThread",              // FILE
     "Web_FileUserBlockingThread",  // FILE_USER_BLOCKING
     "Web_CacheThread",             // CACHE
     "Web_IOThread",                // IO
 };
 
-// An implementation of MessageLoopProxy to be used in conjunction
+// An implementation of SingleThreadTaskRunner to be used in conjunction
 // with WebThread.
-class WebThreadMessageLoopProxy : public base::MessageLoopProxy {
+class WebThreadTaskRunner : public base::SingleThreadTaskRunner {
  public:
-  explicit WebThreadMessageLoopProxy(WebThread::ID identifier)
-      : id_(identifier) {}
+  explicit WebThreadTaskRunner(WebThread::ID identifier) : id_(identifier) {}
 
-  // MessageLoopProxy implementation.
+  // SingleThreadTaskRunner implementation.
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const base::Closure& task,
                        base::TimeDelta delay) override {
     return WebThread::PostDelayedTask(id_, from_here, task, delay);
   }
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   const base::Closure& task,
                                   base::TimeDelta delay) override {
     return WebThread::PostNonNestableDelayedTask(id_, from_here, task, delay);
   }
 
   bool RunsTasksOnCurrentThread() const override {
     return WebThread::CurrentlyOn(id_);
   }
 
  protected:
-  ~WebThreadMessageLoopProxy() override {}
+  ~WebThreadTaskRunner() override {}
 
  private:
   WebThread::ID id_;
-  DISALLOW_COPY_AND_ASSIGN(WebThreadMessageLoopProxy);
+  DISALLOW_COPY_AND_ASSIGN(WebThreadTaskRunner);
 };
 
-// A separate helper is used just for the proxies, in order to avoid needing
-// to initialize the globals to create a proxy.
-struct WebThreadProxies {
-  WebThreadProxies() {
+// A separate helper is used just for the task runners, in order to avoid
+// needing to initialize the globals to create a task runner.
+struct WebThreadTaskRunners {
+  WebThreadTaskRunners() {
     for (int i = 0; i < WebThread::ID_COUNT; ++i) {
-      proxies[i] = new WebThreadMessageLoopProxy(static_cast<WebThread::ID>(i));
+      task_runners[i] = new WebThreadTaskRunner(static_cast<WebThread::ID>(i));
     }
   }
 
-  scoped_refptr<base::MessageLoopProxy> proxies[WebThread::ID_COUNT];
+  scoped_refptr<base::SingleThreadTaskRunner> task_runners[WebThread::ID_COUNT];
 };
 
-base::LazyInstance<WebThreadProxies>::Leaky g_proxies =
+base::LazyInstance<WebThreadTaskRunners>::Leaky g_task_runners =
     LAZY_INSTANCE_INITIALIZER;
 
 struct WebThreadGlobals {
   WebThreadGlobals()
       : blocking_pool(new base::SequencedWorkerPool(3, "WebBlocking")) {
     memset(threads, 0, WebThread::ID_COUNT * sizeof(threads[0]));
     memset(thread_delegates, 0,
            WebThread::ID_COUNT * sizeof(thread_delegates[0]));
   }
 
@@ skipping 354 matching lines @@
     base::TimeDelta delay) {
   return WebThreadImpl::PostTaskHelper(identifier, from_here, task, delay,
                                        false);
 }
 
 // static
 bool WebThread::PostTaskAndReply(ID identifier,
                                  const tracked_objects::Location& from_here,
                                  const base::Closure& task,
                                  const base::Closure& reply) {
-  return GetMessageLoopProxyForThread(identifier)
+  return GetTaskRunnerForThread(identifier)
       ->PostTaskAndReply(from_here, task, reply);
 }
 
 // static
 bool WebThread::GetCurrentThreadIdentifier(ID* identifier) {
   if (g_globals == nullptr)
     return false;
 
   // This shouldn't use MessageLoop::current() since it uses LazyInstance which
   // may be deleted by ~AtExitManager when a WorkerPool thread calls this
   // function.
   // http://crbug.com/63678
   base::ThreadRestrictions::ScopedAllowSingleton allow_singleton;
   base::MessageLoop* cur_message_loop = base::MessageLoop::current();
   WebThreadGlobals& globals = g_globals.Get();
   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::MessageLoopProxy> WebThread::GetMessageLoopProxyForThread(
+scoped_refptr<base::SingleThreadTaskRunner> WebThread::GetTaskRunnerForThread(
     ID identifier) {
-  return g_proxies.Get().proxies[identifier];
+  return g_task_runners.Get().task_runners[identifier];
 }
 
 // static
 base::MessageLoop* WebThread::UnsafeGetMessageLoopForThread(ID identifier) {
   if (g_globals == nullptr)
     return nullptr;
 
   WebThreadGlobals& globals = g_globals.Get();
   base::AutoLock lock(globals.lock);
   base::Thread* thread = globals.threads[identifier];
   DCHECK(thread);
   base::MessageLoop* loop = thread->message_loop();
   return loop;
 }
 
 // static
 void WebThreadImpl::SetDelegate(ID identifier, WebThreadDelegate* delegate) {
   using base::subtle::AtomicWord;
   WebThreadGlobals& globals = g_globals.Get();
   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 web