Reduce usage of MessageLoopProxy in base/

base/prefs/json_pref_store.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/json_pref_store.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/prefs/pref_filter.h"
 #include "base/sequenced_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 
 namespace {
 
 // Some extensions we'll tack on to copies of the Preferences files.
 const base::FilePath::CharType* kBadExtension = FILE_PATH_LITERAL("bad");
 
 // Differentiates file loading between origin thread and passed
 // (aka file) thread.
 class FileThreadDeserializer
     : public base::RefCountedThreadSafe<FileThreadDeserializer> {
  public:
-  FileThreadDeserializer(JsonPrefStore* delegate,
-                         base::SequencedTaskRunner* sequenced_task_runner)
+  FileThreadDeserializer(
+      JsonPrefStore* delegate,
+      const scoped_refptr<base::SequencedTaskRunner>& sequenced_task_runner)
       : no_dir_(false),
         error_(PersistentPrefStore::PREF_READ_ERROR_NONE),
         delegate_(delegate),
         sequenced_task_runner_(sequenced_task_runner),
-        origin_loop_proxy_(base::MessageLoopProxy::current()) {
-  }
+        origin_task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
 
   void Start(const base::FilePath& path,
              const base::FilePath& alternate_path) {
-    DCHECK(origin_loop_proxy_->BelongsToCurrentThread());
+    DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
     // TODO(gab): This should use PostTaskAndReplyWithResult instead of using
     // the |error_| member to pass data across tasks.
     sequenced_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&FileThreadDeserializer::ReadFileAndReport,
                    this, path, alternate_path));
   }
 
   // Deserializes JSON on the sequenced task runner.
   void ReadFileAndReport(const base::FilePath& path,
                          const base::FilePath& alternate_path) {
     DCHECK(sequenced_task_runner_->RunsTasksOnCurrentThread());
 
     value_.reset(DoReading(path, alternate_path, &error_, &no_dir_));
 
-    origin_loop_proxy_->PostTask(
+    origin_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&FileThreadDeserializer::ReportOnOriginThread, this));
   }
 
   // Reports deserialization result on the origin thread.
   void ReportOnOriginThread() {
-    DCHECK(origin_loop_proxy_->BelongsToCurrentThread());
+    DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
     delegate_->OnFileRead(value_.Pass(), error_, no_dir_);
   }
 
   static base::Value* DoReading(const base::FilePath& path,
                                 const base::FilePath& alternate_path,
                                 PersistentPrefStore::PrefReadError* error,
                                 bool* no_dir) {
     if (!base::PathExists(path) && !alternate_path.empty() &&
         base::PathExists(alternate_path)) {
       base::Move(alternate_path, path);
@@ skipping 16 matching lines @@
 
  private:
   friend class base::RefCountedThreadSafe<FileThreadDeserializer>;
   ~FileThreadDeserializer() {}
 
   bool no_dir_;
   PersistentPrefStore::PrefReadError error_;
   scoped_ptr<base::Value> value_;
   const scoped_refptr<JsonPrefStore> delegate_;
   const scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner_;
-  const scoped_refptr<base::MessageLoopProxy> origin_loop_proxy_;
+  const scoped_refptr<base::SequencedTaskRunner> origin_task_runner_;
 };
 
 // static
 void FileThreadDeserializer::HandleErrors(
     const base::Value* value,
     const base::FilePath& path,
     int error_code,
     const std::string& error_msg,
     PersistentPrefStore::PrefReadError* error) {
   *error = PersistentPrefStore::PREF_READ_ERROR_NONE;
@@ skipping 41 matching lines @@
 scoped_refptr<base::SequencedTaskRunner> JsonPrefStore::GetTaskRunnerForFile(
     const base::FilePath& filename,
     base::SequencedWorkerPool* worker_pool) {
   std::string token("json_pref_store-");
   token.append(filename.AsUTF8Unsafe());
   return worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
       worker_pool->GetNamedSequenceToken(token),
       base::SequencedWorkerPool::BLOCK_SHUTDOWN);
 }
 
-JsonPrefStore::JsonPrefStore(const base::FilePath& filename,
-                             base::SequencedTaskRunner* sequenced_task_runner,
-                             scoped_ptr<PrefFilter> pref_filter)
+JsonPrefStore::JsonPrefStore(
+    const base::FilePath& filename,
+    const scoped_refptr<base::SequencedTaskRunner>& sequenced_task_runner,
+    scoped_ptr<PrefFilter> pref_filter)
     : path_(filename),
       sequenced_task_runner_(sequenced_task_runner),
       prefs_(new base::DictionaryValue()),
       read_only_(false),
       writer_(filename, sequenced_task_runner),
       pref_filter_(pref_filter.Pass()),
       initialized_(false),
       filtering_in_progress_(false),
       read_error_(PREF_READ_ERROR_NONE) {
 }
 
-JsonPrefStore::JsonPrefStore(const base::FilePath& filename,
-                             const base::FilePath& alternate_filename,
-                             base::SequencedTaskRunner* sequenced_task_runner,
-                             scoped_ptr<PrefFilter> pref_filter)
+JsonPrefStore::JsonPrefStore(
+    const base::FilePath& filename,
+    const base::FilePath& alternate_filename,
+    const scoped_refptr<base::SequencedTaskRunner>& sequenced_task_runner,
+    scoped_ptr<PrefFilter> pref_filter)
     : path_(filename),
       alternate_path_(alternate_filename),
       sequenced_task_runner_(sequenced_task_runner),
       prefs_(new base::DictionaryValue()),
       read_only_(false),
       writer_(filename, sequenced_task_runner),
       pref_filter_(pref_filter.Pass()),
       initialized_(false),
       filtering_in_progress_(false),
       read_error_(PREF_READ_ERROR_NONE) {
@@ skipping 220 matching lines @@
 
   if (error_delegate_ && read_error_ != PREF_READ_ERROR_NONE)
     error_delegate_->OnError(read_error_);
 
   FOR_EACH_OBSERVER(PrefStore::Observer,
                     observers_,
                     OnInitializationCompleted(true));
 
   return;
 }