Add synchronous callback support to important_file_writer.cc

base/files/important_file_writer.h

 // 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.
 
 #ifndef BASE_FILES_IMPORTANT_FILE_WRITER_H_
 #define BASE_FILES_IMPORTANT_FILE_WRITER_H_
 
 #include <string>
 
 #include "base/base_export.h"
@@ skipping 76 matching lines @@
   // to disk after the commit interval. If another ScheduleWrite is issued
   // before that, only one serialization and write to disk will happen, and
   // the most recent |serializer| will be used. This operation does not block.
   // |serializer| should remain valid through the lifetime of
   // ImportantFileWriter.
   void ScheduleWrite(DataSerializer* serializer);
 
   // Serialize data pending to be saved and execute write on backend thread.
   void DoScheduledWrite();
 
-  // Registers |on_next_successful_write| to be called once, on the next
-  // successful write event. Only one callback can be set at once.
-  void RegisterOnNextSuccessfulWriteCallback(
-      const Closure& on_next_successful_write);
+  // Registers |on_next_write_callback| to be synchronously invoked from
+  // WriteFileAtomically() on its next write (i.e. from |task_runner_|), with
+  // |success| indicating whether it succeeded or not.
+  // |on_next_write_callback| must be thread safe, as it will be called on
+  // |task_runner_| and may be called during Chrome shutdown.
+  // If called more than once before a write is done, the latest callback

[gab, 2016/09/19 18:01:30]

s/before a write is done/before a write is scheduled on |task_runner|/

(i.e. the callback is passed when the write is scheduled and the next one can be
registered before the write is truly "done" -- note your new approach actually
fixes a race in the previous implementation whereby when the reply arrived it
could in theory run a callback registered later... this never occurred in
practice the way it was used today, but this CL is still addressing a
to-this-date-unknown API bug :-))

[proberge, 2016/09/19 21:24:25]

Done.

+  // clobbers the others.
+  void RegisterOnNextWriteCallback(
+      const Callback<void(bool success)>& on_next_write_callback);
 
   TimeDelta commit_interval() const {
     return commit_interval_;
   }
 
  private:
-  // Helper method for WriteNow().
-  bool PostWriteTask(const Callback<bool()>& task);
-
-  // If |result| is true and |on_next_successful_write_| is set, invokes
-  // |on_successful_write_| and then resets it; no-ops otherwise.
-  void ForwardSuccessfulWrite(bool result);
-
-  // Invoked once and then reset on the next successful write event.
-  Closure on_next_successful_write_;
+  // Invoked synchronously on the next write event.
+  Callback<void(bool success)> on_next_write_callback_;
 
   // Path being written to.
   const FilePath path_;
 
   // TaskRunner for the thread on which file I/O can be done.
   const scoped_refptr<SequencedTaskRunner> task_runner_;
 
   // Timer used to schedule commit after ScheduleWrite.
   OneShotTimer timer_;
 
   // Serializer which will provide the data to be saved.
   DataSerializer* serializer_;
 
   // Time delta after which scheduled data will be written to disk.
   const TimeDelta commit_interval_;
 
   WeakPtrFactory<ImportantFileWriter> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ImportantFileWriter);
 };
 
 }  // namespace base
 
 #endif  // BASE_FILES_IMPORTANT_FILE_WRITER_H_