OLD | NEW |
---|---|
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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/pref_hash_filter.h" | 5 #include "chrome/browser/prefs/pref_hash_filter.h" |
6 | 6 |
7 #include <map> | 7 #include <map> |
8 #include <set> | 8 #include <set> |
9 #include <string> | 9 #include <string> |
10 #include <utility> | 10 #include <utility> |
11 #include <vector> | 11 #include <vector> |
12 | 12 |
13 #include "base/basictypes.h" | 13 #include "base/basictypes.h" |
14 #include "base/bind.h" | 14 #include "base/bind.h" |
15 #include "base/callback_forward.h" | 15 #include "base/callback_forward.h" |
16 #include "base/compiler_specific.h" | 16 #include "base/compiler_specific.h" |
17 #include "base/logging.h" | 17 #include "base/logging.h" |
18 #include "base/memory/ref_counted.h" | 18 #include "base/memory/ref_counted.h" |
19 #include "base/memory/scoped_ptr.h" | 19 #include "base/memory/scoped_ptr.h" |
20 #include "base/prefs/testing_pref_store.h" | |
20 #include "base/values.h" | 21 #include "base/values.h" |
21 #include "chrome/browser/prefs/pref_hash_store.h" | 22 #include "chrome/browser/prefs/pref_hash_store.h" |
22 #include "chrome/browser/prefs/pref_hash_store_transaction.h" | 23 #include "chrome/browser/prefs/pref_hash_store_transaction.h" |
23 #include "chrome/common/pref_names.h" | 24 #include "chrome/common/pref_names.h" |
24 #include "testing/gtest/include/gtest/gtest.h" | 25 #include "testing/gtest/include/gtest/gtest.h" |
25 | 26 |
26 namespace { | 27 namespace { |
27 | 28 |
28 const char kAtomicPref[] = "atomic_pref"; | 29 const char kAtomicPref[] = "atomic_pref"; |
29 const char kAtomicPref2[] = "atomic_pref2"; | 30 const char kAtomicPref2[] = "atomic_pref2"; |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
61 | 62 |
62 } // namespace | 63 } // namespace |
63 | 64 |
64 // A PrefHashStore that allows simulation of CheckValue results and captures | 65 // A PrefHashStore that allows simulation of CheckValue results and captures |
65 // checked and stored values. | 66 // checked and stored values. |
66 class MockPrefHashStore : public PrefHashStore { | 67 class MockPrefHashStore : public PrefHashStore { |
67 public: | 68 public: |
68 typedef std::pair<const void*, PrefHashFilter::PrefTrackingStrategy> | 69 typedef std::pair<const void*, PrefHashFilter::PrefTrackingStrategy> |
69 ValuePtrStrategyPair; | 70 ValuePtrStrategyPair; |
70 | 71 |
71 MockPrefHashStore() : transactions_expected_(1), | 72 MockPrefHashStore() : transactions_performed_(0), |
72 transactions_performed_(0), | |
73 transaction_active_(false) {} | 73 transaction_active_(false) {} |
74 | 74 |
75 virtual ~MockPrefHashStore() { | 75 virtual ~MockPrefHashStore() { |
76 EXPECT_EQ(transactions_expected_, transactions_performed_); | |
77 EXPECT_FALSE(transaction_active_); | 76 EXPECT_FALSE(transaction_active_); |
78 } | 77 } |
79 | 78 |
80 // Set the result that will be returned when |path| is passed to | 79 // Set the result that will be returned when |path| is passed to |
81 // |CheckValue/CheckSplitValue|. | 80 // |CheckValue/CheckSplitValue|. |
82 void SetCheckResult(const std::string& path, | 81 void SetCheckResult(const std::string& path, |
83 PrefHashStoreTransaction::ValueState result); | 82 PrefHashStoreTransaction::ValueState result); |
84 | 83 |
85 // Set the invalid_keys that will be returned when |path| is passed to | 84 // Set the invalid_keys that will be returned when |path| is passed to |
86 // |CheckSplitValue|. SetCheckResult should already have been called for | 85 // |CheckSplitValue|. SetCheckResult should already have been called for |
87 // |path| with |result == CHANGED| for this to make any sense. | 86 // |path| with |result == CHANGED| for this to make any sense. |
88 void SetInvalidKeysResult( | 87 void SetInvalidKeysResult( |
89 const std::string& path, | 88 const std::string& path, |
90 const std::vector<std::string>& invalid_keys_result); | 89 const std::vector<std::string>& invalid_keys_result); |
91 | 90 |
92 void set_transactions_expected(size_t transactions_expected) { | 91 // Returns the number of transactions that were performed. |
93 transactions_expected_ = transactions_expected; | 92 size_t transactions_performed() { return transactions_performed_; } |
94 } | |
95 | 93 |
96 // Returns the number of paths checked. | 94 // Returns the number of paths checked. |
97 size_t checked_paths_count() const { | 95 size_t checked_paths_count() const { |
98 return checked_values_.size(); | 96 return checked_values_.size(); |
99 } | 97 } |
100 | 98 |
101 // Returns the number of paths stored. | 99 // Returns the number of paths stored. |
102 size_t stored_paths_count() const { | 100 size_t stored_paths_count() const { |
103 return stored_values_.size(); | 101 return stored_values_.size(); |
104 } | 102 } |
(...skipping 174 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
279 PrefHashFilter::TRACKING_STRATEGY_SPLIT); | 277 PrefHashFilter::TRACKING_STRATEGY_SPLIT); |
280 } | 278 } |
281 | 279 |
282 void MockPrefHashStore::MockPrefHashStoreTransaction::StoreSplitHash( | 280 void MockPrefHashStore::MockPrefHashStoreTransaction::StoreSplitHash( |
283 const std::string& path, | 281 const std::string& path, |
284 const base::DictionaryValue* new_value) { | 282 const base::DictionaryValue* new_value) { |
285 outer_->RecordStoreHash(path, new_value, | 283 outer_->RecordStoreHash(path, new_value, |
286 PrefHashFilter::TRACKING_STRATEGY_SPLIT); | 284 PrefHashFilter::TRACKING_STRATEGY_SPLIT); |
287 } | 285 } |
288 | 286 |
289 // Creates a PrefHashFilter that uses a MockPrefHashStore. The | 287 std::vector<PrefHashFilter::TrackedPreferenceMetadata> GetConfiguration( |
290 // MockPrefHashStore (owned by the PrefHashFilter) is returned in | 288 PrefHashFilter::EnforcementLevel max_enforcement_level) { |
291 // |mock_pref_hash_store|. | |
292 scoped_ptr<PrefHashFilter> CreatePrefHashFilter( | |
293 PrefHashFilter::EnforcementLevel max_enforcement_level, | |
294 MockPrefHashStore** mock_pref_hash_store) { | |
295 scoped_ptr<MockPrefHashStore> temp_mock_pref_hash_store( | |
296 new MockPrefHashStore); | |
297 if (mock_pref_hash_store) | |
298 *mock_pref_hash_store = temp_mock_pref_hash_store.get(); | |
299 std::vector<PrefHashFilter::TrackedPreferenceMetadata> configuration( | 289 std::vector<PrefHashFilter::TrackedPreferenceMetadata> configuration( |
300 kTestTrackedPrefs, kTestTrackedPrefs + arraysize(kTestTrackedPrefs)); | 290 kTestTrackedPrefs, kTestTrackedPrefs + arraysize(kTestTrackedPrefs)); |
301 for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it = | 291 for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it = |
302 configuration.begin(); | 292 configuration.begin(); |
303 it != configuration.end(); | 293 it != configuration.end(); |
304 ++it) { | 294 ++it) { |
305 if (it->enforcement_level > max_enforcement_level) | 295 if (it->enforcement_level > max_enforcement_level) |
306 it->enforcement_level = max_enforcement_level; | 296 it->enforcement_level = max_enforcement_level; |
307 } | 297 } |
308 return scoped_ptr<PrefHashFilter>( | 298 return configuration; |
309 new PrefHashFilter(temp_mock_pref_hash_store.PassAs<PrefHashStore>(), | |
310 configuration, | |
311 arraysize(kTestTrackedPrefs))); | |
312 } | 299 } |
313 | 300 |
314 class PrefHashFilterTest | 301 class PrefHashFilterTest |
315 : public testing::TestWithParam<PrefHashFilter::EnforcementLevel> { | 302 : public testing::TestWithParam<PrefHashFilter::EnforcementLevel> { |
316 public: | 303 public: |
317 PrefHashFilterTest() : mock_pref_hash_store_(NULL) {} | 304 PrefHashFilterTest() : mock_pref_hash_store_(NULL) {} |
318 | 305 |
319 virtual void SetUp() OVERRIDE { | 306 virtual void SetUp() OVERRIDE { |
320 // Construct a PrefHashFilter and MockPrefHashStore for the test. | 307 // Construct a PrefHashFilter and MockPrefHashStore for the test. |
321 pref_hash_filter_ = | 308 InitializePrefHashFilter(GetConfiguration(GetParam())); |
322 CreatePrefHashFilter(GetParam(), &mock_pref_hash_store_); | |
323 } | 309 } |
324 | 310 |
325 protected: | 311 protected: |
312 // Creates a PrefHashFilter that uses a MockPrefHashStore. The | |
313 // MockPrefHashStore (owned by the PrefHashFilter) is returned in | |
314 // |mock_pref_hash_store|. | |
gab
2014/04/01 18:55:06
This comment is wrong, what about:
// Resets |pre
| |
315 void InitializePrefHashFilter(const std::vector< | |
316 PrefHashFilter::TrackedPreferenceMetadata>& configuration) { | |
317 scoped_ptr<MockPrefHashStore> temp_mock_pref_hash_store( | |
318 new MockPrefHashStore); | |
319 mock_pref_hash_store_ = temp_mock_pref_hash_store.get(); | |
320 pref_hash_filter_.reset( | |
321 new PrefHashFilter(temp_mock_pref_hash_store.PassAs<PrefHashStore>(), | |
322 configuration, | |
323 arraysize(kTestTrackedPrefs))); | |
324 } | |
325 | |
326 bool RecordedReset() { | 326 bool RecordedReset() { |
327 return pref_store_contents_.Get(prefs::kPreferenceResetTime, NULL); | 327 return pref_store_contents_.Get(prefs::kPreferenceResetTime, NULL); |
328 } | 328 } |
329 | 329 |
330 MockPrefHashStore* mock_pref_hash_store_; | 330 MockPrefHashStore* mock_pref_hash_store_; |
331 base::DictionaryValue pref_store_contents_; | 331 base::DictionaryValue pref_store_contents_; |
332 scoped_ptr<PrefHashFilter> pref_hash_filter_; | 332 scoped_ptr<PrefHashFilter> pref_hash_filter_; |
333 | 333 |
334 DISALLOW_COPY_AND_ASSIGN(PrefHashFilterTest); | 334 DISALLOW_COPY_AND_ASSIGN(PrefHashFilterTest); |
335 }; | 335 }; |
336 | 336 |
337 TEST_P(PrefHashFilterTest, EmptyAndUnchanged) { | 337 TEST_P(PrefHashFilterTest, EmptyAndUnchanged) { |
338 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 338 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); |
339 // All paths checked. | 339 // All paths checked. |
340 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 340 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
341 mock_pref_hash_store_->checked_paths_count()); | 341 mock_pref_hash_store_->checked_paths_count()); |
342 // No paths stored, since they all return |UNCHANGED|. | 342 // No paths stored, since they all return |UNCHANGED|. |
343 ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count()); | 343 ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count()); |
344 // Since there was nothing in |pref_store_contents_| the checked value should | 344 // Since there was nothing in |pref_store_contents_| the checked value should |
345 // have been NULL for all tracked preferences. | 345 // have been NULL for all tracked preferences. |
346 for (size_t i = 0; i < arraysize(kTestTrackedPrefs); ++i) { | 346 for (size_t i = 0; i < arraysize(kTestTrackedPrefs); ++i) { |
347 ASSERT_EQ(NULL, mock_pref_hash_store_->checked_value( | 347 ASSERT_EQ(NULL, mock_pref_hash_store_->checked_value( |
348 kTestTrackedPrefs[i].name).first); | 348 kTestTrackedPrefs[i].name).first); |
349 } | 349 } |
350 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | |
350 ASSERT_FALSE(RecordedReset()); | 351 ASSERT_FALSE(RecordedReset()); |
351 } | 352 } |
352 | 353 |
353 TEST_P(PrefHashFilterTest, FilterTrackedPrefUpdate) { | 354 TEST_P(PrefHashFilterTest, FilterTrackedPrefUpdate) { |
354 base::DictionaryValue root_dict; | 355 base::DictionaryValue root_dict; |
355 // Ownership of |string_value| is transfered to |root_dict|. | 356 // Ownership of |string_value| is transfered to |root_dict|. |
356 base::Value* string_value = base::Value::CreateStringValue("string value"); | 357 base::Value* string_value = base::Value::CreateStringValue("string value"); |
357 root_dict.Set(kAtomicPref, string_value); | 358 root_dict.Set(kAtomicPref, string_value); |
358 | 359 |
359 // No path should be stored on FilterUpdate. | 360 // No path should be stored on FilterUpdate. |
360 pref_hash_filter_->FilterUpdate(kAtomicPref); | 361 pref_hash_filter_->FilterUpdate(kAtomicPref); |
361 ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count()); | 362 ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count()); |
362 | 363 |
363 // One path should be stored on FilterSerializeData. | 364 // One path should be stored on FilterSerializeData. |
364 pref_hash_filter_->FilterSerializeData(&root_dict); | 365 pref_hash_filter_->FilterSerializeData(&root_dict); |
365 ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count()); | 366 ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count()); |
366 MockPrefHashStore::ValuePtrStrategyPair stored_value = | 367 MockPrefHashStore::ValuePtrStrategyPair stored_value = |
367 mock_pref_hash_store_->stored_value(kAtomicPref); | 368 mock_pref_hash_store_->stored_value(kAtomicPref); |
368 ASSERT_EQ(string_value, stored_value.first); | 369 ASSERT_EQ(string_value, stored_value.first); |
369 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, stored_value.second); | 370 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, stored_value.second); |
370 | 371 |
372 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | |
371 ASSERT_FALSE(RecordedReset()); | 373 ASSERT_FALSE(RecordedReset()); |
372 } | 374 } |
373 | 375 |
374 TEST_P(PrefHashFilterTest, FilterSplitPrefUpdate) { | 376 TEST_P(PrefHashFilterTest, FilterSplitPrefUpdate) { |
375 base::DictionaryValue root_dict; | 377 base::DictionaryValue root_dict; |
376 // Ownership of |dict_value| is transfered to |root_dict|. | 378 // Ownership of |dict_value| is transfered to |root_dict|. |
377 base::DictionaryValue* dict_value = new base::DictionaryValue; | 379 base::DictionaryValue* dict_value = new base::DictionaryValue; |
378 dict_value->SetString("a", "foo"); | 380 dict_value->SetString("a", "foo"); |
379 dict_value->SetInteger("b", 1234); | 381 dict_value->SetInteger("b", 1234); |
380 root_dict.Set(kSplitPref, dict_value); | 382 root_dict.Set(kSplitPref, dict_value); |
381 | 383 |
382 // No path should be stored on FilterUpdate. | 384 // No path should be stored on FilterUpdate. |
383 pref_hash_filter_->FilterUpdate(kSplitPref); | 385 pref_hash_filter_->FilterUpdate(kSplitPref); |
384 ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count()); | 386 ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count()); |
385 | 387 |
386 // One path should be stored on FilterSerializeData. | 388 // One path should be stored on FilterSerializeData. |
387 pref_hash_filter_->FilterSerializeData(&root_dict); | 389 pref_hash_filter_->FilterSerializeData(&root_dict); |
388 ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count()); | 390 ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count()); |
389 MockPrefHashStore::ValuePtrStrategyPair stored_value = | 391 MockPrefHashStore::ValuePtrStrategyPair stored_value = |
390 mock_pref_hash_store_->stored_value(kSplitPref); | 392 mock_pref_hash_store_->stored_value(kSplitPref); |
391 ASSERT_EQ(dict_value, stored_value.first); | 393 ASSERT_EQ(dict_value, stored_value.first); |
392 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_value.second); | 394 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_value.second); |
393 | 395 |
396 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | |
394 ASSERT_FALSE(RecordedReset()); | 397 ASSERT_FALSE(RecordedReset()); |
395 } | 398 } |
396 | 399 |
397 TEST_P(PrefHashFilterTest, FilterUntrackedPrefUpdate) { | 400 TEST_P(PrefHashFilterTest, FilterUntrackedPrefUpdate) { |
398 // No transaction should even be started on FilterSerializeData() if there are | |
399 // no updates to perform. | |
400 mock_pref_hash_store_->set_transactions_expected(0); | |
401 | |
402 base::DictionaryValue root_dict; | 401 base::DictionaryValue root_dict; |
403 root_dict.Set("untracked", base::Value::CreateStringValue("some value")); | 402 root_dict.Set("untracked", base::Value::CreateStringValue("some value")); |
404 pref_hash_filter_->FilterUpdate("untracked"); | 403 pref_hash_filter_->FilterUpdate("untracked"); |
405 | 404 |
406 // No paths should be stored on FilterUpdate. | 405 // No paths should be stored on FilterUpdate. |
407 ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count()); | 406 ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count()); |
408 | 407 |
409 // Nor on FilterSerializeData. | 408 // Nor on FilterSerializeData. |
410 pref_hash_filter_->FilterSerializeData(&root_dict); | 409 pref_hash_filter_->FilterSerializeData(&root_dict); |
411 ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count()); | 410 ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count()); |
411 | |
412 // No transaction should even be started on FilterSerializeData() if there are | |
413 // no updates to perform. | |
414 ASSERT_EQ(0u, mock_pref_hash_store_->transactions_performed()); | |
412 } | 415 } |
413 | 416 |
414 TEST_P(PrefHashFilterTest, MultiplePrefsFilterSerializeData) { | 417 TEST_P(PrefHashFilterTest, MultiplePrefsFilterSerializeData) { |
415 base::DictionaryValue root_dict; | 418 base::DictionaryValue root_dict; |
416 // Ownership of the following values is transfered to |root_dict|. | 419 // Ownership of the following values is transfered to |root_dict|. |
417 base::Value* int_value1 = base::Value::CreateIntegerValue(1); | 420 base::Value* int_value1 = base::Value::CreateIntegerValue(1); |
418 base::Value* int_value2 = base::Value::CreateIntegerValue(2); | 421 base::Value* int_value2 = base::Value::CreateIntegerValue(2); |
419 base::Value* int_value3 = base::Value::CreateIntegerValue(3); | 422 base::Value* int_value3 = base::Value::CreateIntegerValue(3); |
420 base::Value* int_value4 = base::Value::CreateIntegerValue(4); | 423 base::Value* int_value4 = base::Value::CreateIntegerValue(4); |
421 base::DictionaryValue* dict_value = new base::DictionaryValue; | 424 base::DictionaryValue* dict_value = new base::DictionaryValue; |
(...skipping 17 matching lines...) Expand all Loading... | |
439 | 442 |
440 // On FilterSerializeData, only kAtomicPref, kAtomicPref3, and kSplitPref | 443 // On FilterSerializeData, only kAtomicPref, kAtomicPref3, and kSplitPref |
441 // should get a new hash. | 444 // should get a new hash. |
442 pref_hash_filter_->FilterSerializeData(&root_dict); | 445 pref_hash_filter_->FilterSerializeData(&root_dict); |
443 ASSERT_EQ(3u, mock_pref_hash_store_->stored_paths_count()); | 446 ASSERT_EQ(3u, mock_pref_hash_store_->stored_paths_count()); |
444 MockPrefHashStore::ValuePtrStrategyPair stored_value_atomic1 = | 447 MockPrefHashStore::ValuePtrStrategyPair stored_value_atomic1 = |
445 mock_pref_hash_store_->stored_value(kAtomicPref); | 448 mock_pref_hash_store_->stored_value(kAtomicPref); |
446 ASSERT_EQ(int_value1, stored_value_atomic1.first); | 449 ASSERT_EQ(int_value1, stored_value_atomic1.first); |
447 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, | 450 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, |
448 stored_value_atomic1.second); | 451 stored_value_atomic1.second); |
452 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | |
449 | 453 |
450 MockPrefHashStore::ValuePtrStrategyPair stored_value_atomic3 = | 454 MockPrefHashStore::ValuePtrStrategyPair stored_value_atomic3 = |
451 mock_pref_hash_store_->stored_value(kAtomicPref3); | 455 mock_pref_hash_store_->stored_value(kAtomicPref3); |
452 ASSERT_EQ(int_value5, stored_value_atomic3.first); | 456 ASSERT_EQ(int_value5, stored_value_atomic3.first); |
453 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, | 457 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, |
454 stored_value_atomic3.second); | 458 stored_value_atomic3.second); |
455 | 459 |
456 MockPrefHashStore::ValuePtrStrategyPair stored_value_split = | 460 MockPrefHashStore::ValuePtrStrategyPair stored_value_split = |
457 mock_pref_hash_store_->stored_value(kSplitPref); | 461 mock_pref_hash_store_->stored_value(kSplitPref); |
458 ASSERT_EQ(dict_value, stored_value_split.first); | 462 ASSERT_EQ(dict_value, stored_value_split.first); |
459 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_value_split.second); | 463 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_value_split.second); |
460 } | 464 } |
461 | 465 |
462 TEST_P(PrefHashFilterTest, EmptyAndUnknown) { | 466 TEST_P(PrefHashFilterTest, EmptyAndUnknown) { |
463 ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL)); | 467 ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL)); |
464 ASSERT_FALSE(pref_store_contents_.Get(kSplitPref, NULL)); | 468 ASSERT_FALSE(pref_store_contents_.Get(kSplitPref, NULL)); |
465 // NULL values are always trusted by the PrefHashStore. | 469 // NULL values are always trusted by the PrefHashStore. |
466 mock_pref_hash_store_->SetCheckResult( | 470 mock_pref_hash_store_->SetCheckResult( |
467 kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); | 471 kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); |
468 mock_pref_hash_store_->SetCheckResult( | 472 mock_pref_hash_store_->SetCheckResult( |
469 kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); | 473 kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); |
470 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 474 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); |
471 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 475 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
472 mock_pref_hash_store_->checked_paths_count()); | 476 mock_pref_hash_store_->checked_paths_count()); |
473 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); | 477 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); |
478 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | |
474 | 479 |
475 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = | 480 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = |
476 mock_pref_hash_store_->stored_value(kAtomicPref); | 481 mock_pref_hash_store_->stored_value(kAtomicPref); |
477 ASSERT_EQ(NULL, stored_atomic_value.first); | 482 ASSERT_EQ(NULL, stored_atomic_value.first); |
478 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, | 483 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, |
479 stored_atomic_value.second); | 484 stored_atomic_value.second); |
480 | 485 |
481 MockPrefHashStore::ValuePtrStrategyPair stored_split_value = | 486 MockPrefHashStore::ValuePtrStrategyPair stored_split_value = |
482 mock_pref_hash_store_->stored_value(kSplitPref); | 487 mock_pref_hash_store_->stored_value(kSplitPref); |
483 ASSERT_EQ(NULL, stored_split_value.first); | 488 ASSERT_EQ(NULL, stored_split_value.first); |
(...skipping 15 matching lines...) Expand all Loading... | |
499 ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL)); | 504 ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL)); |
500 | 505 |
501 mock_pref_hash_store_->SetCheckResult( | 506 mock_pref_hash_store_->SetCheckResult( |
502 kAtomicPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE); | 507 kAtomicPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE); |
503 mock_pref_hash_store_->SetCheckResult( | 508 mock_pref_hash_store_->SetCheckResult( |
504 kSplitPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE); | 509 kSplitPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE); |
505 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 510 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); |
506 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 511 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
507 mock_pref_hash_store_->checked_paths_count()); | 512 mock_pref_hash_store_->checked_paths_count()); |
508 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); | 513 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); |
514 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | |
509 | 515 |
510 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = | 516 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = |
511 mock_pref_hash_store_->stored_value(kAtomicPref); | 517 mock_pref_hash_store_->stored_value(kAtomicPref); |
512 MockPrefHashStore::ValuePtrStrategyPair stored_split_value = | 518 MockPrefHashStore::ValuePtrStrategyPair stored_split_value = |
513 mock_pref_hash_store_->stored_value(kSplitPref); | 519 mock_pref_hash_store_->stored_value(kSplitPref); |
514 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, | 520 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, |
515 stored_atomic_value.second); | 521 stored_atomic_value.second); |
516 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, | 522 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, |
517 stored_split_value.second); | 523 stored_split_value.second); |
518 if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) { | 524 if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) { |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
556 ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL)); | 562 ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL)); |
557 | 563 |
558 mock_pref_hash_store_->SetCheckResult( | 564 mock_pref_hash_store_->SetCheckResult( |
559 kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); | 565 kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); |
560 mock_pref_hash_store_->SetCheckResult( | 566 mock_pref_hash_store_->SetCheckResult( |
561 kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); | 567 kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); |
562 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 568 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); |
563 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 569 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
564 mock_pref_hash_store_->checked_paths_count()); | 570 mock_pref_hash_store_->checked_paths_count()); |
565 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); | 571 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); |
572 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | |
566 | 573 |
567 // Seeding is always allowed for trusted unknown values. | 574 // Seeding is always allowed for trusted unknown values. |
568 const base::Value* atomic_value_in_store; | 575 const base::Value* atomic_value_in_store; |
569 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, &atomic_value_in_store)); | 576 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, &atomic_value_in_store)); |
570 ASSERT_EQ(string_value, atomic_value_in_store); | 577 ASSERT_EQ(string_value, atomic_value_in_store); |
571 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = | 578 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = |
572 mock_pref_hash_store_->stored_value(kAtomicPref); | 579 mock_pref_hash_store_->stored_value(kAtomicPref); |
573 ASSERT_EQ(string_value, stored_atomic_value.first); | 580 ASSERT_EQ(string_value, stored_atomic_value.first); |
574 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, | 581 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, |
575 stored_atomic_value.second); | 582 stored_atomic_value.second); |
(...skipping 30 matching lines...) Expand all Loading... | |
606 | 613 |
607 std::vector<std::string> mock_invalid_keys; | 614 std::vector<std::string> mock_invalid_keys; |
608 mock_invalid_keys.push_back("a"); | 615 mock_invalid_keys.push_back("a"); |
609 mock_invalid_keys.push_back("c"); | 616 mock_invalid_keys.push_back("c"); |
610 mock_pref_hash_store_->SetInvalidKeysResult(kSplitPref, mock_invalid_keys); | 617 mock_pref_hash_store_->SetInvalidKeysResult(kSplitPref, mock_invalid_keys); |
611 | 618 |
612 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 619 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); |
613 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 620 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
614 mock_pref_hash_store_->checked_paths_count()); | 621 mock_pref_hash_store_->checked_paths_count()); |
615 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); | 622 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); |
623 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | |
616 | 624 |
617 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = | 625 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = |
618 mock_pref_hash_store_->stored_value(kAtomicPref); | 626 mock_pref_hash_store_->stored_value(kAtomicPref); |
619 MockPrefHashStore::ValuePtrStrategyPair stored_split_value = | 627 MockPrefHashStore::ValuePtrStrategyPair stored_split_value = |
620 mock_pref_hash_store_->stored_value(kSplitPref); | 628 mock_pref_hash_store_->stored_value(kSplitPref); |
621 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, | 629 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, |
622 stored_atomic_value.second); | 630 stored_atomic_value.second); |
623 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, | 631 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, |
624 stored_split_value.second); | 632 stored_split_value.second); |
625 if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) { | 633 if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) { |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
666 ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL)); | 674 ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL)); |
667 ASSERT_FALSE(pref_store_contents_.Get(kSplitPref, NULL)); | 675 ASSERT_FALSE(pref_store_contents_.Get(kSplitPref, NULL)); |
668 mock_pref_hash_store_->SetCheckResult(kAtomicPref, | 676 mock_pref_hash_store_->SetCheckResult(kAtomicPref, |
669 PrefHashStoreTransaction::CLEARED); | 677 PrefHashStoreTransaction::CLEARED); |
670 mock_pref_hash_store_->SetCheckResult(kSplitPref, | 678 mock_pref_hash_store_->SetCheckResult(kSplitPref, |
671 PrefHashStoreTransaction::CLEARED); | 679 PrefHashStoreTransaction::CLEARED); |
672 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 680 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); |
673 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 681 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
674 mock_pref_hash_store_->checked_paths_count()); | 682 mock_pref_hash_store_->checked_paths_count()); |
675 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); | 683 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); |
684 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | |
676 | 685 |
677 // Regardless of the enforcement level, the only thing that should be done is | 686 // Regardless of the enforcement level, the only thing that should be done is |
678 // to restore the hash for NULL. The value itself should still be NULL. | 687 // to restore the hash for NULL. The value itself should still be NULL. |
679 ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL)); | 688 ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL)); |
680 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = | 689 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = |
681 mock_pref_hash_store_->stored_value(kAtomicPref); | 690 mock_pref_hash_store_->stored_value(kAtomicPref); |
682 ASSERT_EQ(NULL, stored_atomic_value.first); | 691 ASSERT_EQ(NULL, stored_atomic_value.first); |
683 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, | 692 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, |
684 stored_atomic_value.second); | 693 stored_atomic_value.second); |
685 | 694 |
(...skipping 14 matching lines...) Expand all Loading... | |
700 pref_store_contents_.Set(kAtomicPref, list_value); | 709 pref_store_contents_.Set(kAtomicPref, list_value); |
701 | 710 |
702 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL)); | 711 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL)); |
703 | 712 |
704 mock_pref_hash_store_->SetCheckResult(kAtomicPref, | 713 mock_pref_hash_store_->SetCheckResult(kAtomicPref, |
705 PrefHashStoreTransaction::WEAK_LEGACY); | 714 PrefHashStoreTransaction::WEAK_LEGACY); |
706 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 715 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); |
707 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 716 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
708 mock_pref_hash_store_->checked_paths_count()); | 717 mock_pref_hash_store_->checked_paths_count()); |
709 ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count()); | 718 ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count()); |
719 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | |
710 | 720 |
711 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = | 721 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = |
712 mock_pref_hash_store_->stored_value(kAtomicPref); | 722 mock_pref_hash_store_->stored_value(kAtomicPref); |
713 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, | 723 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, |
714 stored_atomic_value.second); | 724 stored_atomic_value.second); |
715 if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) { | 725 if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) { |
716 // Ensure the pref was cleared and the hash for NULL was restored if the | 726 // Ensure the pref was cleared and the hash for NULL was restored if the |
717 // current enforcement level prevents migration. | 727 // current enforcement level prevents migration. |
718 ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL)); | 728 ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL)); |
719 ASSERT_EQ(NULL, stored_atomic_value.first); | 729 ASSERT_EQ(NULL, stored_atomic_value.first); |
(...skipping 24 matching lines...) Expand all Loading... | |
744 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL)); | 754 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL)); |
745 ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL)); | 755 ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL)); |
746 | 756 |
747 mock_pref_hash_store_->SetCheckResult( | 757 mock_pref_hash_store_->SetCheckResult( |
748 kAtomicPref, PrefHashStoreTransaction::SECURE_LEGACY); | 758 kAtomicPref, PrefHashStoreTransaction::SECURE_LEGACY); |
749 mock_pref_hash_store_->SetCheckResult( | 759 mock_pref_hash_store_->SetCheckResult( |
750 kSplitPref, PrefHashStoreTransaction::SECURE_LEGACY); | 760 kSplitPref, PrefHashStoreTransaction::SECURE_LEGACY); |
751 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 761 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); |
752 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 762 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
753 mock_pref_hash_store_->checked_paths_count()); | 763 mock_pref_hash_store_->checked_paths_count()); |
764 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | |
754 | 765 |
755 // Ensure that both the atomic and split hashes were restored. | 766 // Ensure that both the atomic and split hashes were restored. |
756 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); | 767 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); |
757 | 768 |
758 // In all cases, the values should have remained intact and the hashes should | 769 // In all cases, the values should have remained intact and the hashes should |
759 // have been updated to match them. | 770 // have been updated to match them. |
760 | 771 |
761 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = | 772 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = |
762 mock_pref_hash_store_->stored_value(kAtomicPref); | 773 mock_pref_hash_store_->stored_value(kAtomicPref); |
763 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, | 774 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
803 mock_pref_hash_store_->SetCheckResult(kReportOnlyPref, | 814 mock_pref_hash_store_->SetCheckResult(kReportOnlyPref, |
804 PrefHashStoreTransaction::CHANGED); | 815 PrefHashStoreTransaction::CHANGED); |
805 mock_pref_hash_store_->SetCheckResult(kReportOnlySplitPref, | 816 mock_pref_hash_store_->SetCheckResult(kReportOnlySplitPref, |
806 PrefHashStoreTransaction::CHANGED); | 817 PrefHashStoreTransaction::CHANGED); |
807 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 818 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); |
808 // All prefs should be checked and a new hash should be stored for each tested | 819 // All prefs should be checked and a new hash should be stored for each tested |
809 // pref. | 820 // pref. |
810 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 821 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
811 mock_pref_hash_store_->checked_paths_count()); | 822 mock_pref_hash_store_->checked_paths_count()); |
812 ASSERT_EQ(4u, mock_pref_hash_store_->stored_paths_count()); | 823 ASSERT_EQ(4u, mock_pref_hash_store_->stored_paths_count()); |
824 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | |
813 | 825 |
814 // No matter what the enforcement level is, the report only pref should never | 826 // No matter what the enforcement level is, the report only pref should never |
815 // be reset. | 827 // be reset. |
816 ASSERT_TRUE(pref_store_contents_.Get(kReportOnlyPref, NULL)); | 828 ASSERT_TRUE(pref_store_contents_.Get(kReportOnlyPref, NULL)); |
817 ASSERT_TRUE(pref_store_contents_.Get(kReportOnlySplitPref, NULL)); | 829 ASSERT_TRUE(pref_store_contents_.Get(kReportOnlySplitPref, NULL)); |
818 ASSERT_EQ(report_only_val, | 830 ASSERT_EQ(report_only_val, |
819 mock_pref_hash_store_->stored_value(kReportOnlyPref).first); | 831 mock_pref_hash_store_->stored_value(kReportOnlyPref).first); |
820 ASSERT_EQ(report_only_split_val, | 832 ASSERT_EQ(report_only_split_val, |
821 mock_pref_hash_store_->stored_value(kReportOnlySplitPref).first); | 833 mock_pref_hash_store_->stored_value(kReportOnlySplitPref).first); |
822 | 834 |
(...skipping 14 matching lines...) Expand all Loading... | |
837 ASSERT_EQ(int_value1, | 849 ASSERT_EQ(int_value1, |
838 mock_pref_hash_store_->stored_value(kAtomicPref).first); | 850 mock_pref_hash_store_->stored_value(kAtomicPref).first); |
839 ASSERT_EQ(int_value2, value_in_store2); | 851 ASSERT_EQ(int_value2, value_in_store2); |
840 ASSERT_EQ(int_value2, | 852 ASSERT_EQ(int_value2, |
841 mock_pref_hash_store_->stored_value(kAtomicPref2).first); | 853 mock_pref_hash_store_->stored_value(kAtomicPref2).first); |
842 | 854 |
843 ASSERT_FALSE(RecordedReset()); | 855 ASSERT_FALSE(RecordedReset()); |
844 } | 856 } |
845 } | 857 } |
846 | 858 |
859 TEST_P(PrefHashFilterTest, MigrateValuesTest) { | |
860 // Migration configuration should only contain the protected preferences. | |
861 std::vector<PrefHashFilter::TrackedPreferenceMetadata> configuration = | |
862 GetConfiguration(GetParam()); | |
863 std::vector<PrefHashFilter::TrackedPreferenceMetadata> | |
864 migration_configuration; | |
865 | |
866 for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it = | |
867 configuration.begin(); | |
868 it != configuration.end(); | |
869 ++it) { | |
870 if (it->enforcement_level >= PrefHashFilter::ENFORCE_ON_LOAD) | |
871 migration_configuration.push_back(*it); | |
872 } | |
873 | |
874 // Discards the default created pref_hash_filter_. | |
875 InitializePrefHashFilter(migration_configuration); | |
876 | |
877 scoped_refptr<TestingPrefStore> source(new TestingPrefStore); | |
878 scoped_refptr<TestingPrefStore> destination(new TestingPrefStore); | |
879 | |
880 source->SetString(kAtomicPref, "foobar"); | |
881 source->SetString(kAtomicPref2, "foobar2"); | |
882 destination->SetString(kAtomicPref2, "foobar2 preexisting"); | |
883 destination->SetString(kAtomicPref3, "foobar3"); | |
884 source->SetString(kReportOnlyPref, "helloworld"); | |
885 | |
886 mock_pref_hash_store_->SetCheckResult(kAtomicPref, | |
887 PrefHashStoreTransaction::UNCHANGED); | |
888 mock_pref_hash_store_->SetCheckResult(kAtomicPref2, | |
889 PrefHashStoreTransaction::UNCHANGED); | |
890 mock_pref_hash_store_->SetCheckResult(kAtomicPref3, | |
891 PrefHashStoreTransaction::UNCHANGED); | |
gab
2014/04/01 18:55:06
To have better test coverage, one of these would b
| |
892 mock_pref_hash_store_->SetCheckResult(kReportOnlyPref, | |
893 PrefHashStoreTransaction::UNCHANGED); | |
894 | |
895 pref_hash_filter_->MigrateValues(source, destination); | |
896 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | |
897 | |
898 if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) { | |
899 std::string value; | |
900 | |
901 ASSERT_FALSE(source->GetValue(kAtomicPref, NULL)); | |
902 ASSERT_FALSE(source->GetValue(kAtomicPref2, NULL)); | |
903 ASSERT_FALSE(source->GetValue(kAtomicPref3, NULL)); | |
904 ASSERT_TRUE(source->GetString(kReportOnlyPref, &value)); | |
905 ASSERT_EQ("helloworld", value); | |
906 | |
907 ASSERT_TRUE(destination->GetString(kAtomicPref, &value)); | |
908 ASSERT_EQ("foobar", value); | |
909 ASSERT_TRUE(destination->GetString(kAtomicPref2, &value)); | |
910 ASSERT_EQ("foobar2 preexisting", value); | |
911 ASSERT_TRUE(destination->GetString(kAtomicPref3, &value)); | |
912 ASSERT_EQ("foobar3", value); | |
913 ASSERT_FALSE(destination->GetValue(kReportOnlyPref, NULL)); | |
914 } else { | |
915 std::string value; | |
916 | |
917 ASSERT_TRUE(source->GetString(kAtomicPref, &value)); | |
918 ASSERT_EQ("foobar", value); | |
919 ASSERT_TRUE(source->GetString(kAtomicPref2, &value)); | |
920 ASSERT_EQ("foobar2", value); | |
921 ASSERT_FALSE(source->GetString(kAtomicPref3, &value)); | |
922 ASSERT_TRUE(source->GetString(kReportOnlyPref, &value)); | |
923 ASSERT_EQ("helloworld", value); | |
924 | |
925 ASSERT_FALSE(destination->GetValue(kAtomicPref, NULL)); | |
926 ASSERT_TRUE(destination->GetString(kAtomicPref2, &value)); | |
927 ASSERT_EQ("foobar2 preexisting", value); | |
928 ASSERT_TRUE(destination->GetValue(kAtomicPref3, NULL)); | |
gab
2014/04/01 18:55:06
Why not check the value of kAtomicPref3 in this ca
| |
929 ASSERT_FALSE(destination->GetValue(kReportOnlyPref, NULL)); | |
930 } | |
931 } | |
932 | |
847 INSTANTIATE_TEST_CASE_P( | 933 INSTANTIATE_TEST_CASE_P( |
848 PrefHashFilterTestInstance, PrefHashFilterTest, | 934 PrefHashFilterTestInstance, PrefHashFilterTest, |
849 testing::Values(PrefHashFilter::NO_ENFORCEMENT, | 935 testing::Values(PrefHashFilter::NO_ENFORCEMENT, |
850 PrefHashFilter::ENFORCE_ON_LOAD)); | 936 PrefHashFilter::ENFORCE_ON_LOAD)); |
OLD | NEW |