Revert of base: Remove use of MessageLoopProxy

base/prefs/pref_member.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 "base/prefs/pref_member.h"
 
 #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 {
 
 PrefMemberBase::PrefMemberBase()
     : prefs_(NULL),
       setting_value_(false) {
 }
 
 PrefMemberBase::~PrefMemberBase() {
@@ skipping 20 matching lines @@
 }
 
 void PrefMemberBase::Destroy() {
   if (prefs_ && !pref_name_.empty()) {
     prefs_->RemovePrefObserver(pref_name_, this);
     prefs_ = NULL;
   }
 }
 
 void PrefMemberBase::MoveToThread(
-    scoped_refptr<SingleThreadTaskRunner> task_runner) {
+    const 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);
 }
 
 void PrefMemberBase::OnPreferenceChanged(PrefService* service,
                                          const std::string& pref_name) {
   VerifyValuePrefName();
@@ skipping 18 matching lines @@
   if (!internal())
     UpdateValueFromPref(base::Closure());
 }
 
 void PrefMemberBase::InvokeUnnamedCallback(const base::Closure& callback,
                                            const std::string& pref_name) {
   callback.Run();
 }
 
 PrefMemberBase::Internal::Internal()
-    : thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+    : thread_loop_(MessageLoopProxy::current()),
       is_managed_(false),
       is_user_modifiable_(false) {
 }
 PrefMemberBase::Internal::~Internal() { }
 
 bool PrefMemberBase::Internal::IsOnCorrectThread() const {
-  return thread_task_runner_->BelongsToCurrentThread();
+  // In unit tests, there may not be a message loop.
+  return thread_loop_.get() == NULL || thread_loop_->BelongsToCurrentThread();
 }
 
 void PrefMemberBase::Internal::UpdateValue(
     base::Value* v,
     bool is_managed,
     bool is_user_modifiable,
     const base::Closure& callback) const {
   scoped_ptr<base::Value> value(v);
   base::ScopedClosureRunner closure_runner(callback);
   if (IsOnCorrectThread()) {
     bool rv = UpdateValueInternal(*value);
     DCHECK(rv);
     is_managed_ = is_managed;
     is_user_modifiable_ = is_user_modifiable;
   } else {
-    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()));
+    bool may_run = thread_loop_->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(
-    scoped_refptr<SingleThreadTaskRunner> task_runner) {
+    const scoped_refptr<SingleThreadTaskRunner>& task_runner) {
   CheckOnCorrectThread();
-  thread_task_runner_ = task_runner.Pass();
+  thread_loop_ = task_runner;
 }
 
 bool PrefMemberVectorStringUpdate(const base::Value& value,
                                   std::vector<std::string>* string_vector) {
   if (!value.IsType(base::Value::TYPE_LIST))
     return false;
   const base::ListValue* list = static_cast<const base::ListValue*>(&value);
 
   std::vector<std::string> local_vector;
   for (base::ListValue::const_iterator it = list->begin();
@@ skipping 74 matching lines @@
   base::ListValue list_value;
   list_value.AppendStrings(value);
   prefs()->Set(pref_name(), list_value);
 }
 
 template <>
 bool PrefMember<std::vector<std::string> >::Internal::UpdateValueInternal(
     const base::Value& value) const {
   return subtle::PrefMemberVectorStringUpdate(value, &value_);
 }