Add synchronous callback support to important_file_writer.cc

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.
 
 #include "base/files/important_file_writer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string>
@@ skipping 40 matching lines @@
 void LogFailure(const FilePath& path, TempFileFailure failure_code,
                 StringPiece message) {
   UMA_HISTOGRAM_ENUMERATION("ImportantFile.TempFileFailures", failure_code,
                             TEMP_FILE_FAILURE_MAX);
   DPLOG(WARNING) << "temp file failure: " << path.value() << " : " << message;
 }
 
 // Helper function to call WriteFileAtomically() with a
 // std::unique_ptr<std::string>.
 bool WriteScopedStringToFileAtomically(const FilePath& path,
-                                       std::unique_ptr<std::string> data) {
-  return ImportantFileWriter::WriteFileAtomically(path, *data);
+                                       std::unique_ptr<std::string> data,
+                                       Callback<void(bool success)> callback) {
+  bool result = ImportantFileWriter::WriteFileAtomically(path, *data);
+
+  if (!callback.is_null())
+    callback.Run(result);
+
+  return result;
 }
 
 }  // namespace
 
 // static
 bool ImportantFileWriter::WriteFileAtomically(const FilePath& path,
                                               StringPiece data) {
 #if defined(OS_CHROMEOS)
   // On Chrome OS, chrome gets killed when it cannot finish shutdown quickly,
   // and this function seems to be one of the slowest shutdown steps.
@@ skipping 88 matching lines @@
 void ImportantFileWriter::WriteNow(std::unique_ptr<std::string> data) {
   DCHECK(CalledOnValidThread());
   if (!IsValueInRangeForNumericType<int32_t>(data->length())) {
     NOTREACHED();
     return;
   }
 
   if (HasPendingWrite())
     timer_.Stop();
 
-  auto task = Bind(&WriteScopedStringToFileAtomically, path_, Passed(&data));
+  auto task = Bind(&WriteScopedStringToFileAtomically, path_, Passed(&data),
+                   on_next_write_callback_);
+  on_next_write_callback_.Reset();
+
   if (!PostWriteTask(task)) {
     // 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();
 
     task.Run();
   }
 }
 
@@ skipping 14 matching lines @@
   std::unique_ptr<std::string> data(new std::string);
   if (serializer_->SerializeData(data.get())) {
     WriteNow(std::move(data));
   } else {
     DLOG(WARNING) << "failed to serialize data to be saved in "
                   << path_.value();
   }
   serializer_ = nullptr;
 }
 
-void ImportantFileWriter::RegisterOnNextSuccessfulWriteCallback(
-    const Closure& on_next_successful_write) {
-  DCHECK(on_next_successful_write_.is_null());
-  on_next_successful_write_ = on_next_successful_write;
+void ImportantFileWriter::RegisterOnNextSuccessfulWriteReply(
+    const Closure& on_next_successful_write_reply) {
+  DCHECK(on_next_successful_write_reply_.is_null());
+  on_next_successful_write_reply_ = on_next_successful_write_reply;
+}
+
+void ImportantFileWriter::RegisterOnNextWriteSynchronousCallback(
+    const Callback<void(bool success)>& on_next_write_callback) {
+  DCHECK(on_next_write_callback_.is_null());
+  on_next_write_callback_ = on_next_write_callback;
 }
 
 bool ImportantFileWriter::PostWriteTask(const Callback<bool()>& task) {
   // TODO(gab): This code could always use PostTaskAndReplyWithResult and let
   // ForwardSuccessfulWrite() no-op if |on_next_successful_write_| is null, but
   // PostTaskAndReply causes memory leaks in tests (crbug.com/371974) and
   // suppressing all of those is unrealistic hence we avoid most of them by
   // using PostTask() in the typical scenario below.
-  if (!on_next_successful_write_.is_null()) {
+  if (!on_next_successful_write_reply_.is_null()) {
     return PostTaskAndReplyWithResult(
         task_runner_.get(),
         FROM_HERE,
         MakeCriticalClosure(task),
         Bind(&ImportantFileWriter::ForwardSuccessfulWrite,
              weak_factory_.GetWeakPtr()));
   }
   return task_runner_->PostTask(
       FROM_HERE,
       MakeCriticalClosure(Bind(IgnoreResult(task))));
 }
 
 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();
+  if (result && !on_next_successful_write_reply_.is_null()) {
+    on_next_successful_write_reply_.Run();
+    on_next_successful_write_reply_.Reset();
   }
 }
 
 }  // namespace base