Introduce a new framework for back-and-forth tracked/protected preferences migration.

base/files/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.
 
 #if defined _MSC_VER && _MSC_VER == 1800
 // TODO(scottmg): Internal errors on VS2013 RC in LTCG. This should be removed
 // after RTM. http://crbug.com/288948
 #pragma optimize("", off)
 #endif
 
 #include "base/files/important_file_writer.h"
 
 #include <stdio.h>
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/critical_closure.h"
 #include "base/file_util.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner.h"
+#include "base/task_runner_util.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 
 namespace base {
 
 namespace {
 
 const int kDefaultCommitIntervalMs = 10000;
 
 enum TempFileFailure {
@@ skipping 56 matching lines @@
 
   return true;
 }
 
 ImportantFileWriter::ImportantFileWriter(
     const FilePath& path, base::SequencedTaskRunner* task_runner)
         : path_(path),
           task_runner_(task_runner),
           serializer_(NULL),
           commit_interval_(TimeDelta::FromMilliseconds(
-              kDefaultCommitIntervalMs)) {
+              kDefaultCommitIntervalMs)),
+          weak_factory_(this) {
   DCHECK(CalledOnValidThread());
   DCHECK(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 (!task_runner_->PostTask(
+  if (!base::PostTaskAndReplyWithResult(
+          task_runner_,
           FROM_HERE,
           MakeCriticalClosure(
-              Bind(IgnoreResult(&ImportantFileWriter::WriteFileAtomically),
-                   path_, data)))) {
+              Bind(&ImportantFileWriter::WriteFileAtomically,
+                   path_, data)),
+          Bind(&ImportantFileWriter::ForwardSuccessfulWrite,
+               weak_factory_.GetWeakPtr()))) {
     // 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();
 
     WriteFileAtomically(path_, data);
   }
 }
 
 void ImportantFileWriter::ScheduleWrite(DataSerializer* serializer) {
@@ skipping 13 matching lines @@
   std::string data;
   if (serializer_->SerializeData(&data)) {
     WriteNow(data);
   } else {
     DLOG(WARNING) << "failed to serialize data to be saved in "
                   << path_.value().c_str();
   }
   serializer_ = NULL;
 }
 
+void ImportantFileWriter::RegisterOnNextSuccessfulWriteCallback(
+    const base::Closure& on_next_successful_write) {
+  DCHECK(on_next_successful_write_.is_null());
+  on_next_successful_write_ = on_next_successful_write;
+}
+
+void ImportantFileWriter::ForwardSuccessfulWrite(bool result) {
+  DCHECK(CalledOnValidThread());
+  if (result && !on_next_successful_write_.is_null()) {
+    on_next_successful_write_.Run();
+    on_next_successful_write_.Reset();
+  }
+}
+
 }  // namespace base