Allow ImportantFileWriter to take in a pre-write callback.

components/prefs/json_pref_store_unittest.cc

 // 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.
 
 #include "components/prefs/json_pref_store.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 51 matching lines @@
 void SetCurrentTimeInMinutes(double minutes, base::SimpleTestClock* clock) {
   const int32_t kBaseTimeMins = 100;
   clock->SetNow(base::Time::FromDoubleT((kBaseTimeMins + minutes) * 60));
 }
 
 // A PrefFilter that will intercept all calls to FilterOnLoad() and hold on
 // to the |prefs| until explicitly asked to release them.
 class InterceptingPrefFilter : public PrefFilter {
  public:
   InterceptingPrefFilter();
+  InterceptingPrefFilter(OnWriteCallbackPair callback_pair);
   ~InterceptingPrefFilter() override;
 
   // PrefFilter implementation:
   void FilterOnLoad(
       const PostFilterOnLoadCallback& post_filter_on_load_callback,
       std::unique_ptr<base::DictionaryValue> pref_store_contents) override;
   void FilterUpdate(const std::string& path) override {}
-  void FilterSerializeData(
-      base::DictionaryValue* pref_store_contents) override {}
+  OnWriteCallbackPair FilterSerializeData(
+      base::DictionaryValue* pref_store_contents) override {
+    return on_write_callback_pair_;
+  }
 
   bool has_intercepted_prefs() const { return intercepted_prefs_ != NULL; }
 
   // Finalize an intercepted read, handing |intercepted_prefs_| back to its
   // JsonPrefStore.
   void ReleasePrefs();
 
  private:
   PostFilterOnLoadCallback post_filter_on_load_callback_;
   std::unique_ptr<base::DictionaryValue> intercepted_prefs_;
+  OnWriteCallbackPair on_write_callback_pair_;
 
   DISALLOW_COPY_AND_ASSIGN(InterceptingPrefFilter);
 };
 
 InterceptingPrefFilter::InterceptingPrefFilter() {}
+
+InterceptingPrefFilter::InterceptingPrefFilter(
+    OnWriteCallbackPair callback_pair) {
+  on_write_callback_pair_ = callback_pair;
+}
+
 InterceptingPrefFilter::~InterceptingPrefFilter() {}
 
 void InterceptingPrefFilter::FilterOnLoad(
     const PostFilterOnLoadCallback& post_filter_on_load_callback,
     std::unique_ptr<base::DictionaryValue> pref_store_contents) {
   post_filter_on_load_callback_ = post_filter_on_load_callback;
   intercepted_prefs_ = std::move(pref_store_contents);
 }
 
 void InterceptingPrefFilter::ReleasePrefs() {
@@ skipping 893 matching lines @@
       base::Bind(&SuccessfulWriteReplyObserver::OnSuccessfulWrite,
                  base::Unretained(this)));
 }
 
 enum WriteCallbackObservationState {
   NOT_CALLED,
   CALLED_WITH_ERROR,
   CALLED_WITH_SUCCESS,
 };
 
-class WriteCallbackObserver {
+class WriteCallbacksObserver {
  public:
-  WriteCallbackObserver() = default;
+  WriteCallbacksObserver() = default;
 
   // Register OnWrite() to be called on the next write of |json_pref_store|.
   void ObserveNextWriteCallback(JsonPrefStore* json_pref_store);
 
-  // Returns true if a write was observed via OnWrite()
-  // and resets the observation state to false regardless.
-  WriteCallbackObservationState GetAndResetObservationState();
+  // Returns whether OnPreWrite() was called, and resets the observation state
+  // to false.
+  bool GetAndResetPreWriteObservationState();
 
-  void OnWrite(bool success) {
-    EXPECT_EQ(NOT_CALLED, observation_state_);
-    observation_state_ = success ? CALLED_WITH_SUCCESS : CALLED_WITH_ERROR;
+  // Returns the |WriteCallbackObservationState| which was observed, then resets
+  // it to |NOT_CALLED|.
+  WriteCallbackObservationState GetAndResetPostWriteObservationState();
+
+  JsonPrefStore::OnWriteCallbackPair GetCallbackPair() {
+    return std::make_pair(
+        base::Bind(&WriteCallbacksObserver::OnPreWrite, base::Unretained(this)),
+        base::Bind(&WriteCallbacksObserver::OnPostWrite,
+                   base::Unretained(this)));
+  }
+
+  void OnPreWrite() {
+    EXPECT_FALSE(pre_write_called_);
+    pre_write_called_ = true;
+  }
+
+  void OnPostWrite(bool success) {
+    EXPECT_EQ(NOT_CALLED, post_write_observation_state_);
+    post_write_observation_state_ =
+        success ? CALLED_WITH_SUCCESS : CALLED_WITH_ERROR;
   }
 
  private:
-  WriteCallbackObservationState observation_state_ = NOT_CALLED;
+  bool pre_write_called_ = false;
+  WriteCallbackObservationState post_write_observation_state_ = NOT_CALLED;
 
-  DISALLOW_COPY_AND_ASSIGN(WriteCallbackObserver);
+  DISALLOW_COPY_AND_ASSIGN(WriteCallbacksObserver);
 };
 
-void WriteCallbackObserver::ObserveNextWriteCallback(JsonPrefStore* writer) {
-  writer->RegisterOnNextWriteSynchronousCallback(
-      base::Bind(&WriteCallbackObserver::OnWrite, base::Unretained(this)));
+void WriteCallbacksObserver::ObserveNextWriteCallback(JsonPrefStore* writer) {
+  writer->RegisterOnNextWriteSynchronousCallbacks(GetCallbackPair());
+}
+
+bool WriteCallbacksObserver::GetAndResetPreWriteObservationState() {
+  bool observation_state = pre_write_called_;
+  pre_write_called_ = false;
+  return observation_state;
 }
 
 WriteCallbackObservationState
-WriteCallbackObserver::GetAndResetObservationState() {
-  WriteCallbackObservationState state = observation_state_;
-  observation_state_ = NOT_CALLED;
+WriteCallbacksObserver::GetAndResetPostWriteObservationState() {
+  WriteCallbackObservationState state = post_write_observation_state_;
+  pre_write_called_ = false;
+  post_write_observation_state_ = NOT_CALLED;
   return state;
 }
 
 class JsonPrefStoreCallbackTest : public JsonPrefStoreTest {
  public:
   JsonPrefStoreCallbackTest() = default;
 
  protected:
   void SetUp() override {
     JsonPrefStoreTest::SetUp();
     test_file_ = temp_dir_.path().AppendASCII("test.json");
   }
 
   scoped_refptr<JsonPrefStore> CreatePrefStore() {
     return new JsonPrefStore(test_file_, message_loop_.task_runner(),
                              std::unique_ptr<PrefFilter>());
   }
 
   // Return the ImportantFileWriter for a given JsonPrefStore.
   ImportantFileWriter* GetImportantFileWriter(JsonPrefStore* pref_store) {
     return &(pref_store->writer_);
   }
 
   void TriggerFakeWriteForCallback(JsonPrefStore* pref_store, bool success) {
     JsonPrefStore::PostWriteCallback(
         base::Bind(&JsonPrefStore::RunOrScheduleNextSuccessfulWriteCallback,
                    pref_store->AsWeakPtr()),
-        base::Bind(&WriteCallbackObserver::OnWrite,
+        base::Bind(&WriteCallbacksObserver::OnPostWrite,
                    base::Unretained(&write_callback_observer_)),
         base::SequencedTaskRunnerHandle::Get(), success);
   }
 
   SuccessfulWriteReplyObserver successful_write_reply_observer_;
-  WriteCallbackObserver write_callback_observer_;
+  WriteCallbacksObserver write_callback_observer_;
 
  private:
   base::FilePath test_file_;
 
   DISALLOW_COPY_AND_ASSIGN(JsonPrefStoreCallbackTest);
 };
 
-TEST_F(JsonPrefStoreCallbackTest, TestPostWriteCallback) {
+TEST_F(JsonPrefStoreCallbackTest, TestSerializeDataCallbacks) {
+  base::FilePath input_file = temp_dir_.GetPath().AppendASCII("write.json");
+  ASSERT_LT(0,
+            base::WriteFile(input_file, kReadJson, arraysize(kReadJson) - 1));
+
+  std::unique_ptr<InterceptingPrefFilter> intercepting_pref_filter(
+      new InterceptingPrefFilter(write_callback_observer_.GetCallbackPair()));
+  scoped_refptr<JsonPrefStore> pref_store =
+      new JsonPrefStore(input_file, message_loop_.task_runner(),
+                        std::move(intercepting_pref_filter));
+  ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get());
+
+  EXPECT_EQ(NOT_CALLED,
+            write_callback_observer_.GetAndResetPostWriteObservationState());
+  pref_store->SetValue("normal", base::MakeUnique<base::StringValue>("normal"),
+                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+  file_writer->DoScheduledWrite();
+
+  // The observer should not be invoked right away.
+  EXPECT_FALSE(write_callback_observer_.GetAndResetPreWriteObservationState());
+  EXPECT_EQ(NOT_CALLED,
+            write_callback_observer_.GetAndResetPostWriteObservationState());
+
+  RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(write_callback_observer_.GetAndResetPreWriteObservationState());
+  EXPECT_EQ(CALLED_WITH_SUCCESS,
+            write_callback_observer_.GetAndResetPostWriteObservationState());
+}
+
+TEST_F(JsonPrefStoreCallbackTest, TestPostWriteCallbacks) {
   scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore();
   ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get());
 
-  // Test RegisterOnNextWriteSynchronousCallback after
+  // Test RegisterOnNextWriteSynchronousCallbacks after
   // RegisterOnNextSuccessfulWriteReply.
   successful_write_reply_observer_.ObserveNextWriteCallback(pref_store.get());
   write_callback_observer_.ObserveNextWriteCallback(pref_store.get());
   file_writer->WriteNow(MakeUnique<std::string>("foo"));
   RunLoop().RunUntilIdle();
   EXPECT_TRUE(successful_write_reply_observer_.GetAndResetObservationState());
-  EXPECT_TRUE(write_callback_observer_.GetAndResetObservationState());
+  EXPECT_TRUE(write_callback_observer_.GetAndResetPreWriteObservationState());
+  EXPECT_EQ(CALLED_WITH_SUCCESS,
+            write_callback_observer_.GetAndResetPostWriteObservationState());
 
   // Test RegisterOnNextSuccessfulWriteReply after
-  // RegisterOnNextWriteSynchronousCallback.
+  // RegisterOnNextWriteSynchronousCallbacks.
   successful_write_reply_observer_.ObserveNextWriteCallback(pref_store.get());
   write_callback_observer_.ObserveNextWriteCallback(pref_store.get());
   file_writer->WriteNow(MakeUnique<std::string>("foo"));
   RunLoop().RunUntilIdle();
   EXPECT_TRUE(successful_write_reply_observer_.GetAndResetObservationState());
-  EXPECT_TRUE(write_callback_observer_.GetAndResetObservationState());
+  EXPECT_TRUE(write_callback_observer_.GetAndResetPreWriteObservationState());
+  EXPECT_EQ(CALLED_WITH_SUCCESS,
+            write_callback_observer_.GetAndResetPostWriteObservationState());
 
   // Test RegisterOnNextSuccessfulWriteReply only.
   successful_write_reply_observer_.ObserveNextWriteCallback(pref_store.get());
   file_writer->WriteNow(MakeUnique<std::string>("foo"));
   RunLoop().RunUntilIdle();
   EXPECT_TRUE(successful_write_reply_observer_.GetAndResetObservationState());
-  EXPECT_FALSE(write_callback_observer_.GetAndResetObservationState());
+  EXPECT_FALSE(write_callback_observer_.GetAndResetPreWriteObservationState());
+  EXPECT_EQ(NOT_CALLED,
+            write_callback_observer_.GetAndResetPostWriteObservationState());
 
-  // Test RegisterOnNextWriteSynchronousCallback only.
+  // Test RegisterOnNextWriteSynchronousCallbacks only.
   write_callback_observer_.ObserveNextWriteCallback(pref_store.get());
   file_writer->WriteNow(MakeUnique<std::string>("foo"));
   RunLoop().RunUntilIdle();
   EXPECT_FALSE(successful_write_reply_observer_.GetAndResetObservationState());
-  EXPECT_TRUE(write_callback_observer_.GetAndResetObservationState());
+  EXPECT_TRUE(write_callback_observer_.GetAndResetPreWriteObservationState());
+  EXPECT_EQ(CALLED_WITH_SUCCESS,
+            write_callback_observer_.GetAndResetPostWriteObservationState());
 }
 
-TEST_F(JsonPrefStoreCallbackTest, TestPostWriteCallbackWithFakeFailure) {
+TEST_F(JsonPrefStoreCallbackTest, TestPostWriteCallbacksWithFakeFailure) {
   scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore();
 
   // Confirm that the observers are invoked.
   successful_write_reply_observer_.ObserveNextWriteCallback(pref_store.get());
   TriggerFakeWriteForCallback(pref_store.get(), true);
   RunLoop().RunUntilIdle();
   EXPECT_TRUE(successful_write_reply_observer_.GetAndResetObservationState());
   EXPECT_EQ(CALLED_WITH_SUCCESS,
-            write_callback_observer_.GetAndResetObservationState());
+            write_callback_observer_.GetAndResetPostWriteObservationState());
 
   // Confirm that the observation states were reset.
   EXPECT_FALSE(successful_write_reply_observer_.GetAndResetObservationState());
-  EXPECT_EQ(NOT_CALLED, write_callback_observer_.GetAndResetObservationState());
+  EXPECT_EQ(NOT_CALLED,
+            write_callback_observer_.GetAndResetPostWriteObservationState());
 
   // Confirm that re-installing the observers works for another write.
   successful_write_reply_observer_.ObserveNextWriteCallback(pref_store.get());
   TriggerFakeWriteForCallback(pref_store.get(), true);
   RunLoop().RunUntilIdle();
   EXPECT_TRUE(successful_write_reply_observer_.GetAndResetObservationState());
   EXPECT_EQ(CALLED_WITH_SUCCESS,
-            write_callback_observer_.GetAndResetObservationState());
+            write_callback_observer_.GetAndResetPostWriteObservationState());
 
   // Confirm that the successful observer is not invoked by an unsuccessful
   // write, and that the synchronous observer is invoked.
   successful_write_reply_observer_.ObserveNextWriteCallback(pref_store.get());
   TriggerFakeWriteForCallback(pref_store.get(), false);
   RunLoop().RunUntilIdle();
   EXPECT_FALSE(successful_write_reply_observer_.GetAndResetObservationState());
   EXPECT_EQ(CALLED_WITH_ERROR,
-            write_callback_observer_.GetAndResetObservationState());
+            write_callback_observer_.GetAndResetPostWriteObservationState());
 
   // Do a real write, and confirm that the successful observer was invoked after
   // being set by |PostWriteCallback| by the last TriggerFakeWriteCallback.
   ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get());
   file_writer->WriteNow(MakeUnique<std::string>("foo"));
   RunLoop().RunUntilIdle();
   EXPECT_TRUE(successful_write_reply_observer_.GetAndResetObservationState());
-  EXPECT_EQ(NOT_CALLED, write_callback_observer_.GetAndResetObservationState());
+  EXPECT_EQ(NOT_CALLED,
+            write_callback_observer_.GetAndResetPostWriteObservationState());
 }
 
-TEST_F(JsonPrefStoreCallbackTest, TestPostWriteCallbackDuringProfileDeath) {
+TEST_F(JsonPrefStoreCallbackTest, TestPostWriteCallbacksDuringProfileDeath) {
   // Create a JsonPrefStore and attach observers to it, then delete it by making
   // it go out of scope to simulate profile switch or Chrome shutdown.
   {
     scoped_refptr<JsonPrefStore> soon_out_of_scope_pref_store =
         CreatePrefStore();
     ImportantFileWriter* file_writer =
         GetImportantFileWriter(soon_out_of_scope_pref_store.get());
     successful_write_reply_observer_.ObserveNextWriteCallback(
         soon_out_of_scope_pref_store.get());
     write_callback_observer_.ObserveNextWriteCallback(
         soon_out_of_scope_pref_store.get());
     file_writer->WriteNow(MakeUnique<std::string>("foo"));
   }
   RunLoop().RunUntilIdle();
   EXPECT_FALSE(successful_write_reply_observer_.GetAndResetObservationState());
+  EXPECT_TRUE(write_callback_observer_.GetAndResetPreWriteObservationState());
   EXPECT_EQ(CALLED_WITH_SUCCESS,
-            write_callback_observer_.GetAndResetObservationState());
+            write_callback_observer_.GetAndResetPostWriteObservationState());
 }
 
 }  // namespace base