Revert "content: Remove use of MessageLoopProxy and deprecated MessageLoop APIs"

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>
 
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
-#include "base/single_thread_task_runner.h"
+#include "base/message_loop/message_loop.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/public/browser/browser_thread_delegate.h"
 #include "content/public/browser/content_browser_client.h"
 #include "net/disk_cache/simple/simple_backend_impl.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/jni_android.h"
 #endif
 
 namespace content {
 
 namespace {
 
 // Friendly names for the well-known threads.
 static const char* g_browser_thread_names[BrowserThread::ID_COUNT] = {
   "",  // UI (name assembled in browser_main.cc).
   "Chrome_DBThread",  // DB
   "Chrome_FileThread",  // FILE
   "Chrome_FileUserBlockingThread",  // FILE_USER_BLOCKING
   "Chrome_ProcessLauncherThread",  // PROCESS_LAUNCHER
   "Chrome_CacheThread",  // CACHE
   "Chrome_IOThread",  // IO
 };
 
-// An implementation of SingleThreadTaskRunner to be used in conjunction
+// An implementation of MessageLoopProxy to be used in conjunction
 // with BrowserThread.
-class BrowserThreadTaskRunner : public base::SingleThreadTaskRunner {
+class BrowserThreadMessageLoopProxy : public base::MessageLoopProxy {
  public:
-  explicit BrowserThreadTaskRunner(BrowserThread::ID identifier)
-      : id_(identifier) {}
+  explicit BrowserThreadMessageLoopProxy(BrowserThread::ID identifier)
+      : id_(identifier) {
+  }
 
-  // SingleThreadTaskRunner implementation.
+  // MessageLoopProxy implementation.
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const base::Closure& task,
                        base::TimeDelta delay) override {
     return BrowserThread::PostDelayedTask(id_, from_here, task, delay);
   }
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   const base::Closure& task,
                                   base::TimeDelta delay) override {
     return BrowserThread::PostNonNestableDelayedTask(id_, from_here, task,
                                                      delay);
   }
 
   bool RunsTasksOnCurrentThread() const override {
     return BrowserThread::CurrentlyOn(id_);
   }
 
  protected:
-  ~BrowserThreadTaskRunner() override {}
+  ~BrowserThreadMessageLoopProxy() override {}
 
  private:
   BrowserThread::ID id_;
-  DISALLOW_COPY_AND_ASSIGN(BrowserThreadTaskRunner);
+  DISALLOW_COPY_AND_ASSIGN(BrowserThreadMessageLoopProxy);
 };
 
-// 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 BrowserThreadTaskRunners {
-  BrowserThreadTaskRunners() {
+// A separate helper is used just for the proxies, in order to avoid needing
+// to initialize the globals to create a proxy.
+struct BrowserThreadProxies {
+  BrowserThreadProxies() {
     for (int i = 0; i < BrowserThread::ID_COUNT; ++i) {
       proxies[i] =
-          new BrowserThreadTaskRunner(static_cast<BrowserThread::ID>(i));
+          new BrowserThreadMessageLoopProxy(static_cast<BrowserThread::ID>(i));
     }
   }
 
-  scoped_refptr<base::SingleThreadTaskRunner> proxies[BrowserThread::ID_COUNT];
+  scoped_refptr<base::MessageLoopProxy> proxies[BrowserThread::ID_COUNT];
 };
 
-base::LazyInstance<BrowserThreadTaskRunners>::Leaky g_task_runners =
-    LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<BrowserThreadProxies>::Leaky
+    g_proxies = LAZY_INSTANCE_INITIALIZER;
 
 struct BrowserThreadGlobals {
   BrowserThreadGlobals()
       : blocking_pool(new base::SequencedWorkerPool(3, "BrowserBlocking")) {
     memset(threads, 0, BrowserThread::ID_COUNT * sizeof(threads[0]));
     memset(thread_delegates, 0,
            BrowserThread::ID_COUNT * sizeof(thread_delegates[0]));
   }
 
   // This lock protects |threads|. Do not read or modify that array
@@ skipping 225 matching lines @@
 
   BrowserThreadGlobals& globals = g_globals.Get();
   if (!target_thread_outlives_current)
     globals.lock.Acquire();
 
   base::MessageLoop* message_loop =
       globals.threads[identifier] ? globals.threads[identifier]->message_loop()
                                   : NULL;
   if (message_loop) {
     if (nestable) {
-      message_loop->task_runner()->PostDelayedTask(from_here, task, delay);
+      message_loop->PostDelayedTask(from_here, task, delay);
     } else {
-      message_loop->task_runner()->PostNonNestableDelayedTask(from_here, task,
-                                                              delay);
+      message_loop->PostNonNestableDelayedTask(from_here, task, delay);
     }
   }
 
   if (!target_thread_outlives_current)
     globals.lock.Release();
 
   return !!message_loop;
 }
 
 // static
@@ skipping 163 matching lines @@
         globals.threads[i]->message_loop() == cur_message_loop) {
       *identifier = globals.threads[i]->identifier_;
       return true;
     }
   }
 
   return false;
 }
 
 // static
-scoped_refptr<base::SingleThreadTaskRunner>
+scoped_refptr<base::MessageLoopProxy>
 BrowserThread::GetMessageLoopProxyForThread(ID identifier) {
-  return g_task_runners.Get().proxies[identifier];
+  return g_proxies.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);
   base::Thread* thread = globals.threads[identifier];
@@ skipping 10 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