Allow ImportantFileWriter to take in a pre-write callback.

components/prefs/json_pref_store.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 COMPONENTS_PREFS_JSON_PREF_STORE_H_
 #define COMPONENTS_PREFS_JSON_PREF_STORE_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 16 matching lines @@
 
 namespace base {
 class Clock;
 class DictionaryValue;
 class FilePath;
 class HistogramBase;
 class JsonPrefStoreCallbackTest;
 class JsonPrefStoreLossyWriteTest;
 class SequencedTaskRunner;
 class SequencedWorkerPool;
+class WriteCallbacksObserver;
 class Value;
 FORWARD_DECLARE_TEST(JsonPrefStoreTest, WriteCountHistogramTestBasic);
 FORWARD_DECLARE_TEST(JsonPrefStoreTest, WriteCountHistogramTestSinglePeriod);
 FORWARD_DECLARE_TEST(JsonPrefStoreTest, WriteCountHistogramTestMultiplePeriods);
 FORWARD_DECLARE_TEST(JsonPrefStoreTest, WriteCountHistogramTestPeriodWithGaps);
 }
 
 // A writable PrefStore implementation that is used for user preferences.
 class COMPONENTS_PREFS_EXPORT JsonPrefStore
     : public PersistentPrefStore,
       public base::ImportantFileWriter::DataSerializer,
       public base::SupportsWeakPtr<JsonPrefStore>,
       public base::NonThreadSafe {
  public:
   struct ReadResult;
 
+  // A pair of callbacks to call before and after the preference file is written
+  // to disk.
+  using OnWriteCallbackPair =
+      std::pair<base::Closure, base::Callback<void(bool success)>>;
+
   // Returns instance of SequencedTaskRunner which guarantees that file
   // operations on the same file will be executed in sequenced order.
   static scoped_refptr<base::SequencedTaskRunner> GetTaskRunnerForFile(
       const base::FilePath& pref_filename,
       base::SequencedWorkerPool* worker_pool);
 
   // Same as the constructor below with no alternate filename.
   JsonPrefStore(
       const base::FilePath& pref_filename,
       const scoped_refptr<base::SequencedTaskRunner>& sequenced_task_runner,
@@ skipping 44 matching lines @@
   // cleanup that shouldn't otherwise alert observers.
   void RemoveValueSilently(const std::string& key, uint32_t flags);
 
   // Registers |on_next_successful_write_reply| to be called once, on the next
   // successful write event of |writer_|.
   // |on_next_successful_write_reply| will be called on the thread from which
   // this method is called and does not need to be thread safe.
   void RegisterOnNextSuccessfulWriteReply(
       const base::Closure& on_next_successful_write_reply);
 
-  // Registers |on_next_write_callback| to be called once synchronously, on the
-  // next write event of |writer_|.
-  // |on_next_write_callback| must be thread-safe.
-  void RegisterOnNextWriteSynchronousCallback(
-      const base::Callback<void(bool success)>& on_next_write_callback);
-
   void ClearMutableValues() override;
 
  private:
   // Represents a histogram for recording the number of writes to the pref file
   // that occur every kHistogramWriteReportIntervalInMins minutes.
   class COMPONENTS_PREFS_EXPORT WriteCountHistogram {
    public:
     static const int32_t kHistogramWriteReportIntervalMins;
 
     WriteCountHistogram(const base::TimeDelta& commit_interval,
@@ skipping 41 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(base::JsonPrefStoreTest,
                            WriteCountHistogramTestBasic);
   FRIEND_TEST_ALL_PREFIXES(base::JsonPrefStoreTest,
                            WriteCountHistogramTestSinglePeriod);
   FRIEND_TEST_ALL_PREFIXES(base::JsonPrefStoreTest,
                            WriteCountHistogramTestMultiplePeriods);
   FRIEND_TEST_ALL_PREFIXES(base::JsonPrefStoreTest,
                            WriteCountHistogramTestPeriodWithGaps);
   friend class base::JsonPrefStoreCallbackTest;
   friend class base::JsonPrefStoreLossyWriteTest;
+  friend class base::WriteCallbacksObserver;
 
   ~JsonPrefStore() override;
 
   // If |write_success| is true, runs |on_next_successful_write_|.
   // Otherwise, re-registers |on_next_successful_write_|.
   void RunOrScheduleNextSuccessfulWriteCallback(bool write_success);
 
   // Handles the result of a write with result |write_success|. Runs
   // |on_next_write| callback on the current thread and posts
   // |RunOrScheduleNextSuccessfulWriteCallback| on |reply_task_runner|.
   static void PostWriteCallback(
       const base::Callback<void(bool success)>& on_next_write_reply,
       const base::Callback<void(bool success)>& on_next_write_callback,
       scoped_refptr<base::SequencedTaskRunner> reply_task_runner,
       bool write_success);
 
+  // Registers the |callbacks| pair to be called once synchronously before and
+  // after, respectively, the next write event of |writer_|.
+  // Both callbacks must be thread-safe.
+  void RegisterOnNextWriteSynchronousCallbacks(OnWriteCallbackPair callbacks);
+
   // This method is called after the JSON file has been read.  It then hands
   // |value| (or an empty dictionary in some read error cases) to the
   // |pref_filter| if one is set. It also gives a callback pointing at
   // FinalizeFileRead() to that |pref_filter_| which is then responsible for
   // invoking it when done. If there is no |pref_filter_|, FinalizeFileRead()
   // is invoked directly.
   void OnFileRead(std::unique_ptr<ReadResult> read_result);
 
   // ImportantFileWriter::DataSerializer overrides:
   bool SerializeData(std::string* output) override;
@@ skipping 30 matching lines @@
   std::unique_ptr<ReadErrorDelegate> error_delegate_;
 
   bool initialized_;
   bool filtering_in_progress_;
   bool pending_lossy_write_;
   PrefReadError read_error_;
 
   std::set<std::string> keys_need_empty_value_;
 
   bool has_pending_successful_write_reply_;
-  bool has_pending_write_callback_;
+  bool has_pending_write_callbacks_;
   base::Closure on_next_successful_write_reply_;
 
   WriteCountHistogram write_count_histogram_;
 
   DISALLOW_COPY_AND_ASSIGN(JsonPrefStore);
 };
 
 #endif  // COMPONENTS_PREFS_JSON_PREF_STORE_H_