Use worker pool for IO in JsonPrefStore.

chrome/common/important_file_writer.cc

 // Copyright (c) 2011 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 "chrome/common/important_file_writer.h"
 
 #include <stdio.h>
 
 #include <string>
 
@@ skipping 71 matching lines @@
   if (!file_util::ReplaceFile(tmp_file_path, path)) {
     LogFailure(path, FAILED_RENAMING, "could not rename temporary file");
     file_util::Delete(tmp_file_path, false);
     return;
   }
 }
 
 }  // namespace
 
 ImportantFileWriter::ImportantFileWriter(
-    const FilePath& path, base::MessageLoopProxy* file_message_loop_proxy)
-        : path_(path),
-          file_message_loop_proxy_(file_message_loop_proxy),
-          serializer_(NULL),
-          commit_interval_(TimeDelta::FromMilliseconds(
-              kDefaultCommitIntervalMs)) {
+    const FilePath& path,
+    base::SequencedTaskRunner* blocking_task_runner)
+    : path_(path),
+      blocking_task_runner_(blocking_task_runner),
+      serializer_(NULL),
+      commit_interval_(TimeDelta::FromMilliseconds(
+          kDefaultCommitIntervalMs)) {
   DCHECK(CalledOnValidThread());
-  DCHECK(file_message_loop_proxy_.get());
+  DCHECK(blocking_task_runner_.get());
 }
 
 ImportantFileWriter::~ImportantFileWriter() {
   // We're usually a member variable of some other object, which also tends
   // to be our serializer. It may not be safe to call back to the parent object
   // being destructed.
   DCHECK(!HasPendingWrite());
 }
 
 bool ImportantFileWriter::HasPendingWrite() const {
   DCHECK(CalledOnValidThread());
   return timer_.IsRunning();
 }
 
 void ImportantFileWriter::WriteNow(const std::string& data) {
   DCHECK(CalledOnValidThread());
   if (data.length() > static_cast<size_t>(kint32max)) {
     NOTREACHED();
     return;
   }
 
   if (HasPendingWrite())
     timer_.Stop();
 
-  if (!file_message_loop_proxy_->PostTask(
+  if (!blocking_task_runner_->PostTask(
       FROM_HERE, base::Bind(&WriteToDiskTask, path_, data))) {
     // Posting the task to background message loop is not expected
     // to fail, but if it does, avoid losing data and just hit the disk
     // on the current thread.
     NOTREACHED();
 
     WriteToDiskTask(path_, data);
   }
 }
 
@@ skipping 13 matching lines @@
   DCHECK(serializer_);
   std::string data;
   if (serializer_->SerializeData(&data)) {
     WriteNow(data);
   } else {
     DLOG(WARNING) << "failed to serialize data to be saved in "
                   << path_.value();
   }
   serializer_ = NULL;
 }