Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(89)

Side by Side Diff: chrome/browser/prefs/profile_pref_store_manager_unittest.cc

Issue 2743463002: WIP: Pref service user prefs. (Closed)
Patch Set: Created 3 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "chrome/browser/prefs/profile_pref_store_manager.h" 5 #include "chrome/browser/prefs/profile_pref_store_manager.h"
6 6
7 #include <stddef.h> 7 #include <stddef.h>
8 8
9 #include <memory> 9 #include <memory>
10 #include <utility> 10 #include <utility>
11 #include <vector> 11 #include <vector>
12 12
13 #include "base/callback_helpers.h"
13 #include "base/compiler_specific.h" 14 #include "base/compiler_specific.h"
14 #include "base/files/file_enumerator.h" 15 #include "base/files/file_enumerator.h"
15 #include "base/files/file_util.h" 16 #include "base/files/file_util.h"
16 #include "base/files/scoped_temp_dir.h" 17 #include "base/files/scoped_temp_dir.h"
17 #include "base/macros.h" 18 #include "base/macros.h"
18 #include "base/memory/ptr_util.h" 19 #include "base/memory/ptr_util.h"
19 #include "base/memory/ref_counted.h" 20 #include "base/memory/ref_counted.h"
20 #include "base/run_loop.h" 21 #include "base/run_loop.h"
21 #include "base/strings/string_util.h" 22 #include "base/strings/string_util.h"
22 #include "base/values.h" 23 #include "base/values.h"
23 #include "components/pref_registry/pref_registry_syncable.h" 24 #include "components/pref_registry/pref_registry_syncable.h"
24 #include "components/prefs/json_pref_store.h" 25 #include "components/prefs/json_pref_store.h"
25 #include "components/prefs/persistent_pref_store.h" 26 #include "components/prefs/persistent_pref_store.h"
26 #include "components/prefs/pref_service.h" 27 #include "components/prefs/pref_service.h"
27 #include "components/prefs/pref_service_factory.h" 28 #include "components/prefs/pref_service_factory.h"
28 #include "components/prefs/pref_store.h" 29 #include "components/prefs/pref_store.h"
29 #include "components/prefs/testing_pref_service.h" 30 #include "components/prefs/testing_pref_service.h"
30 #include "components/user_prefs/tracked/mock_validation_delegate.h" 31 #include "components/user_prefs/tracked/mock_validation_delegate.h"
31 #include "components/user_prefs/tracked/pref_hash_filter.h" 32 #include "components/user_prefs/tracked/pref_hash_filter.h"
32 #include "components/user_prefs/tracked/pref_names.h" 33 #include "components/user_prefs/tracked/pref_names.h"
34 #include "services/preferences/public/cpp/persistent_pref_store_client.h"
33 #include "testing/gtest/include/gtest/gtest.h" 35 #include "testing/gtest/include/gtest/gtest.h"
34 36
35 namespace { 37 namespace {
36 38
37 class FirstEqualsPredicate { 39 class FirstEqualsPredicate {
38 public: 40 public:
39 explicit FirstEqualsPredicate(const std::string& expected) 41 explicit FirstEqualsPredicate(const std::string& expected)
40 : expected_(expected) {} 42 : expected_(expected) {}
41 bool operator()(const PrefValueMap::Map::value_type& pair) { 43 bool operator()(const PrefValueMap::Map::value_type& pair) {
42 return pair.first == expected_; 44 return pair.first == expected_;
(...skipping 18 matching lines...) Expand all
61 FirstEqualsPredicate(key))) 63 FirstEqualsPredicate(key)))
62 << "Unregistered key " << key << " was changed."; 64 << "Unregistered key " << key << " was changed.";
63 } 65 }
64 66
65 void OnInitializationCompleted(bool succeeded) override {} 67 void OnInitializationCompleted(bool succeeded) override {}
66 68
67 private: 69 private:
68 scoped_refptr<PrefRegistry> pref_registry_; 70 scoped_refptr<PrefRegistry> pref_registry_;
69 }; 71 };
70 72
73 class PrefStoreReadObserver : public PrefStore::Observer {
74 public:
75 explicit PrefStoreReadObserver(scoped_refptr<PersistentPrefStore> pref_store)
76 : pref_store_(std::move(pref_store)) {
77 pref_store_->AddObserver(this);
78 }
79
80 ~PrefStoreReadObserver() override { pref_store_->RemoveObserver(this); }
81
82 PersistentPrefStore::PrefReadError Read() {
83 base::RunLoop run_loop;
84 stop_waiting_ = run_loop.QuitClosure();
85 pref_store_->ReadPrefsAsync(nullptr);
86 run_loop.Run();
87 return pref_store_->GetReadError();
88 }
89
90 // PrefStore::Observer implementation
91 void OnPrefValueChanged(const std::string& key) override {}
92
93 void OnInitializationCompleted(bool succeeded) override {
94 if (!stop_waiting_.is_null()) {
95 base::ResetAndReturn(&stop_waiting_).Run();
96 }
97 }
98
99 private:
100 scoped_refptr<PersistentPrefStore> pref_store_;
101 base::Closure stop_waiting_;
102 };
103
71 const char kUnprotectedPref[] = "unprotected_pref"; 104 const char kUnprotectedPref[] = "unprotected_pref";
72 const char kTrackedAtomic[] = "tracked_atomic"; 105 const char kTrackedAtomic[] = "tracked_atomic";
73 const char kProtectedAtomic[] = "protected_atomic"; 106 const char kProtectedAtomic[] = "protected_atomic";
74 107
75 const char kFoobar[] = "FOOBAR"; 108 const char kFoobar[] = "FOOBAR";
76 const char kBarfoo[] = "BARFOO"; 109 const char kBarfoo[] = "BARFOO";
77 const char kHelloWorld[] = "HELLOWORLD"; 110 const char kHelloWorld[] = "HELLOWORLD";
78 const char kGoodbyeWorld[] = "GOODBYEWORLD"; 111 const char kGoodbyeWorld[] = "GOODBYEWORLD";
79 112
80 const PrefHashFilter::TrackedPreferenceMetadata kConfiguration[] = { 113 const PrefHashFilter::TrackedPreferenceMetadata kConfiguration[] = {
81 {0u, kTrackedAtomic, PrefHashFilter::NO_ENFORCEMENT, 114 {0u, kTrackedAtomic, PrefHashFilter::EnforcementLevel::NO_ENFORCEMENT,
82 PrefHashFilter::TRACKING_STRATEGY_ATOMIC}, 115 PrefHashFilter::PrefTrackingStrategy::ATOMIC},
83 {1u, kProtectedAtomic, PrefHashFilter::ENFORCE_ON_LOAD, 116 {1u, kProtectedAtomic, PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
84 PrefHashFilter::TRACKING_STRATEGY_ATOMIC}}; 117 PrefHashFilter::PrefTrackingStrategy::ATOMIC}};
85 118
86 const size_t kExtraReportingId = 2u; 119 const size_t kExtraReportingId = 2u;
87 const size_t kReportingIdCount = 3u; 120 const size_t kReportingIdCount = 3u;
88 121
89 } // namespace 122 } // namespace
90 123
91 class ProfilePrefStoreManagerTest : public testing::Test { 124 class ProfilePrefStoreManagerTest : public testing::Test {
92 public: 125 public:
93 ProfilePrefStoreManagerTest() 126 ProfilePrefStoreManagerTest()
94 : configuration_(kConfiguration, 127 : configuration_(kConfiguration,
95 kConfiguration + arraysize(kConfiguration)), 128 kConfiguration + arraysize(kConfiguration)),
96 profile_pref_registry_(new user_prefs::PrefRegistrySyncable), 129 profile_pref_registry_(new user_prefs::PrefRegistrySyncable),
97 registry_verifier_(profile_pref_registry_.get()), 130 registry_verifier_(profile_pref_registry_.get()),
98 seed_("seed"), 131 seed_("seed"),
99 reset_recorded_(false) {} 132 reset_recorded_(false) {}
100 133
101 void SetUp() override { 134 void SetUp() override {
102 mock_validation_delegate_record_ = new MockValidationDelegateRecord; 135 mock_validation_delegate_record_ = new MockValidationDelegateRecord;
103 mock_validation_delegate_ = base::MakeUnique<MockValidationDelegate>(
104 mock_validation_delegate_record_);
105 ProfilePrefStoreManager::RegisterProfilePrefs(profile_pref_registry_.get()); 136 ProfilePrefStoreManager::RegisterProfilePrefs(profile_pref_registry_.get());
106 for (const PrefHashFilter::TrackedPreferenceMetadata* it = kConfiguration; 137 for (const PrefHashFilter::TrackedPreferenceMetadata* it = kConfiguration;
107 it != kConfiguration + arraysize(kConfiguration); 138 it != kConfiguration + arraysize(kConfiguration);
108 ++it) { 139 ++it) {
109 if (it->strategy == PrefHashFilter::TRACKING_STRATEGY_ATOMIC) { 140 if (it->strategy == PrefHashFilter::PrefTrackingStrategy::ATOMIC) {
110 profile_pref_registry_->RegisterStringPref(it->name, std::string()); 141 profile_pref_registry_->RegisterStringPref(it->name, std::string());
111 } else { 142 } else {
112 profile_pref_registry_->RegisterDictionaryPref(it->name); 143 profile_pref_registry_->RegisterDictionaryPref(it->name);
113 } 144 }
114 } 145 }
115 profile_pref_registry_->RegisterStringPref(kUnprotectedPref, std::string()); 146 profile_pref_registry_->RegisterStringPref(kUnprotectedPref, std::string());
116 147
117 // As in chrome_pref_service_factory.cc, kPreferencesResetTime needs to be 148 // As in chrome_pref_service_factory.cc, kPreferencesResetTime needs to be
118 // declared as protected in order to be read from the proper store by the 149 // declared as protected in order to be read from the proper store by the
119 // SegregatedPrefStore. Only declare it after configured prefs have been 150 // SegregatedPrefStore. Only declare it after configured prefs have been
120 // registered above for this test as kPreferenceResetTime is already 151 // registered above for this test as kPreferenceResetTime is already
121 // registered in ProfilePrefStoreManager::RegisterProfilePrefs. 152 // registered in ProfilePrefStoreManager::RegisterProfilePrefs.
122 PrefHashFilter::TrackedPreferenceMetadata pref_reset_time_config = 153 PrefHashFilter::TrackedPreferenceMetadata pref_reset_time_config = {
123 {configuration_.rbegin()->reporting_id + 1, 154 configuration_.rbegin()->reporting_id + 1,
124 user_prefs::kPreferenceResetTime, 155 user_prefs::kPreferenceResetTime,
125 PrefHashFilter::ENFORCE_ON_LOAD, 156 PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
126 PrefHashFilter::TRACKING_STRATEGY_ATOMIC}; 157 PrefHashFilter::PrefTrackingStrategy::ATOMIC};
127 configuration_.push_back(pref_reset_time_config); 158 configuration_.push_back(pref_reset_time_config);
128 159
129 ASSERT_TRUE(profile_dir_.CreateUniqueTempDir()); 160 ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
130 ReloadConfiguration(); 161 ReloadConfiguration();
131 } 162 }
132 163
133 void ReloadConfiguration() { 164 void ReloadConfiguration() {
134 manager_.reset(new ProfilePrefStoreManager( 165 manager_.reset(new ProfilePrefStoreManager(
135 profile_dir_.GetPath(), configuration_, kReportingIdCount, seed_, 166 profile_dir_.GetPath(), configuration_, kReportingIdCount, seed_,
136 "device_id", &local_state_)); 167 "device_id", &local_state_));
(...skipping 26 matching lines...) Expand all
163 194
164 std::unique_ptr<PrefService> pref_service( 195 std::unique_ptr<PrefService> pref_service(
165 pref_service_factory.Create(profile_pref_registry_.get())); 196 pref_service_factory.Create(profile_pref_registry_.get()));
166 197
167 ProfilePrefStoreManager::ClearResetTime(pref_service.get()); 198 ProfilePrefStoreManager::ClearResetTime(pref_service.get());
168 } 199 }
169 200
170 void InitializePrefs() { 201 void InitializePrefs() {
171 // According to the implementation of ProfilePrefStoreManager, this is 202 // According to the implementation of ProfilePrefStoreManager, this is
172 // actually a SegregatedPrefStore backed by two underlying pref stores. 203 // actually a SegregatedPrefStore backed by two underlying pref stores.
204 mock_validation_delegate_ = base::MakeUnique<MockValidationDelegate>(
205 mock_validation_delegate_record_);
206 prefs::mojom::PersistentPrefStoreConnectorPtr connector;
173 scoped_refptr<PersistentPrefStore> pref_store = 207 scoped_refptr<PersistentPrefStore> pref_store =
174 manager_->CreateProfilePrefStore( 208 manager_->CreateProfilePrefStore(
175 main_message_loop_.task_runner(), 209 main_message_loop_.task_runner(), main_message_loop_.task_runner(),
176 base::Bind(&ProfilePrefStoreManagerTest::RecordReset, 210 base::Bind(&ProfilePrefStoreManagerTest::RecordReset,
177 base::Unretained(this)), 211 base::Unretained(this)),
178 mock_validation_delegate_.get()); 212 &mock_validation_delegate_, &connector);
213 if (!pref_store) {
214 ASSERT_TRUE(connector);
215 pref_store = new prefs::PersistentPrefStoreMojo(std::move(connector));
216 }
179 InitializePrefStore(pref_store.get()); 217 InitializePrefStore(pref_store.get());
180 pref_store = NULL; 218 pref_store = NULL;
181 base::RunLoop().RunUntilIdle(); 219 base::RunLoop().RunUntilIdle();
182 } 220 }
183 221
184 void DestroyPrefStore() { 222 void DestroyPrefStore() {
185 if (pref_store_.get()) { 223 if (pref_store_.get()) {
186 ClearResetRecorded(); 224 ClearResetRecorded();
187 // Force everything to be written to disk, triggering the PrefHashFilter 225 // Force everything to be written to disk, triggering the PrefHashFilter
188 // while our RegistryVerifier is watching. 226 // while our RegistryVerifier is watching.
189 pref_store_->CommitPendingWrite(); 227 pref_store_->CommitPendingWrite();
190 base::RunLoop().RunUntilIdle(); 228 base::RunLoop().RunUntilIdle();
191 229
192 pref_store_->RemoveObserver(&registry_verifier_); 230 pref_store_->RemoveObserver(&registry_verifier_);
193 pref_store_ = NULL; 231 pref_store_ = NULL;
194 // Nothing should have to happen on the background threads, but just in 232 // Nothing should have to happen on the background threads, but just in
195 // case... 233 // case...
196 base::RunLoop().RunUntilIdle(); 234 base::RunLoop().RunUntilIdle();
197 } 235 }
198 } 236 }
199 237
200 void InitializePrefStore(PersistentPrefStore* pref_store) { 238 void InitializePrefStore(PersistentPrefStore* pref_store) {
201 pref_store->AddObserver(&registry_verifier_); 239 pref_store->AddObserver(&registry_verifier_);
202 PersistentPrefStore::PrefReadError error = pref_store->ReadPrefs(); 240 PrefStoreReadObserver read_observer(pref_store);
241 PersistentPrefStore::PrefReadError error = read_observer.Read();
203 EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE, error); 242 EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE, error);
204 pref_store->SetValue(kTrackedAtomic, base::MakeUnique<base::Value>(kFoobar), 243 pref_store->SetValue(kTrackedAtomic, base::MakeUnique<base::Value>(kFoobar),
205 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); 244 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
206 pref_store->SetValue(kProtectedAtomic, 245 pref_store->SetValue(kProtectedAtomic,
207 base::MakeUnique<base::Value>(kHelloWorld), 246 base::MakeUnique<base::Value>(kHelloWorld),
208 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); 247 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
209 pref_store->SetValue(kUnprotectedPref, 248 pref_store->SetValue(kUnprotectedPref,
210 base::MakeUnique<base::Value>(kFoobar), 249 base::MakeUnique<base::Value>(kFoobar),
211 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); 250 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
212 pref_store->RemoveObserver(&registry_verifier_); 251 pref_store->RemoveObserver(&registry_verifier_);
213 pref_store->CommitPendingWrite(); 252 pref_store->CommitPendingWrite();
214 base::RunLoop().RunUntilIdle(); 253 base::RunLoop().RunUntilIdle();
215 } 254 }
216 255
217 void LoadExistingPrefs() { 256 void LoadExistingPrefs() {
218 DestroyPrefStore(); 257 DestroyPrefStore();
258 std::unique_ptr<prefs::mojom::TrackedPreferenceValidationDelegate>
259 validation_delegate;
260 prefs::mojom::PersistentPrefStoreConnectorPtr connector;
219 pref_store_ = manager_->CreateProfilePrefStore( 261 pref_store_ = manager_->CreateProfilePrefStore(
220 main_message_loop_.task_runner(), 262 main_message_loop_.task_runner(), main_message_loop_.task_runner(),
221 base::Bind(&ProfilePrefStoreManagerTest::RecordReset, 263 base::Bind(&ProfilePrefStoreManagerTest::RecordReset,
222 base::Unretained(this)), 264 base::Unretained(this)),
223 NULL); 265 &validation_delegate, &connector);
266 if (!pref_store_) {
267 ASSERT_TRUE(connector);
268 pref_store_ = new prefs::PersistentPrefStoreMojo(std::move(connector));
269 }
224 pref_store_->AddObserver(&registry_verifier_); 270 pref_store_->AddObserver(&registry_verifier_);
225 pref_store_->ReadPrefs(); 271 PrefStoreReadObserver read_observer(pref_store_);
272 read_observer.Read();
226 } 273 }
227 274
228 void ReplaceStringInPrefs(const std::string& find, 275 void ReplaceStringInPrefs(const std::string& find,
229 const std::string& replace) { 276 const std::string& replace) {
230 base::FileEnumerator file_enum(profile_dir_.GetPath(), true, 277 base::FileEnumerator file_enum(profile_dir_.GetPath(), true,
231 base::FileEnumerator::FILES); 278 base::FileEnumerator::FILES);
232 279
233 for (base::FilePath path = file_enum.Next(); !path.empty(); 280 for (base::FilePath path = file_enum.Next(); !path.empty();
234 path = file_enum.Next()) { 281 path = file_enum.Next()) {
235 // Tamper with the file's contents 282 // Tamper with the file's contents
(...skipping 26 matching lines...) Expand all
262 ADD_FAILURE() << "No validation observed for preference: " << pref_path; 309 ADD_FAILURE() << "No validation observed for preference: " << pref_path;
263 } 310 }
264 311
265 base::MessageLoop main_message_loop_; 312 base::MessageLoop main_message_loop_;
266 std::vector<PrefHashFilter::TrackedPreferenceMetadata> configuration_; 313 std::vector<PrefHashFilter::TrackedPreferenceMetadata> configuration_;
267 base::ScopedTempDir profile_dir_; 314 base::ScopedTempDir profile_dir_;
268 TestingPrefServiceSimple local_state_; 315 TestingPrefServiceSimple local_state_;
269 scoped_refptr<user_prefs::PrefRegistrySyncable> profile_pref_registry_; 316 scoped_refptr<user_prefs::PrefRegistrySyncable> profile_pref_registry_;
270 RegistryVerifier registry_verifier_; 317 RegistryVerifier registry_verifier_;
271 scoped_refptr<MockValidationDelegateRecord> mock_validation_delegate_record_; 318 scoped_refptr<MockValidationDelegateRecord> mock_validation_delegate_record_;
272 std::unique_ptr<MockValidationDelegate> mock_validation_delegate_; 319 std::unique_ptr<prefs::mojom::TrackedPreferenceValidationDelegate>
320 mock_validation_delegate_;
273 std::unique_ptr<ProfilePrefStoreManager> manager_; 321 std::unique_ptr<ProfilePrefStoreManager> manager_;
274 scoped_refptr<PersistentPrefStore> pref_store_; 322 scoped_refptr<PersistentPrefStore> pref_store_;
275 323
276 std::string seed_; 324 std::string seed_;
277 325
278 private: 326 private:
279 void RecordReset() { 327 void RecordReset() {
280 // As-is |reset_recorded_| is only designed to remember a single reset, make 328 // As-is |reset_recorded_| is only designed to remember a single reset, make
281 // sure none was previously recorded (or that ClearResetRecorded() was 329 // sure none was previously recorded (or that ClearResetRecorded() was
282 // called). 330 // called).
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after
351 DestroyPrefStore(); 399 DestroyPrefStore();
352 400
353 ReplaceStringInPrefs(kFoobar, kBarfoo); 401 ReplaceStringInPrefs(kFoobar, kBarfoo);
354 402
355 // It's unprotected, so we can load the modified value. 403 // It's unprotected, so we can load the modified value.
356 LoadExistingPrefs(); 404 LoadExistingPrefs();
357 ExpectStringValueEquals(kUnprotectedPref, kBarfoo); 405 ExpectStringValueEquals(kUnprotectedPref, kBarfoo);
358 406
359 // Now update the configuration to protect it. 407 // Now update the configuration to protect it.
360 PrefHashFilter::TrackedPreferenceMetadata new_protected = { 408 PrefHashFilter::TrackedPreferenceMetadata new_protected = {
361 kExtraReportingId, kUnprotectedPref, PrefHashFilter::ENFORCE_ON_LOAD, 409 kExtraReportingId, kUnprotectedPref,
362 PrefHashFilter::TRACKING_STRATEGY_ATOMIC}; 410 PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
411 PrefHashFilter::PrefTrackingStrategy::ATOMIC};
363 configuration_.push_back(new_protected); 412 configuration_.push_back(new_protected);
364 ReloadConfiguration(); 413 ReloadConfiguration();
365 414
366 // And try loading with the new configuration. 415 // And try loading with the new configuration.
367 LoadExistingPrefs(); 416 LoadExistingPrefs();
368 417
369 // Since there was a valid super MAC we were able to extend the existing trust 418 // Since there was a valid super MAC we were able to extend the existing trust
370 // to the newly protected preference. 419 // to the newly protected preference.
371 ExpectStringValueEquals(kUnprotectedPref, kBarfoo); 420 ExpectStringValueEquals(kUnprotectedPref, kBarfoo);
372 VerifyResetRecorded(false); 421 VerifyResetRecorded(false);
(...skipping 11 matching lines...) Expand all
384 ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking); 433 ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking);
385 } 434 }
386 435
387 TEST_F(ProfilePrefStoreManagerTest, NewPrefWhenFirstProtecting) { 436 TEST_F(ProfilePrefStoreManagerTest, NewPrefWhenFirstProtecting) {
388 std::vector<PrefHashFilter::TrackedPreferenceMetadata> 437 std::vector<PrefHashFilter::TrackedPreferenceMetadata>
389 original_configuration = configuration_; 438 original_configuration = configuration_;
390 for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it = 439 for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it =
391 configuration_.begin(); 440 configuration_.begin();
392 it != configuration_.end(); 441 it != configuration_.end();
393 ++it) { 442 ++it) {
394 it->enforcement_level = PrefHashFilter::NO_ENFORCEMENT; 443 it->enforcement_level = PrefHashFilter::EnforcementLevel::NO_ENFORCEMENT;
395 } 444 }
396 ReloadConfiguration(); 445 ReloadConfiguration();
397 446
398 InitializePrefs(); 447 InitializePrefs();
399 448
400 ExpectValidationObserved(kTrackedAtomic); 449 ExpectValidationObserved(kTrackedAtomic);
401 ExpectValidationObserved(kProtectedAtomic); 450 ExpectValidationObserved(kProtectedAtomic);
402 451
403 LoadExistingPrefs(); 452 LoadExistingPrefs();
404 ExpectStringValueEquals(kUnprotectedPref, kFoobar); 453 ExpectStringValueEquals(kUnprotectedPref, kFoobar);
405 454
406 // Ensure everything is written out to disk. 455 // Ensure everything is written out to disk.
407 DestroyPrefStore(); 456 DestroyPrefStore();
408 457
409 // Now introduce protection, including the never-before tracked "new_pref". 458 // Now introduce protection, including the never-before tracked "new_pref".
410 configuration_ = original_configuration; 459 configuration_ = original_configuration;
411 PrefHashFilter::TrackedPreferenceMetadata new_protected = { 460 PrefHashFilter::TrackedPreferenceMetadata new_protected = {
412 kExtraReportingId, kUnprotectedPref, PrefHashFilter::ENFORCE_ON_LOAD, 461 kExtraReportingId, kUnprotectedPref,
413 PrefHashFilter::TRACKING_STRATEGY_ATOMIC}; 462 PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
463 PrefHashFilter::PrefTrackingStrategy::ATOMIC};
414 configuration_.push_back(new_protected); 464 configuration_.push_back(new_protected);
415 ReloadConfiguration(); 465 ReloadConfiguration();
416 466
417 // And try loading with the new configuration. 467 // And try loading with the new configuration.
418 LoadExistingPrefs(); 468 LoadExistingPrefs();
419 469
420 // Since there was a valid super MAC we were able to extend the existing trust 470 // Since there was a valid super MAC we were able to extend the existing trust
421 // to the newly tracked & protected preference. 471 // to the newly tracked & protected preference.
422 ExpectStringValueEquals(kUnprotectedPref, kFoobar); 472 ExpectStringValueEquals(kUnprotectedPref, kFoobar);
423 VerifyResetRecorded(false); 473 VerifyResetRecorded(false);
424 } 474 }
425 475
426 TEST_F(ProfilePrefStoreManagerTest, UnprotectedToProtectedWithoutTrust) { 476 TEST_F(ProfilePrefStoreManagerTest, UnprotectedToProtectedWithoutTrust) {
427 InitializePrefs(); 477 InitializePrefs();
428 478
429 ExpectValidationObserved(kTrackedAtomic); 479 ExpectValidationObserved(kTrackedAtomic);
430 ExpectValidationObserved(kProtectedAtomic); 480 ExpectValidationObserved(kProtectedAtomic);
431 481
432 // Now update the configuration to protect it. 482 // Now update the configuration to protect it.
433 PrefHashFilter::TrackedPreferenceMetadata new_protected = { 483 PrefHashFilter::TrackedPreferenceMetadata new_protected = {
434 kExtraReportingId, kUnprotectedPref, PrefHashFilter::ENFORCE_ON_LOAD, 484 kExtraReportingId, kUnprotectedPref,
435 PrefHashFilter::TRACKING_STRATEGY_ATOMIC}; 485 PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
486 PrefHashFilter::PrefTrackingStrategy::ATOMIC};
436 configuration_.push_back(new_protected); 487 configuration_.push_back(new_protected);
437 seed_ = "new-seed-to-break-trust"; 488 seed_ = "new-seed-to-break-trust";
438 ReloadConfiguration(); 489 ReloadConfiguration();
439 490
440 // And try loading with the new configuration. 491 // And try loading with the new configuration.
441 LoadExistingPrefs(); 492 LoadExistingPrefs();
442 493
443 // If preference tracking is supported, kUnprotectedPref will have been 494 // If preference tracking is supported, kUnprotectedPref will have been
444 // discarded because new values are not accepted without a valid super MAC. 495 // discarded because new values are not accepted without a valid super MAC.
445 EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking, 496 EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
(...skipping 11 matching lines...) Expand all
457 ExpectValidationObserved(kProtectedAtomic); 508 ExpectValidationObserved(kProtectedAtomic);
458 509
459 DestroyPrefStore(); 510 DestroyPrefStore();
460 511
461 // Unconfigure protection for kProtectedAtomic 512 // Unconfigure protection for kProtectedAtomic
462 for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it = 513 for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it =
463 configuration_.begin(); 514 configuration_.begin();
464 it != configuration_.end(); 515 it != configuration_.end();
465 ++it) { 516 ++it) {
466 if (it->name == kProtectedAtomic) { 517 if (it->name == kProtectedAtomic) {
467 it->enforcement_level = PrefHashFilter::NO_ENFORCEMENT; 518 it->enforcement_level = PrefHashFilter::EnforcementLevel::NO_ENFORCEMENT;
468 break; 519 break;
469 } 520 }
470 } 521 }
471 522
472 seed_ = "new-seed-to-break-trust"; 523 seed_ = "new-seed-to-break-trust";
473 ReloadConfiguration(); 524 ReloadConfiguration();
474 LoadExistingPrefs(); 525 LoadExistingPrefs();
475 526
476 // Verify that the value was not reset. 527 // Verify that the value was not reset.
477 ExpectStringValueEquals(kProtectedAtomic, kHelloWorld); 528 ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
478 VerifyResetRecorded(false); 529 VerifyResetRecorded(false);
479 530
480 // Accessing the value of the previously protected pref didn't trigger its 531 // Accessing the value of the previously protected pref didn't trigger its
481 // move to the unprotected preferences file, though the loading of the pref 532 // move to the unprotected preferences file, though the loading of the pref
482 // store should still have caused the MAC store to be recalculated. 533 // store should still have caused the MAC store to be recalculated.
483 LoadExistingPrefs(); 534 LoadExistingPrefs();
484 ExpectStringValueEquals(kProtectedAtomic, kHelloWorld); 535 ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
485 536
486 // Trigger the logic that migrates it back to the unprotected preferences 537 // Trigger the logic that migrates it back to the unprotected preferences
487 // file. 538 // file.
488 pref_store_->SetValue(kProtectedAtomic, 539 pref_store_->SetValue(kProtectedAtomic,
489 base::WrapUnique(new base::Value(kGoodbyeWorld)), 540 base::WrapUnique(new base::Value(kGoodbyeWorld)),
490 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); 541 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
491 LoadExistingPrefs(); 542 LoadExistingPrefs();
492 ExpectStringValueEquals(kProtectedAtomic, kGoodbyeWorld); 543 ExpectStringValueEquals(kProtectedAtomic, kGoodbyeWorld);
493 VerifyResetRecorded(false); 544 VerifyResetRecorded(false);
494 } 545 }
OLDNEW
« no previous file with comments | « chrome/browser/prefs/profile_pref_store_manager.cc ('k') | chrome/browser/profiles/profile_browsertest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698