base: Remove more use of MessageLoopProxy

Replace usage of MessageLoopProxy under base/prefs and
base/threading/sequenced_worker_pool with SingleThreadTaskRunner and
ThreadTaskRunnerHandle.

BUG=465354

Review URL: https://codereview.chromium.org/1115223003

Cr-Commit-Position: refs/heads/master@{#328326}

4 files changed, 28 insertions, 36 deletions

diff --git a/base/prefs/pref_member.cc b/base/prefs/pref_member.cc
index 8d80dd0..64c3d6a 100644
--- a/base/prefs/pref_member.cc
+++ b/base/prefs/pref_member.cc
@@ -7,11 +7,10 @@
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/prefs/pref_service.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/value_conversions.h"
 
-using base::MessageLoopProxy;
 using base::SingleThreadTaskRunner;
 
 namespace subtle {
@@ -52,12 +51,12 @@ void PrefMemberBase::Destroy() {
 }
 
 void PrefMemberBase::MoveToThread(
-    const scoped_refptr<SingleThreadTaskRunner>& task_runner) {
+    scoped_refptr<SingleThreadTaskRunner> task_runner) {
   VerifyValuePrefName();
   // Load the value from preferences if it hasn't been loaded so far.
   if (!internal())
     UpdateValueFromPref(base::Closure());
-  internal()->MoveToThread(task_runner);
+  internal()->MoveToThread(task_runner.Pass());
 }
 
 void PrefMemberBase::OnPreferenceChanged(PrefService* service,
@@ -91,15 +90,14 @@ void PrefMemberBase::InvokeUnnamedCallback(const base::Closure& callback,
 }
 
 PrefMemberBase::Internal::Internal()
-    : thread_loop_(MessageLoopProxy::current()),
+    : thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       is_managed_(false),
       is_user_modifiable_(false) {
 }
 PrefMemberBase::Internal::~Internal() { }
 
 bool PrefMemberBase::Internal::IsOnCorrectThread() const {
-  // In unit tests, there may not be a message loop.
-  return thread_loop_.get() == NULL || thread_loop_->BelongsToCurrentThread();
+  return thread_task_runner_->BelongsToCurrentThread();
 }
 
 void PrefMemberBase::Internal::UpdateValue(
@@ -115,19 +113,18 @@ void PrefMemberBase::Internal::UpdateValue(
     is_managed_ = is_managed;
     is_user_modifiable_ = is_user_modifiable;
   } else {
-    bool may_run = thread_loop_->PostTask(
-        FROM_HERE,
-        base::Bind(&PrefMemberBase::Internal::UpdateValue, this,
-                   value.release(), is_managed, is_user_modifiable,
-                   closure_runner.Release()));
+    bool may_run = thread_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&PrefMemberBase::Internal::UpdateValue, this,
+                              value.release(), is_managed, is_user_modifiable,
+                              closure_runner.Release()));
     DCHECK(may_run);
   }
 }
 
 void PrefMemberBase::Internal::MoveToThread(
-    const scoped_refptr<SingleThreadTaskRunner>& task_runner) {
+    scoped_refptr<SingleThreadTaskRunner> task_runner) {
   CheckOnCorrectThread();
-  thread_loop_ = task_runner;
+  thread_task_runner_ = task_runner.Pass();
 }
 
 bool PrefMemberVectorStringUpdate(const base::Value& value,
diff --git a/base/prefs/pref_member.h b/base/prefs/pref_member.h
index 9b140d1..6dceb43 100644
--- a/base/prefs/pref_member.h
+++ b/base/prefs/pref_member.h
@@ -65,8 +65,7 @@ class BASE_PREFS_EXPORT PrefMemberBase : public PrefObserver {
                      bool is_user_modifiable,
                      const base::Closure& callback) const;
 
-    void MoveToThread(
-        const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
+    void MoveToThread(scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
     // See PrefMember<> for description.
     bool IsManaged() const {
@@ -92,7 +91,7 @@ class BASE_PREFS_EXPORT PrefMemberBase : public PrefObserver {
 
     bool IsOnCorrectThread() const;
 
-    scoped_refptr<base::SingleThreadTaskRunner> thread_loop_;
+    scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner_;
     mutable bool is_managed_;
     mutable bool is_user_modifiable_;
 
@@ -113,8 +112,7 @@ class BASE_PREFS_EXPORT PrefMemberBase : public PrefObserver {
   // See PrefMember<> for description.
   void Destroy();
 
-  void MoveToThread(
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
+  void MoveToThread(scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
   // PrefObserver
   void OnPreferenceChanged(PrefService* service,
@@ -201,8 +199,7 @@ class PrefMember : public subtle::PrefMemberBase {
   // via PostTask.
   // This method should only be used from the thread the PrefMember is currently
   // on, which is the UI thread by default.
-  void MoveToThread(
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
+  void MoveToThread(scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
     subtle::PrefMemberBase::MoveToThread(task_runner);
   }
 
diff --git a/base/threading/sequenced_worker_pool.cc b/base/threading/sequenced_worker_pool.cc
index faf7f53..7bbca92 100644
--- a/base/threading/sequenced_worker_pool.cc
+++ b/base/threading/sequenced_worker_pool.cc
@@ -17,11 +17,11 @@
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread_local.h"
@@ -1157,29 +1157,26 @@ SequencedWorkerPool::GetSequenceTokenForCurrentThread() {
   return *token;
 }
 
-SequencedWorkerPool::SequencedWorkerPool(
-    size_t max_threads,
-    const std::string& thread_name_prefix)
-    : constructor_message_loop_(MessageLoopProxy::current()),
+SequencedWorkerPool::SequencedWorkerPool(size_t max_threads,
+                                         const std::string& thread_name_prefix)
+    : constructor_task_runner_(ThreadTaskRunnerHandle::Get()),
       inner_(new Inner(this, max_threads, thread_name_prefix, NULL)) {
 }
 
-SequencedWorkerPool::SequencedWorkerPool(
-    size_t max_threads,
-    const std::string& thread_name_prefix,
-    TestingObserver* observer)
-    : constructor_message_loop_(MessageLoopProxy::current()),
+SequencedWorkerPool::SequencedWorkerPool(size_t max_threads,
+                                         const std::string& thread_name_prefix,
+                                         TestingObserver* observer)
+    : constructor_task_runner_(ThreadTaskRunnerHandle::Get()),
       inner_(new Inner(this, max_threads, thread_name_prefix, observer)) {
 }
 
 SequencedWorkerPool::~SequencedWorkerPool() {}
 
 void SequencedWorkerPool::OnDestruct() const {
-  DCHECK(constructor_message_loop_.get());
   // Avoid deleting ourselves on a worker thread (which would
   // deadlock).
   if (RunsTasksOnCurrentThread()) {
-    constructor_message_loop_->DeleteSoon(FROM_HERE, this);
+    constructor_task_runner_->DeleteSoon(FROM_HERE, this);
   } else {
     delete this;
   }
@@ -1299,7 +1296,7 @@ void SequencedWorkerPool::SignalHasWorkForTesting() {
 }
 
 void SequencedWorkerPool::Shutdown(int max_new_blocking_tasks_after_shutdown) {
-  DCHECK(constructor_message_loop_->BelongsToCurrentThread());
+  DCHECK(constructor_task_runner_->BelongsToCurrentThread());
   inner_->Shutdown(max_new_blocking_tasks_after_shutdown);
 }
 
diff --git a/base/threading/sequenced_worker_pool.h b/base/threading/sequenced_worker_pool.h
index 0b6c5f9..ee282bc 100644
--- a/base/threading/sequenced_worker_pool.h
+++ b/base/threading/sequenced_worker_pool.h
@@ -13,6 +13,7 @@
 #include "base/callback_forward.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
 
 namespace tracked_objects {
@@ -21,7 +22,7 @@ class Location;
 
 namespace base {
 
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 
 template <class T> class DeleteHelper;
 
@@ -345,7 +346,7 @@ class BASE_EXPORT SequencedWorkerPool : public TaskRunner {
   class Inner;
   class Worker;
 
-  const scoped_refptr<MessageLoopProxy> constructor_message_loop_;
+  const scoped_refptr<SingleThreadTaskRunner> constructor_task_runner_;
 
   // Avoid pulling in too many headers by putting (almost) everything
   // into |inner_|.