Third patch in getting rid of caching MessageLoop pointers and always using C...

chrome/common/important_file_writer.cc

 // Copyright (c) 2009 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 <ostream>
 #include <string>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/thread.h"
 #include "base/time.h"
+#include "chrome/browser/chrome_thread.h"
 
 using base::TimeDelta;
 
 namespace {
 
 const int kDefaultCommitIntervalMs = 10000;
 
 class WriteToDiskTask : public Task {
  public:
   WriteToDiskTask(const FilePath& path, const std::string& data)
@@ skipping 46 matching lines @@
   }
 
   const FilePath path_;
   const std::string data_;
 
   DISALLOW_COPY_AND_ASSIGN(WriteToDiskTask);
 };
 
 }  // namespace
 
-ImportantFileWriter::ImportantFileWriter(const FilePath& path,
-                                         const base::Thread* backend_thread)
+ImportantFileWriter::ImportantFileWriter(const FilePath& path)
     : path_(path),
-      backend_thread_(backend_thread),
       serializer_(NULL),
       commit_interval_(TimeDelta::FromMilliseconds(kDefaultCommitIntervalMs)) {
   DCHECK(CalledOnValidThread());
 }
 
 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 (HasPendingWrite())
     timer_.Stop();
 
-  Task* task = new WriteToDiskTask(path_, data);
-  if (backend_thread_) {
-    backend_thread_->message_loop()->PostTask(FROM_HERE, task);
-  } else {
-    task->Run();
-    delete task;
-  }
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE, new WriteToDiskTask(path_, data));
 }
 
 void ImportantFileWriter::ScheduleWrite(DataSerializer* serializer) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(serializer);
   serializer_ = serializer;
 
   if (!MessageLoop::current()) {
     // Happens in unit tests.
@@ skipping 11 matching lines @@
   DCHECK(serializer_);
   std::string data;
   if (serializer_->SerializeData(&data)) {
     WriteNow(data);
   } else {
     LOG(WARNING) << "failed to serialize data to be saved in "
                  << path_.value();
   }
   serializer_ = NULL;
 }