Reduce usage of MessageLoopProxy in base/

base/prefs/pref_member.h

 // 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.
 //
 // A helper class that stays in sync with a preference (bool, int, real,
 // string or filepath).  For example:
 //
 // class MyClass {
 //  public:
 //   MyClass(PrefService* prefs) {
@@ skipping 15 matching lines @@
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_forward.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/prefs/base_prefs_export.h"
 #include "base/prefs/pref_observer.h"
+#include "base/sequenced_task_runner.h"
 #include "base/values.h"
 
 class PrefService;
 
 namespace subtle {
 
 class BASE_PREFS_EXPORT PrefMemberBase : public PrefObserver {
  public:
   // Type of callback you can register if you need to know the name of
   // the pref that is changing.
   typedef base::Callback<void(const std::string&)> NamedChangeCallback;
 
   PrefService* prefs() { return prefs_; }
   const PrefService* prefs() const { return prefs_; }
 
  protected:
   class BASE_PREFS_EXPORT Internal
       : public base::RefCountedThreadSafe<Internal> {
    public:
     Internal();
 
     // Update the value, either by calling |UpdateValueInternal| directly
     // or by dispatching to the right thread.
     // Takes ownership of |value|.
     void UpdateValue(base::Value* value,
                      bool is_managed,
                      bool is_user_modifiable,
                      const base::Closure& callback) const;
 
-    void MoveToThread(
-        const scoped_refptr<base::MessageLoopProxy>& message_loop);
+    void MoveToTaskRunner(

[darin (slow to review), 2014/07/10 22:12:05]

Hmm, MoveToThread seems like a better name. The concept of moving something to a
TaskRunner is quite awkward. The previous code used MLP as a proxy for
identifying a thread. Now you are just using a TaskRunner for that purpose.
Otherwise, nothing is really changing, right?

[Ryan Sleevi, 2014/07/10 22:46:37]

Correct, but with the caveat explained (below) that the specific concept of a
Thread is a more restrictive API than the generic concept of a "Task Runner",
for reasons below.

+        const scoped_refptr<base::SequencedTaskRunner>& task_runner);

[darin (slow to review), 2014/07/10 22:12:05]

shouldn't this be a SingleThreadTaskRunner given the IsOnCorrectThread
implementation?

[Ryan Sleevi, 2014/07/10 22:46:37]

This is not actually coupled to a particular thread, though. That is, many of
our "UI thread"-type dependencies are expressions of "the same task runner I was
on before", which the caller supplies.

The (generally speaking) only time we should be using SingleThreadTaskRunner, as
opposed to SequencedTaskRunner, is when we're expressly making use of
thread-local state - whether through ThreadLocalStorage or through some API
call.

Prefs doesn't have this TLS dependency, hence the 'broadening' of the acceptable
API to SequencedTaskRunner.

Note that a SequencedTaskRunner guarantees that two tasks as part of the same
sequence will not run in parallel, so this has the same implied semantics that
we say when we talk about "threads" are still present (in terms of single,
ordered steps of execution). The only change is with respect to thread-local
storage.

 
     // See PrefMember<> for description.
     bool IsManaged() const {
       return is_managed_;
     }
 
     bool IsUserModifiable() const {
       return is_user_modifiable_;
     }
 
    protected:
     friend class base::RefCountedThreadSafe<Internal>;
     virtual ~Internal();
 
     void CheckOnCorrectThread() const {
       DCHECK(IsOnCorrectThread());
     }
 
    private:
     // This method actually updates the value. It should only be called from
     // the thread the PrefMember is on.
     virtual bool UpdateValueInternal(const base::Value& value) const = 0;
 
     bool IsOnCorrectThread() const;
 
-    scoped_refptr<base::MessageLoopProxy> thread_loop_;
+    scoped_refptr<base::SequencedTaskRunner> task_runner_;
     mutable bool is_managed_;
     mutable bool is_user_modifiable_;
 
     DISALLOW_COPY_AND_ASSIGN(Internal);
   };
 
   PrefMemberBase();
   virtual ~PrefMemberBase();
 
   // See PrefMember<> for description.
   void Init(const char* pref_name, PrefService* prefs,
             const NamedChangeCallback& observer);
   void Init(const char* pref_name, PrefService* prefs);
 
   virtual void CreateInternal() const = 0;
 
   // See PrefMember<> for description.
   void Destroy();
 
-  void MoveToThread(const scoped_refptr<base::MessageLoopProxy>& message_loop);
+  void MoveToTaskRunner(
+      const scoped_refptr<base::SequencedTaskRunner>& task_runner);
 
   // PrefObserver
   virtual void OnPreferenceChanged(PrefService* service,
                                    const std::string& pref_name) OVERRIDE;
 
   void VerifyValuePrefName() const {
     DCHECK(!pref_name_.empty());
   }
 
   // This method is used to do the actual sync with the preference.
@@ skipping 51 matching lines @@
     subtle::PrefMemberBase::Init(
         pref_name, prefs,
         base::Bind(&PrefMemberBase::InvokeUnnamedCallback, observer));
   }
   void Init(const char* pref_name, PrefService* prefs) {
     subtle::PrefMemberBase::Init(pref_name, prefs);
   }
 
   // Unsubscribes the PrefMember from the PrefService. After calling this
   // function, the PrefMember may not be used any more on the UI thread.
-  // Assuming |MoveToThread| was previously called, |GetValue|, |IsManaged|,
+  // Assuming |MoveToTaskRunner| was previously called, |GetValue|, |IsManaged|,
   // and |IsUserModifiable| can still be called from the other thread but
   // the results will no longer update from the PrefService.
   // This method should only be called on the UI thread.
   void Destroy() {
     subtle::PrefMemberBase::Destroy();
   }
 
   // Moves the PrefMember to another thread, allowing read accesses from there.
   // Changes from the PrefService will be propagated asynchronously
   // 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::MessageLoopProxy>& message_loop) {
-    subtle::PrefMemberBase::MoveToThread(message_loop);
+  void MoveToTaskRunner(
+      const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
+    subtle::PrefMemberBase::MoveToTaskRunner(task_runner);
   }
 
   // Check whether the pref is managed, i.e. controlled externally through
   // enterprise configuration management (e.g. windows group policy). Returns
   // false for unknown prefs.
   // This method should only be used from the thread the PrefMember is currently
-  // on, which is the UI thread unless changed by |MoveToThread|.
+  // on, which is the UI thread unless changed by |MoveToTaskRunner|.
   bool IsManaged() const {
     VerifyPref();
     return internal_->IsManaged();
   }
 
   // Checks whether the pref can be modified by the user. This returns false
   // when the pref is managed by a policy or an extension, and when a command
   // line flag overrides the pref.
   // This method should only be used from the thread the PrefMember is currently
-  // on, which is the UI thread unless changed by |MoveToThread|.
+  // on, which is the UI thread unless changed by |MoveToTaskRunner|.
   bool IsUserModifiable() const {
     VerifyPref();
     return internal_->IsUserModifiable();
   }
 
   // Retrieve the value of the member variable.
   // This method should only be used from the thread the PrefMember is currently
-  // on, which is the UI thread unless changed by |MoveToThread|.
+  // on, which is the UI thread unless changed by |MoveToTaskRunner|.
   ValueType GetValue() const {
     VerifyPref();
     return internal_->value();
   }
 
   // Provided as a convenience.
   ValueType operator*() const {
     return GetValue();
   }
 
@@ skipping 106 matching lines @@
 
 typedef PrefMember<bool> BooleanPrefMember;
 typedef PrefMember<int> IntegerPrefMember;
 typedef PrefMember<double> DoublePrefMember;
 typedef PrefMember<std::string> StringPrefMember;
 typedef PrefMember<base::FilePath> FilePathPrefMember;
 // This preference member is expensive for large string arrays.
 typedef PrefMember<std::vector<std::string> > StringListPrefMember;
 
 #endif  // BASE_PREFS_PREF_MEMBER_H_