Avi Drissman | 8ba1bad | 2022-09-13 19:22:36 | [diff] [blame] | 1 | // Copyright 2012 The Chromium Authors |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
brettw | f00b9b4 | 2016-02-01 22:11:38 | [diff] [blame] | 5 | #include "components/prefs/json_pref_store.h" |
tfarina@chromium.org | 00c8782 | 2012-11-27 19:09:17 | [diff] [blame] | 6 | |
avi | 9ef8bb0 | 2015-12-24 05:29:36 | [diff] [blame] | 7 | #include <stdint.h> |
| 8 | |
dcheng | 5f043bc | 2016-04-22 19:09:06 | [diff] [blame] | 9 | #include <memory> |
danakj | 0c8d4aa | 2015-11-25 05:29:58 | [diff] [blame] | 10 | #include <utility> |
| 11 | |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 12 | #include "base/compiler_specific.h" |
brettw@chromium.org | e3177dd5 | 2014-08-13 20:22:14 | [diff] [blame] | 13 | #include "base/files/file_util.h" |
brettw@chromium.org | ea1a3f6 | 2012-11-16 20:34:23 | [diff] [blame] | 14 | #include "base/files/scoped_temp_dir.h" |
Avi Drissman | 12be031 | 2023-01-11 09:16:09 | [diff] [blame] | 15 | #include "base/functional/bind.h" |
| 16 | #include "base/functional/callback.h" |
skyostil | 054861d | 2015-04-30 19:06:15 | [diff] [blame] | 17 | #include "base/location.h" |
levin@chromium.org | 3b63f8f4 | 2011-03-28 01:54:15 | [diff] [blame] | 18 | #include "base/memory/ref_counted.h" |
raymes | bfb910a | 2015-04-29 07:43:09 | [diff] [blame] | 19 | #include "base/metrics/histogram_samples.h" |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 20 | #include "base/path_service.h" |
tfarina@chromium.org | f7b98b3 | 2013-02-05 08:14:15 | [diff] [blame] | 21 | #include "base/run_loop.h" |
brettw@chromium.org | dfa049e | 2013-02-07 02:57:22 | [diff] [blame] | 22 | #include "base/strings/string_number_conversions.h" |
avi@chromium.org | d529cb0 | 2013-06-10 19:06:57 | [diff] [blame] | 23 | #include "base/strings/string_util.h" |
avi@chromium.org | a4ea1f1 | 2013-06-07 18:37:07 | [diff] [blame] | 24 | #include "base/strings/utf_string_conversions.h" |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 25 | #include "base/synchronization/waitable_event.h" |
Sean Maher | 52fa5a7 | 2022-11-14 15:53:25 | [diff] [blame] | 26 | #include "base/task/sequenced_task_runner.h" |
Patrick Monette | 643cdf6 | 2021-10-15 19:13:42 | [diff] [blame] | 27 | #include "base/task/single_thread_task_runner.h" |
Devlin Cronin | 69228f4 | 2018-06-01 17:25:10 | [diff] [blame] | 28 | #include "base/test/metrics/histogram_tester.h" |
Patrick Noland | c4817974 | 2022-11-10 20:55:43 | [diff] [blame] | 29 | #include "base/test/scoped_feature_list.h" |
Gabriel Charette | c710874 | 2019-08-23 03:31:40 | [diff] [blame] | 30 | #include "base/test/task_environment.h" |
brettw@chromium.org | 34b9963 | 2011-01-01 01:01:06 | [diff] [blame] | 31 | #include "base/threading/thread.h" |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 32 | #include "base/values.h" |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 33 | #include "components/prefs/persistent_pref_store_unittest.h" |
brettw | f00b9b4 | 2016-02-01 22:11:38 | [diff] [blame] | 34 | #include "components/prefs/pref_filter.h" |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 35 | #include "testing/gmock/include/gmock/gmock.h" |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 36 | #include "testing/gtest/include/gtest/gtest.h" |
| 37 | |
tfarina@chromium.org | 7e3ec42c | 2012-12-16 05:13:21 | [diff] [blame] | 38 | namespace base { |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 39 | namespace { |
| 40 | |
tfarina@chromium.org | 5bfdcfd | 2012-11-22 22:08:24 | [diff] [blame] | 41 | const char kHomePage[] = "homepage"; |
| 42 | |
brettw | 58cd1f1 | 2016-01-30 05:56:05 | [diff] [blame] | 43 | const char kReadJson[] = |
| 44 | "{\n" |
| 45 | " \"homepage\": \"http://www.cnn.com\",\n" |
| 46 | " \"some_directory\": \"/usr/local/\",\n" |
| 47 | " \"tabs\": {\n" |
| 48 | " \"new_windows_in_tabs\": true,\n" |
| 49 | " \"max_tabs\": 20\n" |
| 50 | " }\n" |
| 51 | "}"; |
| 52 | |
| 53 | const char kInvalidJson[] = "!@#$%^&"; |
| 54 | |
| 55 | // Expected output for tests using RunBasicJsonPrefStoreTest(). |
| 56 | const char kWriteGolden[] = |
| 57 | "{\"homepage\":\"http://www.cnn.com\"," |
| 58 | "\"long_int\":{\"pref\":\"214748364842\"}," |
| 59 | "\"some_directory\":\"/usr/sbin/\"," |
| 60 | "\"tabs\":{\"max_tabs\":10,\"new_windows_in_tabs\":false}}"; |
| 61 | |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 62 | // A PrefFilter that will intercept all calls to FilterOnLoad() and hold on |
| 63 | // to the |prefs| until explicitly asked to release them. |
| 64 | class InterceptingPrefFilter : public PrefFilter { |
| 65 | public: |
| 66 | InterceptingPrefFilter(); |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 67 | InterceptingPrefFilter(OnWriteCallbackPair callback_pair); |
Peter Boström | 09c0182 | 2021-09-20 22:43:27 | [diff] [blame] | 68 | |
| 69 | InterceptingPrefFilter(const InterceptingPrefFilter&) = delete; |
| 70 | InterceptingPrefFilter& operator=(const InterceptingPrefFilter&) = delete; |
| 71 | |
dcheng | 5648818 | 2014-10-21 10:54:51 | [diff] [blame] | 72 | ~InterceptingPrefFilter() override; |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 73 | |
| 74 | // PrefFilter implementation: |
Nan Lin | d043237 | 2022-12-16 21:58:24 | [diff] [blame] | 75 | void FilterOnLoad(PostFilterOnLoadCallback post_filter_on_load_callback, |
| 76 | base::Value::Dict pref_store_contents) override; |
dcheng | 5648818 | 2014-10-21 10:54:51 | [diff] [blame] | 77 | void FilterUpdate(const std::string& path) override {} |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 78 | OnWriteCallbackPair FilterSerializeData( |
Nan Lin | d043237 | 2022-12-16 21:58:24 | [diff] [blame] | 79 | base::Value::Dict& pref_store_contents) override { |
Sylvain Defresne | 8812fcda | 2019-10-07 21:45:00 | [diff] [blame] | 80 | return std::move(on_write_callback_pair_); |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 81 | } |
proberge | 45e34728 | 2017-08-16 21:24:05 | [diff] [blame] | 82 | void OnStoreDeletionFromDisk() override {} |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 83 | |
Ivan Kotenkov | 75b1c3a | 2017-10-24 14:47:24 | [diff] [blame] | 84 | bool has_intercepted_prefs() const { return intercepted_prefs_ != nullptr; } |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 85 | |
gab@chromium.org | cfcf0e5 | 2014-06-20 18:29:47 | [diff] [blame] | 86 | // Finalize an intercepted read, handing |intercepted_prefs_| back to its |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 87 | // JsonPrefStore. |
| 88 | void ReleasePrefs(); |
| 89 | |
| 90 | private: |
| 91 | PostFilterOnLoadCallback post_filter_on_load_callback_; |
Nan Lin | d043237 | 2022-12-16 21:58:24 | [diff] [blame] | 92 | std::unique_ptr<base::Value::Dict> intercepted_prefs_; |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 93 | OnWriteCallbackPair on_write_callback_pair_; |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 94 | }; |
| 95 | |
| 96 | InterceptingPrefFilter::InterceptingPrefFilter() {} |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 97 | |
| 98 | InterceptingPrefFilter::InterceptingPrefFilter( |
| 99 | OnWriteCallbackPair callback_pair) { |
Sylvain Defresne | 8812fcda | 2019-10-07 21:45:00 | [diff] [blame] | 100 | on_write_callback_pair_ = std::move(callback_pair); |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 101 | } |
| 102 | |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 103 | InterceptingPrefFilter::~InterceptingPrefFilter() {} |
| 104 | |
| 105 | void InterceptingPrefFilter::FilterOnLoad( |
Sylvain Defresne | d17a425 | 2019-10-11 15:50:24 | [diff] [blame] | 106 | PostFilterOnLoadCallback post_filter_on_load_callback, |
Nan Lin | d043237 | 2022-12-16 21:58:24 | [diff] [blame] | 107 | base::Value::Dict pref_store_contents) { |
Sylvain Defresne | d17a425 | 2019-10-11 15:50:24 | [diff] [blame] | 108 | post_filter_on_load_callback_ = std::move(post_filter_on_load_callback); |
Nan Lin | d043237 | 2022-12-16 21:58:24 | [diff] [blame] | 109 | intercepted_prefs_ = |
| 110 | std::make_unique<base::Value::Dict>(std::move(pref_store_contents)); |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 111 | } |
| 112 | |
| 113 | void InterceptingPrefFilter::ReleasePrefs() { |
| 114 | EXPECT_FALSE(post_filter_on_load_callback_.is_null()); |
Nan Lin | d043237 | 2022-12-16 21:58:24 | [diff] [blame] | 115 | std::unique_ptr<base::Value::Dict> prefs = std::move(intercepted_prefs_); |
| 116 | std::move(post_filter_on_load_callback_).Run(std::move(*prefs), false); |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 117 | } |
| 118 | |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 119 | class MockPrefStoreObserver : public PrefStore::Observer { |
| 120 | public: |
| 121 | MOCK_METHOD1(OnPrefValueChanged, void (const std::string&)); |
| 122 | MOCK_METHOD1(OnInitializationCompleted, void (bool)); |
| 123 | }; |
| 124 | |
| 125 | class MockReadErrorDelegate : public PersistentPrefStore::ReadErrorDelegate { |
| 126 | public: |
| 127 | MOCK_METHOD1(OnError, void(PersistentPrefStore::PrefReadError)); |
| 128 | }; |
| 129 | |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 130 | enum class CommitPendingWriteMode { |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 131 | // Basic mode. |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 132 | WITHOUT_CALLBACK, |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 133 | // With reply callback. |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 134 | WITH_CALLBACK, |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 135 | // With synchronous notify callback (synchronous after the write -- shouldn't |
| 136 | // require pumping messages to observe). |
| 137 | WITH_SYNCHRONOUS_CALLBACK, |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 138 | }; |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 139 | |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 140 | base::test::TaskEnvironment::ThreadPoolExecutionMode GetExecutionMode( |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 141 | CommitPendingWriteMode commit_mode) { |
| 142 | switch (commit_mode) { |
| 143 | case CommitPendingWriteMode::WITHOUT_CALLBACK: |
Roland Bock | 17c8f5f6 | 2022-01-04 15:25:54 | [diff] [blame] | 144 | [[fallthrough]]; |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 145 | case CommitPendingWriteMode::WITH_CALLBACK: |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 146 | return base::test::TaskEnvironment::ThreadPoolExecutionMode::QUEUED; |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 147 | case CommitPendingWriteMode::WITH_SYNCHRONOUS_CALLBACK: |
| 148 | // Synchronous callbacks require async tasks to run on their own. |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 149 | return base::test::TaskEnvironment::ThreadPoolExecutionMode::ASYNC; |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 150 | } |
| 151 | } |
| 152 | |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 153 | void CommitPendingWrite(JsonPrefStore* pref_store, |
| 154 | CommitPendingWriteMode commit_pending_write_mode, |
| 155 | base::test::TaskEnvironment* task_environment) { |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 156 | switch (commit_pending_write_mode) { |
| 157 | case CommitPendingWriteMode::WITHOUT_CALLBACK: { |
| 158 | pref_store->CommitPendingWrite(); |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 159 | task_environment->RunUntilIdle(); |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 160 | break; |
| 161 | } |
| 162 | case CommitPendingWriteMode::WITH_CALLBACK: { |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 163 | TestCommitPendingWriteWithCallback(pref_store, task_environment); |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 164 | break; |
| 165 | } |
| 166 | case CommitPendingWriteMode::WITH_SYNCHRONOUS_CALLBACK: { |
| 167 | base::WaitableEvent written; |
| 168 | pref_store->CommitPendingWrite( |
| 169 | base::OnceClosure(), |
| 170 | base::BindOnce(&base::WaitableEvent::Signal, Unretained(&written))); |
| 171 | written.Wait(); |
| 172 | break; |
| 173 | } |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 174 | } |
| 175 | } |
| 176 | |
| 177 | class JsonPrefStoreTest |
Marc Treib | 85b56d54 | 2023-06-12 10:15:49 | [diff] [blame] | 178 | : public testing::TestWithParam<CommitPendingWriteMode> { |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 179 | public: |
Francois Doray | 5f54795 | 2017-07-25 21:02:05 | [diff] [blame] | 180 | JsonPrefStoreTest() |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 181 | : task_environment_(base::test::TaskEnvironment::MainThreadType::DEFAULT, |
Marc Treib | 85b56d54 | 2023-06-12 10:15:49 | [diff] [blame] | 182 | GetExecutionMode(GetParam())) {} |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 183 | |
Peter Boström | 9f667c38 | 2021-10-01 20:09:31 | [diff] [blame] | 184 | JsonPrefStoreTest(const JsonPrefStoreTest&) = delete; |
| 185 | JsonPrefStoreTest& operator=(const JsonPrefStoreTest&) = delete; |
| 186 | |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 187 | protected: |
dcheng | 8aef3761 | 2014-12-23 02:56:47 | [diff] [blame] | 188 | void SetUp() override { |
Marc Treib | 85b56d54 | 2023-06-12 10:15:49 | [diff] [blame] | 189 | commit_pending_write_mode_ = GetParam(); |
Patrick Noland | c4817974 | 2022-11-10 20:55:43 | [diff] [blame] | 190 | |
mkwst@chromium.org | 3a305db | 2011-04-12 13:40:53 | [diff] [blame] | 191 | ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 192 | } |
| 193 | |
mkwst@chromium.org | 3a305db | 2011-04-12 13:40:53 | [diff] [blame] | 194 | // The path to temporary directory used to contain the test operations. |
brettw@chromium.org | ea1a3f6 | 2012-11-16 20:34:23 | [diff] [blame] | 195 | base::ScopedTempDir temp_dir_; |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 196 | |
Greg Thompson | 191ab5f | 2019-10-31 14:07:45 | [diff] [blame] | 197 | base::test::TaskEnvironment task_environment_; |
Patrick Noland | c4817974 | 2022-11-10 20:55:43 | [diff] [blame] | 198 | CommitPendingWriteMode commit_pending_write_mode_; |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 199 | }; |
| 200 | |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 201 | } // namespace |
| 202 | |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 203 | // Test fallback behavior for a nonexistent file. |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 204 | TEST_P(JsonPrefStoreTest, NonExistentFile) { |
vabr | 8023d87 | 2016-09-15 08:12:22 | [diff] [blame] | 205 | base::FilePath bogus_input_file = temp_dir_.GetPath().AppendASCII("read.txt"); |
brettw@chromium.org | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 206 | ASSERT_FALSE(PathExists(bogus_input_file)); |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 207 | auto pref_store = base::MakeRefCounted<JsonPrefStore>(bogus_input_file); |
mnissler@chromium.org | f2d1f61 | 2010-12-09 15:10:17 | [diff] [blame] | 208 | EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE, |
battre@chromium.org | 9a8c402 | 2011-01-25 14:25:33 | [diff] [blame] | 209 | pref_store->ReadPrefs()); |
| 210 | EXPECT_FALSE(pref_store->ReadOnly()); |
Dominic Battre | c7911fe | 2020-11-26 21:13:18 | [diff] [blame] | 211 | EXPECT_EQ(0u, pref_store->get_writer().previous_data_size()); |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 212 | } |
| 213 | |
| 214 | // Test fallback behavior for an invalid file. |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 215 | TEST_P(JsonPrefStoreTest, InvalidFile) { |
vabr | 8023d87 | 2016-09-15 08:12:22 | [diff] [blame] | 216 | base::FilePath invalid_file = temp_dir_.GetPath().AppendASCII("invalid.json"); |
Claudio DeSouza | c3e8508 | 2023-02-27 16:07:15 | [diff] [blame] | 217 | ASSERT_TRUE(base::WriteFile(invalid_file, kInvalidJson)); |
brettw | 58cd1f1 | 2016-01-30 05:56:05 | [diff] [blame] | 218 | |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 219 | auto pref_store = base::MakeRefCounted<JsonPrefStore>(invalid_file); |
mnissler@chromium.org | f2d1f61 | 2010-12-09 15:10:17 | [diff] [blame] | 220 | EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_JSON_PARSE, |
battre@chromium.org | 9a8c402 | 2011-01-25 14:25:33 | [diff] [blame] | 221 | pref_store->ReadPrefs()); |
| 222 | EXPECT_FALSE(pref_store->ReadOnly()); |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 223 | |
| 224 | // The file should have been moved aside. |
brettw@chromium.org | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 225 | EXPECT_FALSE(PathExists(invalid_file)); |
vabr | 8023d87 | 2016-09-15 08:12:22 | [diff] [blame] | 226 | base::FilePath moved_aside = temp_dir_.GetPath().AppendASCII("invalid.bad"); |
brettw@chromium.org | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 227 | EXPECT_TRUE(PathExists(moved_aside)); |
brettw | 58cd1f1 | 2016-01-30 05:56:05 | [diff] [blame] | 228 | |
| 229 | std::string moved_aside_contents; |
| 230 | ASSERT_TRUE(base::ReadFileToString(moved_aside, &moved_aside_contents)); |
| 231 | EXPECT_EQ(kInvalidJson, moved_aside_contents); |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 232 | } |
| 233 | |
brettw | 58cd1f1 | 2016-01-30 05:56:05 | [diff] [blame] | 234 | // This function is used to avoid code duplication while testing synchronous |
| 235 | // and asynchronous version of the JsonPrefStore loading. It validates that the |
| 236 | // given output file's contents matches kWriteGolden. |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 237 | void RunBasicJsonPrefStoreTest(JsonPrefStore* pref_store, |
| 238 | const base::FilePath& output_file, |
| 239 | CommitPendingWriteMode commit_pending_write_mode, |
| 240 | base::test::TaskEnvironment* task_environment) { |
viettrungluu@chromium.org | 57ecc4b | 2010-08-11 03:02:51 | [diff] [blame] | 241 | const char kNewWindowsInTabs[] = "tabs.new_windows_in_tabs"; |
| 242 | const char kMaxTabs[] = "tabs.max_tabs"; |
| 243 | const char kLongIntPref[] = "long_int.pref"; |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 244 | |
viettrungluu@chromium.org | 57ecc4b | 2010-08-11 03:02:51 | [diff] [blame] | 245 | std::string cnn("http://www.cnn.com"); |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 246 | |
battre@chromium.org | 68bf41a | 2011-03-25 16:38:31 | [diff] [blame] | 247 | const Value* actual; |
tfarina@chromium.org | 5bfdcfd | 2012-11-22 22:08:24 | [diff] [blame] | 248 | EXPECT_TRUE(pref_store->GetValue(kHomePage, &actual)); |
Ayu Ishii | e48b794 | 2021-05-12 18:03:18 | [diff] [blame] | 249 | EXPECT_TRUE(actual->is_string()); |
| 250 | EXPECT_EQ(cnn, actual->GetString()); |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 251 | |
viettrungluu@chromium.org | 57ecc4b | 2010-08-11 03:02:51 | [diff] [blame] | 252 | const char kSomeDirectory[] = "some_directory"; |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 253 | |
bauerb@chromium.org | 892f1d6 | 2012-11-08 18:24:34 | [diff] [blame] | 254 | EXPECT_TRUE(pref_store->GetValue(kSomeDirectory, &actual)); |
Ayu Ishii | e48b794 | 2021-05-12 18:03:18 | [diff] [blame] | 255 | EXPECT_TRUE(actual->is_string()); |
| 256 | EXPECT_EQ("/usr/local/", actual->GetString()); |
brettw@chromium.org | 023ad6ab | 2013-02-17 05:07:23 | [diff] [blame] | 257 | base::FilePath some_path(FILE_PATH_LITERAL("/usr/sbin/")); |
mnissler@chromium.org | f2d1f61 | 2010-12-09 15:10:17 | [diff] [blame] | 258 | |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 259 | pref_store->SetValue(kSomeDirectory, Value(some_path.AsUTF8Unsafe()), |
raymes | 76de1af | 2015-05-06 03:22:21 | [diff] [blame] | 260 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
bauerb@chromium.org | 892f1d6 | 2012-11-08 18:24:34 | [diff] [blame] | 261 | EXPECT_TRUE(pref_store->GetValue(kSomeDirectory, &actual)); |
Ayu Ishii | e48b794 | 2021-05-12 18:03:18 | [diff] [blame] | 262 | EXPECT_TRUE(actual->is_string()); |
| 263 | EXPECT_EQ(some_path.AsUTF8Unsafe(), actual->GetString()); |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 264 | |
| 265 | // Test reading some other data types from sub-dictionaries. |
bauerb@chromium.org | 892f1d6 | 2012-11-08 18:24:34 | [diff] [blame] | 266 | EXPECT_TRUE(pref_store->GetValue(kNewWindowsInTabs, &actual)); |
Ayu Ishii | e48b794 | 2021-05-12 18:03:18 | [diff] [blame] | 267 | EXPECT_TRUE(actual->is_bool()); |
| 268 | EXPECT_TRUE(actual->GetBool()); |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 269 | |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 270 | pref_store->SetValue(kNewWindowsInTabs, Value(false), |
raymes | 76de1af | 2015-05-06 03:22:21 | [diff] [blame] | 271 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
bauerb@chromium.org | 892f1d6 | 2012-11-08 18:24:34 | [diff] [blame] | 272 | EXPECT_TRUE(pref_store->GetValue(kNewWindowsInTabs, &actual)); |
Ayu Ishii | e48b794 | 2021-05-12 18:03:18 | [diff] [blame] | 273 | EXPECT_TRUE(actual->is_bool()); |
| 274 | EXPECT_FALSE(actual->GetBool()); |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 275 | |
bauerb@chromium.org | 892f1d6 | 2012-11-08 18:24:34 | [diff] [blame] | 276 | EXPECT_TRUE(pref_store->GetValue(kMaxTabs, &actual)); |
Minoru Chikamune | 8dcb6e9 | 2021-04-17 00:54:26 | [diff] [blame] | 277 | ASSERT_TRUE(actual->is_int()); |
| 278 | EXPECT_EQ(20, actual->GetInt()); |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 279 | pref_store->SetValue(kMaxTabs, Value(10), |
raymes | 76de1af | 2015-05-06 03:22:21 | [diff] [blame] | 280 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
bauerb@chromium.org | 892f1d6 | 2012-11-08 18:24:34 | [diff] [blame] | 281 | EXPECT_TRUE(pref_store->GetValue(kMaxTabs, &actual)); |
Minoru Chikamune | 8dcb6e9 | 2021-04-17 00:54:26 | [diff] [blame] | 282 | ASSERT_TRUE(actual->is_int()); |
| 283 | EXPECT_EQ(10, actual->GetInt()); |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 284 | |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 285 | pref_store->SetValue(kLongIntPref, |
| 286 | Value(base::NumberToString(214748364842LL)), |
| 287 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
bauerb@chromium.org | 892f1d6 | 2012-11-08 18:24:34 | [diff] [blame] | 288 | EXPECT_TRUE(pref_store->GetValue(kLongIntPref, &actual)); |
Ayu Ishii | e48b794 | 2021-05-12 18:03:18 | [diff] [blame] | 289 | EXPECT_TRUE(actual->is_string()); |
avi | 9ef8bb0 | 2015-12-24 05:29:36 | [diff] [blame] | 290 | int64_t value; |
Ayu Ishii | e48b794 | 2021-05-12 18:03:18 | [diff] [blame] | 291 | base::StringToInt64(actual->GetString(), &value); |
brettw@chromium.org | e83326f | 2010-07-31 17:29:25 | [diff] [blame] | 292 | EXPECT_EQ(214748364842LL, value); |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 293 | |
| 294 | // Serialize and compare to expected output. |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 295 | CommitPendingWrite(pref_store, commit_pending_write_mode, task_environment); |
brettw | 58cd1f1 | 2016-01-30 05:56:05 | [diff] [blame] | 296 | |
| 297 | std::string output_contents; |
| 298 | ASSERT_TRUE(base::ReadFileToString(output_file, &output_contents)); |
| 299 | EXPECT_EQ(kWriteGolden, output_contents); |
Lei Zhang | e6e8c132 | 2020-07-08 20:04:12 | [diff] [blame] | 300 | ASSERT_TRUE(base::DeleteFile(output_file)); |
bauerb@chromium.org | 277404c2 | 2010-04-22 13:09:45 | [diff] [blame] | 301 | } |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 302 | |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 303 | TEST_P(JsonPrefStoreTest, Basic) { |
vabr | 8023d87 | 2016-09-15 08:12:22 | [diff] [blame] | 304 | base::FilePath input_file = temp_dir_.GetPath().AppendASCII("write.json"); |
Claudio DeSouza | c3e8508 | 2023-02-27 16:07:15 | [diff] [blame] | 305 | ASSERT_TRUE(base::WriteFile(input_file, kReadJson)); |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 306 | |
| 307 | // Test that the persistent value can be loaded. |
brettw@chromium.org | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 308 | ASSERT_TRUE(PathExists(input_file)); |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 309 | auto pref_store = base::MakeRefCounted<JsonPrefStore>(input_file); |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 310 | ASSERT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE, pref_store->ReadPrefs()); |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 311 | EXPECT_FALSE(pref_store->ReadOnly()); |
| 312 | EXPECT_TRUE(pref_store->IsInitializationComplete()); |
Dominic Battre | c7911fe | 2020-11-26 21:13:18 | [diff] [blame] | 313 | EXPECT_GT(pref_store->get_writer().previous_data_size(), 0u); |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 314 | |
| 315 | // The JSON file looks like this: |
| 316 | // { |
| 317 | // "homepage": "http://www.cnn.com", |
| 318 | // "some_directory": "/usr/local/", |
| 319 | // "tabs": { |
| 320 | // "new_windows_in_tabs": true, |
| 321 | // "max_tabs": 20 |
| 322 | // } |
| 323 | // } |
| 324 | |
Patrick Noland | c4817974 | 2022-11-10 20:55:43 | [diff] [blame] | 325 | RunBasicJsonPrefStoreTest(pref_store.get(), input_file, |
| 326 | commit_pending_write_mode_, &task_environment_); |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 327 | } |
| 328 | |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 329 | TEST_P(JsonPrefStoreTest, BasicAsync) { |
vabr | 8023d87 | 2016-09-15 08:12:22 | [diff] [blame] | 330 | base::FilePath input_file = temp_dir_.GetPath().AppendASCII("write.json"); |
Claudio DeSouza | c3e8508 | 2023-02-27 16:07:15 | [diff] [blame] | 331 | ASSERT_TRUE(base::WriteFile(input_file, kReadJson)); |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 332 | |
| 333 | // Test that the persistent value can be loaded. |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 334 | auto pref_store = base::MakeRefCounted<JsonPrefStore>(input_file); |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 335 | |
zelidrag@chromium.org | 0de615a | 2012-11-08 04:40:59 | [diff] [blame] | 336 | { |
| 337 | MockPrefStoreObserver mock_observer; |
| 338 | pref_store->AddObserver(&mock_observer); |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 339 | |
zelidrag@chromium.org | 0de615a | 2012-11-08 04:40:59 | [diff] [blame] | 340 | MockReadErrorDelegate* mock_error_delegate = new MockReadErrorDelegate; |
| 341 | pref_store->ReadPrefsAsync(mock_error_delegate); |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 342 | |
zelidrag@chromium.org | 0de615a | 2012-11-08 04:40:59 | [diff] [blame] | 343 | EXPECT_CALL(mock_observer, OnInitializationCompleted(true)).Times(1); |
| 344 | EXPECT_CALL(*mock_error_delegate, |
| 345 | OnError(PersistentPrefStore::PREF_READ_ERROR_NONE)).Times(0); |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 346 | task_environment_.RunUntilIdle(); |
zelidrag@chromium.org | 0de615a | 2012-11-08 04:40:59 | [diff] [blame] | 347 | pref_store->RemoveObserver(&mock_observer); |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 348 | |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 349 | EXPECT_FALSE(pref_store->ReadOnly()); |
| 350 | EXPECT_TRUE(pref_store->IsInitializationComplete()); |
Dominic Battre | c7911fe | 2020-11-26 21:13:18 | [diff] [blame] | 351 | EXPECT_GT(pref_store->get_writer().previous_data_size(), 0u); |
zelidrag@chromium.org | 0de615a | 2012-11-08 04:40:59 | [diff] [blame] | 352 | } |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 353 | |
| 354 | // The JSON file looks like this: |
| 355 | // { |
| 356 | // "homepage": "http://www.cnn.com", |
| 357 | // "some_directory": "/usr/local/", |
| 358 | // "tabs": { |
| 359 | // "new_windows_in_tabs": true, |
| 360 | // "max_tabs": 20 |
| 361 | // } |
| 362 | // } |
| 363 | |
Patrick Noland | c4817974 | 2022-11-10 20:55:43 | [diff] [blame] | 364 | RunBasicJsonPrefStoreTest(pref_store.get(), input_file, |
| 365 | commit_pending_write_mode_, &task_environment_); |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 366 | } |
| 367 | |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 368 | TEST_P(JsonPrefStoreTest, PreserveEmptyValues) { |
vabr | 8023d87 | 2016-09-15 08:12:22 | [diff] [blame] | 369 | FilePath pref_file = temp_dir_.GetPath().AppendASCII("empty_values.json"); |
gab@chromium.org | aa328339 | 2013-11-27 01:38:24 | [diff] [blame] | 370 | |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 371 | auto pref_store = base::MakeRefCounted<JsonPrefStore>(pref_file); |
gab@chromium.org | aa328339 | 2013-11-27 01:38:24 | [diff] [blame] | 372 | |
| 373 | // Set some keys with empty values. |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 374 | pref_store->SetValue("list", base::Value(base::Value::List()), |
raymes | 76de1af | 2015-05-06 03:22:21 | [diff] [blame] | 375 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 376 | pref_store->SetValue("dict", base::Value(base::Value::Dict()), |
raymes | 76de1af | 2015-05-06 03:22:21 | [diff] [blame] | 377 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
gab@chromium.org | aa328339 | 2013-11-27 01:38:24 | [diff] [blame] | 378 | |
| 379 | // Write to file. |
Patrick Noland | c4817974 | 2022-11-10 20:55:43 | [diff] [blame] | 380 | CommitPendingWrite(pref_store.get(), commit_pending_write_mode_, |
| 381 | &task_environment_); |
gab@chromium.org | aa328339 | 2013-11-27 01:38:24 | [diff] [blame] | 382 | |
| 383 | // Reload. |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 384 | pref_store = base::MakeRefCounted<JsonPrefStore>(pref_file); |
gab@chromium.org | aa328339 | 2013-11-27 01:38:24 | [diff] [blame] | 385 | ASSERT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE, pref_store->ReadPrefs()); |
| 386 | ASSERT_FALSE(pref_store->ReadOnly()); |
| 387 | |
| 388 | // Check values. |
Ivan Kotenkov | 75b1c3a | 2017-10-24 14:47:24 | [diff] [blame] | 389 | const Value* result = nullptr; |
gab@chromium.org | aa328339 | 2013-11-27 01:38:24 | [diff] [blame] | 390 | EXPECT_TRUE(pref_store->GetValue("list", &result)); |
Matt Menke | 7b290b85 | 2023-01-04 12:51:51 | [diff] [blame] | 391 | EXPECT_EQ(Value::List(), *result); |
gab@chromium.org | aa328339 | 2013-11-27 01:38:24 | [diff] [blame] | 392 | EXPECT_TRUE(pref_store->GetValue("dict", &result)); |
Matt Menke | 7b290b85 | 2023-01-04 12:51:51 | [diff] [blame] | 393 | EXPECT_EQ(Value::Dict(), *result); |
gab@chromium.org | aa328339 | 2013-11-27 01:38:24 | [diff] [blame] | 394 | } |
| 395 | |
dgrogan@chromium.org | eeedaa69 | 2014-01-30 09:22:27 | [diff] [blame] | 396 | // This test is just documenting some potentially non-obvious behavior. It |
| 397 | // shouldn't be taken as normative. |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 398 | TEST_P(JsonPrefStoreTest, RemoveClearsEmptyParent) { |
vabr | 8023d87 | 2016-09-15 08:12:22 | [diff] [blame] | 399 | FilePath pref_file = temp_dir_.GetPath().AppendASCII("empty_values.json"); |
dgrogan@chromium.org | eeedaa69 | 2014-01-30 09:22:27 | [diff] [blame] | 400 | |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 401 | auto pref_store = base::MakeRefCounted<JsonPrefStore>(pref_file); |
dgrogan@chromium.org | eeedaa69 | 2014-01-30 09:22:27 | [diff] [blame] | 402 | |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 403 | base::Value::Dict dict; |
| 404 | dict.Set("key", "value"); |
| 405 | pref_store->SetValue("dict", base::Value(std::move(dict)), |
raymes | 76de1af | 2015-05-06 03:22:21 | [diff] [blame] | 406 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
dgrogan@chromium.org | eeedaa69 | 2014-01-30 09:22:27 | [diff] [blame] | 407 | |
raymes | 76de1af | 2015-05-06 03:22:21 | [diff] [blame] | 408 | pref_store->RemoveValue("dict.key", |
| 409 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
dgrogan@chromium.org | eeedaa69 | 2014-01-30 09:22:27 | [diff] [blame] | 410 | |
Ivan Kotenkov | 75b1c3a | 2017-10-24 14:47:24 | [diff] [blame] | 411 | const base::Value* retrieved_dict = nullptr; |
dgrogan@chromium.org | eeedaa69 | 2014-01-30 09:22:27 | [diff] [blame] | 412 | bool has_dict = pref_store->GetValue("dict", &retrieved_dict); |
| 413 | EXPECT_FALSE(has_dict); |
| 414 | } |
| 415 | |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 416 | // Tests asynchronous reading of the file when there is no file. |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 417 | TEST_P(JsonPrefStoreTest, AsyncNonExistingFile) { |
vabr | 8023d87 | 2016-09-15 08:12:22 | [diff] [blame] | 418 | base::FilePath bogus_input_file = temp_dir_.GetPath().AppendASCII("read.txt"); |
brettw@chromium.org | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 419 | ASSERT_FALSE(PathExists(bogus_input_file)); |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 420 | auto pref_store = base::MakeRefCounted<JsonPrefStore>(bogus_input_file); |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 421 | MockPrefStoreObserver mock_observer; |
| 422 | pref_store->AddObserver(&mock_observer); |
| 423 | |
| 424 | MockReadErrorDelegate *mock_error_delegate = new MockReadErrorDelegate; |
| 425 | pref_store->ReadPrefsAsync(mock_error_delegate); |
| 426 | |
| 427 | EXPECT_CALL(mock_observer, OnInitializationCompleted(true)).Times(1); |
| 428 | EXPECT_CALL(*mock_error_delegate, |
| 429 | OnError(PersistentPrefStore::PREF_READ_ERROR_NO_FILE)).Times(1); |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 430 | task_environment_.RunUntilIdle(); |
altimofeev@chromium.org | 845b43a8 | 2011-05-11 10:14:43 | [diff] [blame] | 431 | pref_store->RemoveObserver(&mock_observer); |
| 432 | |
| 433 | EXPECT_FALSE(pref_store->ReadOnly()); |
| 434 | } |
xiyuan@chromium.org | ea3e497 | 2012-04-12 03:41:37 | [diff] [blame] | 435 | |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 436 | TEST_P(JsonPrefStoreTest, ReadWithInterceptor) { |
vabr | 8023d87 | 2016-09-15 08:12:22 | [diff] [blame] | 437 | base::FilePath input_file = temp_dir_.GetPath().AppendASCII("write.json"); |
Claudio DeSouza | c3e8508 | 2023-02-27 16:07:15 | [diff] [blame] | 438 | ASSERT_TRUE(base::WriteFile(input_file, kReadJson)); |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 439 | |
dcheng | 5f043bc | 2016-04-22 19:09:06 | [diff] [blame] | 440 | std::unique_ptr<InterceptingPrefFilter> intercepting_pref_filter( |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 441 | new InterceptingPrefFilter()); |
| 442 | InterceptingPrefFilter* raw_intercepting_pref_filter_ = |
| 443 | intercepting_pref_filter.get(); |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 444 | auto pref_store = base::MakeRefCounted<JsonPrefStore>( |
Gabriel Charette | 1f53ca3 | 2018-08-07 21:31:17 | [diff] [blame] | 445 | input_file, std::move(intercepting_pref_filter)); |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 446 | |
| 447 | ASSERT_EQ(PersistentPrefStore::PREF_READ_ERROR_ASYNCHRONOUS_TASK_INCOMPLETE, |
| 448 | pref_store->ReadPrefs()); |
| 449 | EXPECT_FALSE(pref_store->ReadOnly()); |
| 450 | |
| 451 | // The store shouldn't be considered initialized until the interceptor |
| 452 | // returns. |
| 453 | EXPECT_TRUE(raw_intercepting_pref_filter_->has_intercepted_prefs()); |
| 454 | EXPECT_FALSE(pref_store->IsInitializationComplete()); |
Ivan Kotenkov | 75b1c3a | 2017-10-24 14:47:24 | [diff] [blame] | 455 | EXPECT_FALSE(pref_store->GetValue(kHomePage, nullptr)); |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 456 | |
| 457 | raw_intercepting_pref_filter_->ReleasePrefs(); |
| 458 | |
| 459 | EXPECT_FALSE(raw_intercepting_pref_filter_->has_intercepted_prefs()); |
| 460 | EXPECT_TRUE(pref_store->IsInitializationComplete()); |
Ivan Kotenkov | 75b1c3a | 2017-10-24 14:47:24 | [diff] [blame] | 461 | EXPECT_TRUE(pref_store->GetValue(kHomePage, nullptr)); |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 462 | |
| 463 | // The JSON file looks like this: |
| 464 | // { |
| 465 | // "homepage": "http://www.cnn.com", |
| 466 | // "some_directory": "/usr/local/", |
| 467 | // "tabs": { |
| 468 | // "new_windows_in_tabs": true, |
| 469 | // "max_tabs": 20 |
| 470 | // } |
| 471 | // } |
| 472 | |
Patrick Noland | c4817974 | 2022-11-10 20:55:43 | [diff] [blame] | 473 | RunBasicJsonPrefStoreTest(pref_store.get(), input_file, |
| 474 | commit_pending_write_mode_, &task_environment_); |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 475 | } |
| 476 | |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 477 | TEST_P(JsonPrefStoreTest, ReadAsyncWithInterceptor) { |
vabr | 8023d87 | 2016-09-15 08:12:22 | [diff] [blame] | 478 | base::FilePath input_file = temp_dir_.GetPath().AppendASCII("write.json"); |
Claudio DeSouza | c3e8508 | 2023-02-27 16:07:15 | [diff] [blame] | 479 | ASSERT_TRUE(base::WriteFile(input_file, kReadJson)); |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 480 | |
dcheng | 5f043bc | 2016-04-22 19:09:06 | [diff] [blame] | 481 | std::unique_ptr<InterceptingPrefFilter> intercepting_pref_filter( |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 482 | new InterceptingPrefFilter()); |
| 483 | InterceptingPrefFilter* raw_intercepting_pref_filter_ = |
| 484 | intercepting_pref_filter.get(); |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 485 | auto pref_store = base::MakeRefCounted<JsonPrefStore>( |
Gabriel Charette | 1f53ca3 | 2018-08-07 21:31:17 | [diff] [blame] | 486 | input_file, std::move(intercepting_pref_filter)); |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 487 | |
| 488 | MockPrefStoreObserver mock_observer; |
| 489 | pref_store->AddObserver(&mock_observer); |
| 490 | |
| 491 | // Ownership of the |mock_error_delegate| is handed to the |pref_store| below. |
| 492 | MockReadErrorDelegate* mock_error_delegate = new MockReadErrorDelegate; |
| 493 | |
| 494 | { |
| 495 | pref_store->ReadPrefsAsync(mock_error_delegate); |
| 496 | |
| 497 | EXPECT_CALL(mock_observer, OnInitializationCompleted(true)).Times(0); |
| 498 | // EXPECT_CALL(*mock_error_delegate, |
| 499 | // OnError(PersistentPrefStore::PREF_READ_ERROR_NONE)).Times(0); |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 500 | task_environment_.RunUntilIdle(); |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 501 | |
| 502 | EXPECT_FALSE(pref_store->ReadOnly()); |
| 503 | EXPECT_TRUE(raw_intercepting_pref_filter_->has_intercepted_prefs()); |
| 504 | EXPECT_FALSE(pref_store->IsInitializationComplete()); |
Ivan Kotenkov | 75b1c3a | 2017-10-24 14:47:24 | [diff] [blame] | 505 | EXPECT_FALSE(pref_store->GetValue(kHomePage, nullptr)); |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 506 | } |
| 507 | |
| 508 | { |
| 509 | EXPECT_CALL(mock_observer, OnInitializationCompleted(true)).Times(1); |
| 510 | // EXPECT_CALL(*mock_error_delegate, |
| 511 | // OnError(PersistentPrefStore::PREF_READ_ERROR_NONE)).Times(0); |
| 512 | |
| 513 | raw_intercepting_pref_filter_->ReleasePrefs(); |
| 514 | |
| 515 | EXPECT_FALSE(pref_store->ReadOnly()); |
| 516 | EXPECT_FALSE(raw_intercepting_pref_filter_->has_intercepted_prefs()); |
| 517 | EXPECT_TRUE(pref_store->IsInitializationComplete()); |
Ivan Kotenkov | 75b1c3a | 2017-10-24 14:47:24 | [diff] [blame] | 518 | EXPECT_TRUE(pref_store->GetValue(kHomePage, nullptr)); |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 519 | } |
| 520 | |
| 521 | pref_store->RemoveObserver(&mock_observer); |
| 522 | |
| 523 | // The JSON file looks like this: |
| 524 | // { |
| 525 | // "homepage": "http://www.cnn.com", |
| 526 | // "some_directory": "/usr/local/", |
| 527 | // "tabs": { |
| 528 | // "new_windows_in_tabs": true, |
| 529 | // "max_tabs": 20 |
| 530 | // } |
| 531 | // } |
| 532 | |
Patrick Noland | c4817974 | 2022-11-10 20:55:43 | [diff] [blame] | 533 | RunBasicJsonPrefStoreTest(pref_store.get(), input_file, |
| 534 | commit_pending_write_mode_, &task_environment_); |
gab@chromium.org | e33c951 | 2014-05-12 02:24:13 | [diff] [blame] | 535 | } |
| 536 | |
Anatoliy Potapchuk | 5d9d8de | 2020-04-21 02:09:26 | [diff] [blame] | 537 | TEST_P(JsonPrefStoreTest, RemoveValuesByPrefix) { |
| 538 | FilePath pref_file = temp_dir_.GetPath().AppendASCII("empty.json"); |
| 539 | |
| 540 | auto pref_store = base::MakeRefCounted<JsonPrefStore>(pref_file); |
| 541 | |
| 542 | const Value* value; |
| 543 | const std::string prefix = "pref"; |
| 544 | const std::string subpref_name1 = "pref.a"; |
| 545 | const std::string subpref_name2 = "pref.b"; |
| 546 | const std::string other_name = "other"; |
| 547 | |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 548 | pref_store->SetValue(subpref_name1, base::Value(42), |
Anatoliy Potapchuk | 5d9d8de | 2020-04-21 02:09:26 | [diff] [blame] | 549 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 550 | pref_store->SetValue(subpref_name2, base::Value(42), |
Anatoliy Potapchuk | 5d9d8de | 2020-04-21 02:09:26 | [diff] [blame] | 551 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 552 | pref_store->SetValue(other_name, base::Value(42), |
Anatoliy Potapchuk | 5d9d8de | 2020-04-21 02:09:26 | [diff] [blame] | 553 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
| 554 | |
| 555 | pref_store->RemoveValuesByPrefixSilently(prefix); |
| 556 | EXPECT_FALSE(pref_store->GetValue(subpref_name1, &value)); |
| 557 | EXPECT_FALSE(pref_store->GetValue(subpref_name2, &value)); |
| 558 | EXPECT_TRUE(pref_store->GetValue(other_name, &value)); |
| 559 | } |
| 560 | |
Victor Costan | 1559fac | 2019-02-13 13:29:50 | [diff] [blame] | 561 | INSTANTIATE_TEST_SUITE_P( |
Patrick Noland | c4817974 | 2022-11-10 20:55:43 | [diff] [blame] | 562 | JsonPrefStoreTestVariations, |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 563 | JsonPrefStoreTest, |
Marc Treib | 85b56d54 | 2023-06-12 10:15:49 | [diff] [blame] | 564 | ::testing::Values(CommitPendingWriteMode::WITHOUT_CALLBACK, |
| 565 | CommitPendingWriteMode::WITH_CALLBACK, |
| 566 | CommitPendingWriteMode::WITH_SYNCHRONOUS_CALLBACK)); |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 567 | |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 568 | class JsonPrefStoreLossyWriteTest : public JsonPrefStoreTest { |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 569 | public: |
| 570 | JsonPrefStoreLossyWriteTest() = default; |
| 571 | |
Peter Boström | 9f667c38 | 2021-10-01 20:09:31 | [diff] [blame] | 572 | JsonPrefStoreLossyWriteTest(const JsonPrefStoreLossyWriteTest&) = delete; |
| 573 | JsonPrefStoreLossyWriteTest& operator=(const JsonPrefStoreLossyWriteTest&) = |
| 574 | delete; |
| 575 | |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 576 | protected: |
| 577 | void SetUp() override { |
| 578 | JsonPrefStoreTest::SetUp(); |
vabr | 8023d87 | 2016-09-15 08:12:22 | [diff] [blame] | 579 | test_file_ = temp_dir_.GetPath().AppendASCII("test.json"); |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 580 | } |
| 581 | |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 582 | scoped_refptr<JsonPrefStore> CreatePrefStore() { |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 583 | return base::MakeRefCounted<JsonPrefStore>(test_file_); |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 584 | } |
| 585 | |
| 586 | // Return the ImportantFileWriter for a given JsonPrefStore. |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 587 | ImportantFileWriter* GetImportantFileWriter(JsonPrefStore* pref_store) { |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 588 | return &(pref_store->writer_); |
| 589 | } |
| 590 | |
| 591 | // Get the contents of kTestFile. Pumps the message loop before returning the |
| 592 | // result. |
| 593 | std::string GetTestFileContents() { |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 594 | task_environment_.RunUntilIdle(); |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 595 | std::string file_contents; |
| 596 | ReadFileToString(test_file_, &file_contents); |
| 597 | return file_contents; |
| 598 | } |
| 599 | |
| 600 | private: |
| 601 | base::FilePath test_file_; |
| 602 | }; |
| 603 | |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 604 | TEST_P(JsonPrefStoreLossyWriteTest, LossyWriteBasic) { |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 605 | scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore(); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 606 | ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get()); |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 607 | |
| 608 | // Set a normal pref and check that it gets scheduled to be written. |
| 609 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 610 | pref_store->SetValue("normal", base::Value("normal"), |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 611 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
| 612 | ASSERT_TRUE(file_writer->HasPendingWrite()); |
| 613 | file_writer->DoScheduledWrite(); |
| 614 | ASSERT_EQ("{\"normal\":\"normal\"}", GetTestFileContents()); |
| 615 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
| 616 | |
| 617 | // Set a lossy pref and check that it is not scheduled to be written. |
| 618 | // SetValue/RemoveValue. |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 619 | pref_store->SetValue("lossy", base::Value("lossy"), |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 620 | WriteablePrefStore::LOSSY_PREF_WRITE_FLAG); |
| 621 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
| 622 | pref_store->RemoveValue("lossy", WriteablePrefStore::LOSSY_PREF_WRITE_FLAG); |
| 623 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
| 624 | |
| 625 | // SetValueSilently/RemoveValueSilently. |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 626 | pref_store->SetValueSilently("lossy", base::Value("lossy"), |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 627 | WriteablePrefStore::LOSSY_PREF_WRITE_FLAG); |
| 628 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
| 629 | pref_store->RemoveValueSilently("lossy", |
| 630 | WriteablePrefStore::LOSSY_PREF_WRITE_FLAG); |
| 631 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
| 632 | |
| 633 | // ReportValueChanged. |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 634 | pref_store->SetValue("lossy", base::Value("lossy"), |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 635 | WriteablePrefStore::LOSSY_PREF_WRITE_FLAG); |
| 636 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
| 637 | pref_store->ReportValueChanged("lossy", |
| 638 | WriteablePrefStore::LOSSY_PREF_WRITE_FLAG); |
| 639 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
| 640 | |
| 641 | // Call CommitPendingWrite and check that the lossy pref and the normal pref |
| 642 | // are there with the last values set above. |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 643 | pref_store->CommitPendingWrite(base::OnceClosure()); |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 644 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
| 645 | ASSERT_EQ("{\"lossy\":\"lossy\",\"normal\":\"normal\"}", |
| 646 | GetTestFileContents()); |
| 647 | } |
| 648 | |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 649 | TEST_P(JsonPrefStoreLossyWriteTest, LossyWriteMixedLossyFirst) { |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 650 | scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore(); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 651 | ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get()); |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 652 | |
| 653 | // Set a lossy pref and check that it is not scheduled to be written. |
| 654 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 655 | pref_store->SetValue("lossy", base::Value("lossy"), |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 656 | WriteablePrefStore::LOSSY_PREF_WRITE_FLAG); |
| 657 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
| 658 | |
| 659 | // Set a normal pref and check that it is scheduled to be written. |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 660 | pref_store->SetValue("normal", base::Value("normal"), |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 661 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
| 662 | ASSERT_TRUE(file_writer->HasPendingWrite()); |
| 663 | |
| 664 | // Call DoScheduledWrite and check both prefs get written. |
| 665 | file_writer->DoScheduledWrite(); |
| 666 | ASSERT_EQ("{\"lossy\":\"lossy\",\"normal\":\"normal\"}", |
| 667 | GetTestFileContents()); |
| 668 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
| 669 | } |
| 670 | |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 671 | TEST_P(JsonPrefStoreLossyWriteTest, LossyWriteMixedLossySecond) { |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 672 | scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore(); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 673 | ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get()); |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 674 | |
| 675 | // Set a normal pref and check that it is scheduled to be written. |
| 676 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 677 | pref_store->SetValue("normal", base::Value("normal"), |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 678 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
| 679 | ASSERT_TRUE(file_writer->HasPendingWrite()); |
| 680 | |
| 681 | // Set a lossy pref and check that the write is still scheduled. |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 682 | pref_store->SetValue("lossy", base::Value("lossy"), |
raymes | 4b6e14e | 2015-05-12 00:10:30 | [diff] [blame] | 683 | WriteablePrefStore::LOSSY_PREF_WRITE_FLAG); |
| 684 | ASSERT_TRUE(file_writer->HasPendingWrite()); |
| 685 | |
| 686 | // Call DoScheduledWrite and check both prefs get written. |
| 687 | file_writer->DoScheduledWrite(); |
| 688 | ASSERT_EQ("{\"lossy\":\"lossy\",\"normal\":\"normal\"}", |
| 689 | GetTestFileContents()); |
| 690 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
| 691 | } |
| 692 | |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 693 | TEST_P(JsonPrefStoreLossyWriteTest, ScheduleLossyWrite) { |
benwells | 2673059 | 2015-05-28 13:08:08 | [diff] [blame] | 694 | scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore(); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 695 | ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get()); |
benwells | 2673059 | 2015-05-28 13:08:08 | [diff] [blame] | 696 | |
| 697 | // Set a lossy pref and check that it is not scheduled to be written. |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 698 | pref_store->SetValue("lossy", base::Value("lossy"), |
benwells | 2673059 | 2015-05-28 13:08:08 | [diff] [blame] | 699 | WriteablePrefStore::LOSSY_PREF_WRITE_FLAG); |
| 700 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
| 701 | |
| 702 | // Schedule pending lossy writes and check that it is scheduled. |
| 703 | pref_store->SchedulePendingLossyWrites(); |
| 704 | ASSERT_TRUE(file_writer->HasPendingWrite()); |
| 705 | |
| 706 | // Call CommitPendingWrite and check that the lossy pref is there with the |
| 707 | // last value set above. |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 708 | pref_store->CommitPendingWrite(base::OnceClosure()); |
benwells | 2673059 | 2015-05-28 13:08:08 | [diff] [blame] | 709 | ASSERT_FALSE(file_writer->HasPendingWrite()); |
| 710 | ASSERT_EQ("{\"lossy\":\"lossy\"}", GetTestFileContents()); |
| 711 | } |
| 712 | |
Victor Costan | 1559fac | 2019-02-13 13:29:50 | [diff] [blame] | 713 | INSTANTIATE_TEST_SUITE_P( |
Patrick Noland | c4817974 | 2022-11-10 20:55:43 | [diff] [blame] | 714 | JsonPrefStoreLossyWriteTestVariations, |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 715 | JsonPrefStoreLossyWriteTest, |
Marc Treib | 85b56d54 | 2023-06-12 10:15:49 | [diff] [blame] | 716 | ::testing::Values(CommitPendingWriteMode::WITHOUT_CALLBACK, |
| 717 | CommitPendingWriteMode::WITH_CALLBACK, |
| 718 | CommitPendingWriteMode::WITH_SYNCHRONOUS_CALLBACK)); |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 719 | |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 720 | class SuccessfulWriteReplyObserver { |
| 721 | public: |
| 722 | SuccessfulWriteReplyObserver() = default; |
| 723 | |
Peter Boström | 9f667c38 | 2021-10-01 20:09:31 | [diff] [blame] | 724 | SuccessfulWriteReplyObserver(const SuccessfulWriteReplyObserver&) = delete; |
| 725 | SuccessfulWriteReplyObserver& operator=(const SuccessfulWriteReplyObserver&) = |
| 726 | delete; |
| 727 | |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 728 | // Returns true if a successful write was observed via on_successful_write() |
| 729 | // and resets the observation state to false regardless. |
| 730 | bool GetAndResetObservationState() { |
| 731 | bool was_successful_write_observed = successful_write_reply_observed_; |
| 732 | successful_write_reply_observed_ = false; |
| 733 | return was_successful_write_observed; |
| 734 | } |
| 735 | |
| 736 | // Register OnWrite() to be called on the next write of |json_pref_store|. |
| 737 | void ObserveNextWriteCallback(JsonPrefStore* json_pref_store); |
| 738 | |
| 739 | void OnSuccessfulWrite() { |
| 740 | EXPECT_FALSE(successful_write_reply_observed_); |
| 741 | successful_write_reply_observed_ = true; |
| 742 | } |
| 743 | |
| 744 | private: |
| 745 | bool successful_write_reply_observed_ = false; |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 746 | }; |
| 747 | |
| 748 | void SuccessfulWriteReplyObserver::ObserveNextWriteCallback( |
| 749 | JsonPrefStore* json_pref_store) { |
| 750 | json_pref_store->RegisterOnNextSuccessfulWriteReply( |
Sylvain Defresne | 073318e2 | 2019-10-14 11:06:02 | [diff] [blame] | 751 | base::BindOnce(&SuccessfulWriteReplyObserver::OnSuccessfulWrite, |
| 752 | base::Unretained(this))); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 753 | } |
| 754 | |
| 755 | enum WriteCallbackObservationState { |
| 756 | NOT_CALLED, |
| 757 | CALLED_WITH_ERROR, |
| 758 | CALLED_WITH_SUCCESS, |
| 759 | }; |
| 760 | |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 761 | class WriteCallbacksObserver { |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 762 | public: |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 763 | WriteCallbacksObserver() = default; |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 764 | |
Peter Boström | 9f667c38 | 2021-10-01 20:09:31 | [diff] [blame] | 765 | WriteCallbacksObserver(const WriteCallbacksObserver&) = delete; |
| 766 | WriteCallbacksObserver& operator=(const WriteCallbacksObserver&) = delete; |
| 767 | |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 768 | // Register OnWrite() to be called on the next write of |json_pref_store|. |
| 769 | void ObserveNextWriteCallback(JsonPrefStore* json_pref_store); |
| 770 | |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 771 | // Returns whether OnPreWrite() was called, and resets the observation state |
| 772 | // to false. |
| 773 | bool GetAndResetPreWriteObservationState(); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 774 | |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 775 | // Returns the |WriteCallbackObservationState| which was observed, then resets |
| 776 | // it to |NOT_CALLED|. |
| 777 | WriteCallbackObservationState GetAndResetPostWriteObservationState(); |
| 778 | |
| 779 | JsonPrefStore::OnWriteCallbackPair GetCallbackPair() { |
Sylvain Defresne | 073318e2 | 2019-10-14 11:06:02 | [diff] [blame] | 780 | return std::make_pair(base::BindOnce(&WriteCallbacksObserver::OnPreWrite, |
| 781 | base::Unretained(this)), |
| 782 | base::BindOnce(&WriteCallbacksObserver::OnPostWrite, |
| 783 | base::Unretained(this))); |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 784 | } |
| 785 | |
| 786 | void OnPreWrite() { |
| 787 | EXPECT_FALSE(pre_write_called_); |
| 788 | pre_write_called_ = true; |
| 789 | } |
| 790 | |
| 791 | void OnPostWrite(bool success) { |
| 792 | EXPECT_EQ(NOT_CALLED, post_write_observation_state_); |
| 793 | post_write_observation_state_ = |
| 794 | success ? CALLED_WITH_SUCCESS : CALLED_WITH_ERROR; |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 795 | } |
| 796 | |
| 797 | private: |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 798 | bool pre_write_called_ = false; |
| 799 | WriteCallbackObservationState post_write_observation_state_ = NOT_CALLED; |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 800 | }; |
| 801 | |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 802 | void WriteCallbacksObserver::ObserveNextWriteCallback(JsonPrefStore* writer) { |
| 803 | writer->RegisterOnNextWriteSynchronousCallbacks(GetCallbackPair()); |
| 804 | } |
| 805 | |
| 806 | bool WriteCallbacksObserver::GetAndResetPreWriteObservationState() { |
| 807 | bool observation_state = pre_write_called_; |
| 808 | pre_write_called_ = false; |
| 809 | return observation_state; |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 810 | } |
| 811 | |
| 812 | WriteCallbackObservationState |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 813 | WriteCallbacksObserver::GetAndResetPostWriteObservationState() { |
| 814 | WriteCallbackObservationState state = post_write_observation_state_; |
| 815 | pre_write_called_ = false; |
| 816 | post_write_observation_state_ = NOT_CALLED; |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 817 | return state; |
| 818 | } |
| 819 | |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 820 | class JsonPrefStoreCallbackTest : public testing::Test { |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 821 | public: |
| 822 | JsonPrefStoreCallbackTest() = default; |
| 823 | |
Peter Boström | 9f667c38 | 2021-10-01 20:09:31 | [diff] [blame] | 824 | JsonPrefStoreCallbackTest(const JsonPrefStoreCallbackTest&) = delete; |
| 825 | JsonPrefStoreCallbackTest& operator=(const JsonPrefStoreCallbackTest&) = |
| 826 | delete; |
| 827 | |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 828 | protected: |
| 829 | void SetUp() override { |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 830 | ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); |
vabr | 5d919d6 | 2016-09-30 08:55:36 | [diff] [blame] | 831 | test_file_ = temp_dir_.GetPath().AppendASCII("test.json"); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 832 | } |
| 833 | |
| 834 | scoped_refptr<JsonPrefStore> CreatePrefStore() { |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 835 | return base::MakeRefCounted<JsonPrefStore>(test_file_); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 836 | } |
| 837 | |
| 838 | // Return the ImportantFileWriter for a given JsonPrefStore. |
| 839 | ImportantFileWriter* GetImportantFileWriter(JsonPrefStore* pref_store) { |
| 840 | return &(pref_store->writer_); |
| 841 | } |
| 842 | |
| 843 | void TriggerFakeWriteForCallback(JsonPrefStore* pref_store, bool success) { |
| 844 | JsonPrefStore::PostWriteCallback( |
Sylvain Defresne | 073318e2 | 2019-10-14 11:06:02 | [diff] [blame] | 845 | base::BindOnce(&JsonPrefStore::RunOrScheduleNextSuccessfulWriteCallback, |
| 846 | pref_store->AsWeakPtr()), |
| 847 | base::BindOnce(&WriteCallbacksObserver::OnPostWrite, |
| 848 | base::Unretained(&write_callback_observer_)), |
Sean Maher | 52fa5a7 | 2022-11-14 15:53:25 | [diff] [blame] | 849 | base::SequencedTaskRunner::GetCurrentDefault(), success); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 850 | } |
| 851 | |
| 852 | SuccessfulWriteReplyObserver successful_write_reply_observer_; |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 853 | WriteCallbacksObserver write_callback_observer_; |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 854 | |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 855 | protected: |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 856 | base::test::TaskEnvironment task_environment_{ |
| 857 | base::test::TaskEnvironment::MainThreadType::DEFAULT, |
| 858 | base::test::TaskEnvironment::ThreadPoolExecutionMode::QUEUED}; |
Gabriel Charette | 788eaf6 | 2018-08-07 20:11:46 | [diff] [blame] | 859 | |
| 860 | base::ScopedTempDir temp_dir_; |
| 861 | |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 862 | private: |
| 863 | base::FilePath test_file_; |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 864 | }; |
| 865 | |
Francois Doray | 5f54795 | 2017-07-25 21:02:05 | [diff] [blame] | 866 | TEST_F(JsonPrefStoreCallbackTest, TestSerializeDataCallbacks) { |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 867 | base::FilePath input_file = temp_dir_.GetPath().AppendASCII("write.json"); |
Claudio DeSouza | c3e8508 | 2023-02-27 16:07:15 | [diff] [blame] | 868 | ASSERT_TRUE(base::WriteFile(input_file, kReadJson)); |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 869 | |
| 870 | std::unique_ptr<InterceptingPrefFilter> intercepting_pref_filter( |
| 871 | new InterceptingPrefFilter(write_callback_observer_.GetCallbackPair())); |
Francois Doray | 405dd2d | 2017-06-09 15:23:33 | [diff] [blame] | 872 | auto pref_store = base::MakeRefCounted<JsonPrefStore>( |
Gabriel Charette | 1f53ca3 | 2018-08-07 21:31:17 | [diff] [blame] | 873 | input_file, std::move(intercepting_pref_filter)); |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 874 | ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get()); |
| 875 | |
| 876 | EXPECT_EQ(NOT_CALLED, |
| 877 | write_callback_observer_.GetAndResetPostWriteObservationState()); |
Roland Bock | e01119d | 2022-09-29 01:21:41 | [diff] [blame] | 878 | pref_store->SetValue("normal", base::Value("normal"), |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 879 | WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
| 880 | file_writer->DoScheduledWrite(); |
| 881 | |
| 882 | // The observer should not be invoked right away. |
| 883 | EXPECT_FALSE(write_callback_observer_.GetAndResetPreWriteObservationState()); |
| 884 | EXPECT_EQ(NOT_CALLED, |
| 885 | write_callback_observer_.GetAndResetPostWriteObservationState()); |
| 886 | |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 887 | task_environment_.RunUntilIdle(); |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 888 | |
| 889 | EXPECT_TRUE(write_callback_observer_.GetAndResetPreWriteObservationState()); |
| 890 | EXPECT_EQ(CALLED_WITH_SUCCESS, |
| 891 | write_callback_observer_.GetAndResetPostWriteObservationState()); |
| 892 | } |
| 893 | |
| 894 | TEST_F(JsonPrefStoreCallbackTest, TestPostWriteCallbacks) { |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 895 | scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore(); |
| 896 | ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get()); |
| 897 | |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 898 | // Test RegisterOnNextWriteSynchronousCallbacks after |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 899 | // RegisterOnNextSuccessfulWriteReply. |
| 900 | successful_write_reply_observer_.ObserveNextWriteCallback(pref_store.get()); |
| 901 | write_callback_observer_.ObserveNextWriteCallback(pref_store.get()); |
Claudio DeSouza | f3385c73 | 2023-03-13 12:36:23 | [diff] [blame] | 902 | file_writer->WriteNow("foo"); |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 903 | task_environment_.RunUntilIdle(); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 904 | EXPECT_TRUE(successful_write_reply_observer_.GetAndResetObservationState()); |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 905 | EXPECT_TRUE(write_callback_observer_.GetAndResetPreWriteObservationState()); |
| 906 | EXPECT_EQ(CALLED_WITH_SUCCESS, |
| 907 | write_callback_observer_.GetAndResetPostWriteObservationState()); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 908 | |
| 909 | // Test RegisterOnNextSuccessfulWriteReply after |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 910 | // RegisterOnNextWriteSynchronousCallbacks. |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 911 | successful_write_reply_observer_.ObserveNextWriteCallback(pref_store.get()); |
| 912 | write_callback_observer_.ObserveNextWriteCallback(pref_store.get()); |
Claudio DeSouza | f3385c73 | 2023-03-13 12:36:23 | [diff] [blame] | 913 | file_writer->WriteNow("foo"); |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 914 | task_environment_.RunUntilIdle(); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 915 | EXPECT_TRUE(successful_write_reply_observer_.GetAndResetObservationState()); |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 916 | EXPECT_TRUE(write_callback_observer_.GetAndResetPreWriteObservationState()); |
| 917 | EXPECT_EQ(CALLED_WITH_SUCCESS, |
| 918 | write_callback_observer_.GetAndResetPostWriteObservationState()); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 919 | |
| 920 | // Test RegisterOnNextSuccessfulWriteReply only. |
| 921 | successful_write_reply_observer_.ObserveNextWriteCallback(pref_store.get()); |
Claudio DeSouza | f3385c73 | 2023-03-13 12:36:23 | [diff] [blame] | 922 | file_writer->WriteNow("foo"); |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 923 | task_environment_.RunUntilIdle(); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 924 | EXPECT_TRUE(successful_write_reply_observer_.GetAndResetObservationState()); |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 925 | EXPECT_FALSE(write_callback_observer_.GetAndResetPreWriteObservationState()); |
| 926 | EXPECT_EQ(NOT_CALLED, |
| 927 | write_callback_observer_.GetAndResetPostWriteObservationState()); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 928 | |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 929 | // Test RegisterOnNextWriteSynchronousCallbacks only. |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 930 | write_callback_observer_.ObserveNextWriteCallback(pref_store.get()); |
Claudio DeSouza | f3385c73 | 2023-03-13 12:36:23 | [diff] [blame] | 931 | file_writer->WriteNow("foo"); |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 932 | task_environment_.RunUntilIdle(); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 933 | EXPECT_FALSE(successful_write_reply_observer_.GetAndResetObservationState()); |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 934 | EXPECT_TRUE(write_callback_observer_.GetAndResetPreWriteObservationState()); |
| 935 | EXPECT_EQ(CALLED_WITH_SUCCESS, |
| 936 | write_callback_observer_.GetAndResetPostWriteObservationState()); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 937 | } |
| 938 | |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 939 | TEST_F(JsonPrefStoreCallbackTest, TestPostWriteCallbacksWithFakeFailure) { |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 940 | scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore(); |
| 941 | |
| 942 | // Confirm that the observers are invoked. |
| 943 | successful_write_reply_observer_.ObserveNextWriteCallback(pref_store.get()); |
| 944 | TriggerFakeWriteForCallback(pref_store.get(), true); |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 945 | task_environment_.RunUntilIdle(); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 946 | EXPECT_TRUE(successful_write_reply_observer_.GetAndResetObservationState()); |
| 947 | EXPECT_EQ(CALLED_WITH_SUCCESS, |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 948 | write_callback_observer_.GetAndResetPostWriteObservationState()); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 949 | |
| 950 | // Confirm that the observation states were reset. |
| 951 | EXPECT_FALSE(successful_write_reply_observer_.GetAndResetObservationState()); |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 952 | EXPECT_EQ(NOT_CALLED, |
| 953 | write_callback_observer_.GetAndResetPostWriteObservationState()); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 954 | |
| 955 | // Confirm that re-installing the observers works for another write. |
| 956 | successful_write_reply_observer_.ObserveNextWriteCallback(pref_store.get()); |
| 957 | TriggerFakeWriteForCallback(pref_store.get(), true); |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 958 | task_environment_.RunUntilIdle(); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 959 | EXPECT_TRUE(successful_write_reply_observer_.GetAndResetObservationState()); |
| 960 | EXPECT_EQ(CALLED_WITH_SUCCESS, |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 961 | write_callback_observer_.GetAndResetPostWriteObservationState()); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 962 | |
| 963 | // Confirm that the successful observer is not invoked by an unsuccessful |
| 964 | // write, and that the synchronous observer is invoked. |
| 965 | successful_write_reply_observer_.ObserveNextWriteCallback(pref_store.get()); |
| 966 | TriggerFakeWriteForCallback(pref_store.get(), false); |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 967 | task_environment_.RunUntilIdle(); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 968 | EXPECT_FALSE(successful_write_reply_observer_.GetAndResetObservationState()); |
| 969 | EXPECT_EQ(CALLED_WITH_ERROR, |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 970 | write_callback_observer_.GetAndResetPostWriteObservationState()); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 971 | |
| 972 | // Do a real write, and confirm that the successful observer was invoked after |
| 973 | // being set by |PostWriteCallback| by the last TriggerFakeWriteCallback. |
| 974 | ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get()); |
Claudio DeSouza | f3385c73 | 2023-03-13 12:36:23 | [diff] [blame] | 975 | file_writer->WriteNow("foo"); |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 976 | task_environment_.RunUntilIdle(); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 977 | EXPECT_TRUE(successful_write_reply_observer_.GetAndResetObservationState()); |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 978 | EXPECT_EQ(NOT_CALLED, |
| 979 | write_callback_observer_.GetAndResetPostWriteObservationState()); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 980 | } |
| 981 | |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 982 | TEST_F(JsonPrefStoreCallbackTest, TestPostWriteCallbacksDuringProfileDeath) { |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 983 | // Create a JsonPrefStore and attach observers to it, then delete it by making |
| 984 | // it go out of scope to simulate profile switch or Chrome shutdown. |
| 985 | { |
| 986 | scoped_refptr<JsonPrefStore> soon_out_of_scope_pref_store = |
| 987 | CreatePrefStore(); |
| 988 | ImportantFileWriter* file_writer = |
| 989 | GetImportantFileWriter(soon_out_of_scope_pref_store.get()); |
| 990 | successful_write_reply_observer_.ObserveNextWriteCallback( |
| 991 | soon_out_of_scope_pref_store.get()); |
| 992 | write_callback_observer_.ObserveNextWriteCallback( |
| 993 | soon_out_of_scope_pref_store.get()); |
Claudio DeSouza | f3385c73 | 2023-03-13 12:36:23 | [diff] [blame] | 994 | file_writer->WriteNow("foo"); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 995 | } |
Gabriel Charette | dfa3604 | 2019-08-19 17:30:11 | [diff] [blame] | 996 | task_environment_.RunUntilIdle(); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 997 | EXPECT_FALSE(successful_write_reply_observer_.GetAndResetObservationState()); |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 998 | EXPECT_TRUE(write_callback_observer_.GetAndResetPreWriteObservationState()); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 999 | EXPECT_EQ(CALLED_WITH_SUCCESS, |
proberge | c503d69 | 2016-09-28 19:51:05 | [diff] [blame] | 1000 | write_callback_observer_.GetAndResetPostWriteObservationState()); |
proberge | fc46ac1 | 2016-09-21 18:03:00 | [diff] [blame] | 1001 | } |
| 1002 | |
vabr | 5d919d6 | 2016-09-30 08:55:36 | [diff] [blame] | 1003 | } // namespace base |