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> |
(...skipping 322 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
333 } | 333 } |
334 | 334 |
335 MockPrefHashStore* mock_pref_hash_store_; | 335 MockPrefHashStore* mock_pref_hash_store_; |
336 base::DictionaryValue pref_store_contents_; | 336 base::DictionaryValue pref_store_contents_; |
337 scoped_ptr<PrefHashFilter> pref_hash_filter_; | 337 scoped_ptr<PrefHashFilter> pref_hash_filter_; |
338 | 338 |
339 DISALLOW_COPY_AND_ASSIGN(PrefHashFilterTest); | 339 DISALLOW_COPY_AND_ASSIGN(PrefHashFilterTest); |
340 }; | 340 }; |
341 | 341 |
342 TEST_P(PrefHashFilterTest, EmptyAndUnchanged) { | 342 TEST_P(PrefHashFilterTest, EmptyAndUnchanged) { |
343 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 343 ASSERT_FALSE(pref_hash_filter_->FilterOnLoad(&pref_store_contents_)); |
344 // All paths checked. | 344 // All paths checked. |
345 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 345 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
346 mock_pref_hash_store_->checked_paths_count()); | 346 mock_pref_hash_store_->checked_paths_count()); |
347 // No paths stored, since they all return |UNCHANGED|. | 347 // No paths stored, since they all return |UNCHANGED|. |
348 ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count()); | 348 ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count()); |
349 // Since there was nothing in |pref_store_contents_| the checked value should | 349 // Since there was nothing in |pref_store_contents_| the checked value should |
350 // have been NULL for all tracked preferences. | 350 // have been NULL for all tracked preferences. |
351 for (size_t i = 0; i < arraysize(kTestTrackedPrefs); ++i) { | 351 for (size_t i = 0; i < arraysize(kTestTrackedPrefs); ++i) { |
352 ASSERT_EQ(NULL, mock_pref_hash_store_->checked_value( | 352 ASSERT_EQ(NULL, mock_pref_hash_store_->checked_value( |
353 kTestTrackedPrefs[i].name).first); | 353 kTestTrackedPrefs[i].name).first); |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
469 } | 469 } |
470 | 470 |
471 TEST_P(PrefHashFilterTest, EmptyAndUnknown) { | 471 TEST_P(PrefHashFilterTest, EmptyAndUnknown) { |
472 ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL)); | 472 ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL)); |
473 ASSERT_FALSE(pref_store_contents_.Get(kSplitPref, NULL)); | 473 ASSERT_FALSE(pref_store_contents_.Get(kSplitPref, NULL)); |
474 // NULL values are always trusted by the PrefHashStore. | 474 // NULL values are always trusted by the PrefHashStore. |
475 mock_pref_hash_store_->SetCheckResult( | 475 mock_pref_hash_store_->SetCheckResult( |
476 kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); | 476 kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); |
477 mock_pref_hash_store_->SetCheckResult( | 477 mock_pref_hash_store_->SetCheckResult( |
478 kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); | 478 kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); |
479 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 479 ASSERT_FALSE(pref_hash_filter_->FilterOnLoad(&pref_store_contents_)); |
480 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 480 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
481 mock_pref_hash_store_->checked_paths_count()); | 481 mock_pref_hash_store_->checked_paths_count()); |
482 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); | 482 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); |
483 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | 483 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); |
484 | 484 |
485 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = | 485 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = |
486 mock_pref_hash_store_->stored_value(kAtomicPref); | 486 mock_pref_hash_store_->stored_value(kAtomicPref); |
487 ASSERT_EQ(NULL, stored_atomic_value.first); | 487 ASSERT_EQ(NULL, stored_atomic_value.first); |
488 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, | 488 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, |
489 stored_atomic_value.second); | 489 stored_atomic_value.second); |
(...skipping 15 matching lines...) Expand all Loading... |
505 dict_value->SetInteger("b", 1234); | 505 dict_value->SetInteger("b", 1234); |
506 pref_store_contents_.Set(kSplitPref, dict_value); | 506 pref_store_contents_.Set(kSplitPref, dict_value); |
507 | 507 |
508 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL)); | 508 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL)); |
509 ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL)); | 509 ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL)); |
510 | 510 |
511 mock_pref_hash_store_->SetCheckResult( | 511 mock_pref_hash_store_->SetCheckResult( |
512 kAtomicPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE); | 512 kAtomicPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE); |
513 mock_pref_hash_store_->SetCheckResult( | 513 mock_pref_hash_store_->SetCheckResult( |
514 kSplitPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE); | 514 kSplitPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE); |
515 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 515 // If we are enforcing, expect this to report changes. |
| 516 ASSERT_EQ(GetParam() >= PrefHashFilter::ENFORCE_ON_LOAD, |
| 517 pref_hash_filter_->FilterOnLoad(&pref_store_contents_)); |
516 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 518 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
517 mock_pref_hash_store_->checked_paths_count()); | 519 mock_pref_hash_store_->checked_paths_count()); |
518 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); | 520 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); |
519 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | 521 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); |
520 | 522 |
521 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = | 523 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = |
522 mock_pref_hash_store_->stored_value(kAtomicPref); | 524 mock_pref_hash_store_->stored_value(kAtomicPref); |
523 MockPrefHashStore::ValuePtrStrategyPair stored_split_value = | 525 MockPrefHashStore::ValuePtrStrategyPair stored_split_value = |
524 mock_pref_hash_store_->stored_value(kSplitPref); | 526 mock_pref_hash_store_->stored_value(kSplitPref); |
525 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, | 527 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
563 dict_value->SetInteger("b", 1234); | 565 dict_value->SetInteger("b", 1234); |
564 pref_store_contents_.Set(kSplitPref, dict_value); | 566 pref_store_contents_.Set(kSplitPref, dict_value); |
565 | 567 |
566 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL)); | 568 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL)); |
567 ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL)); | 569 ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL)); |
568 | 570 |
569 mock_pref_hash_store_->SetCheckResult( | 571 mock_pref_hash_store_->SetCheckResult( |
570 kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); | 572 kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); |
571 mock_pref_hash_store_->SetCheckResult( | 573 mock_pref_hash_store_->SetCheckResult( |
572 kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); | 574 kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE); |
573 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 575 ASSERT_FALSE(pref_hash_filter_->FilterOnLoad(&pref_store_contents_)); |
574 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 576 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
575 mock_pref_hash_store_->checked_paths_count()); | 577 mock_pref_hash_store_->checked_paths_count()); |
576 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); | 578 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); |
577 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | 579 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); |
578 | 580 |
579 // Seeding is always allowed for trusted unknown values. | 581 // Seeding is always allowed for trusted unknown values. |
580 const base::Value* atomic_value_in_store; | 582 const base::Value* atomic_value_in_store; |
581 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, &atomic_value_in_store)); | 583 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, &atomic_value_in_store)); |
582 ASSERT_EQ(string_value, atomic_value_in_store); | 584 ASSERT_EQ(string_value, atomic_value_in_store); |
583 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = | 585 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = |
(...skipping 30 matching lines...) Expand all Loading... |
614 mock_pref_hash_store_->SetCheckResult(kAtomicPref, | 616 mock_pref_hash_store_->SetCheckResult(kAtomicPref, |
615 PrefHashStoreTransaction::CHANGED); | 617 PrefHashStoreTransaction::CHANGED); |
616 mock_pref_hash_store_->SetCheckResult(kSplitPref, | 618 mock_pref_hash_store_->SetCheckResult(kSplitPref, |
617 PrefHashStoreTransaction::CHANGED); | 619 PrefHashStoreTransaction::CHANGED); |
618 | 620 |
619 std::vector<std::string> mock_invalid_keys; | 621 std::vector<std::string> mock_invalid_keys; |
620 mock_invalid_keys.push_back("a"); | 622 mock_invalid_keys.push_back("a"); |
621 mock_invalid_keys.push_back("c"); | 623 mock_invalid_keys.push_back("c"); |
622 mock_pref_hash_store_->SetInvalidKeysResult(kSplitPref, mock_invalid_keys); | 624 mock_pref_hash_store_->SetInvalidKeysResult(kSplitPref, mock_invalid_keys); |
623 | 625 |
624 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 626 ASSERT_EQ(GetParam() >= PrefHashFilter::ENFORCE_ON_LOAD, |
| 627 pref_hash_filter_->FilterOnLoad(&pref_store_contents_)); |
625 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 628 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
626 mock_pref_hash_store_->checked_paths_count()); | 629 mock_pref_hash_store_->checked_paths_count()); |
627 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); | 630 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); |
628 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | 631 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); |
629 | 632 |
630 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = | 633 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = |
631 mock_pref_hash_store_->stored_value(kAtomicPref); | 634 mock_pref_hash_store_->stored_value(kAtomicPref); |
632 MockPrefHashStore::ValuePtrStrategyPair stored_split_value = | 635 MockPrefHashStore::ValuePtrStrategyPair stored_split_value = |
633 mock_pref_hash_store_->stored_value(kSplitPref); | 636 mock_pref_hash_store_->stored_value(kSplitPref); |
634 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, | 637 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
675 } | 678 } |
676 } | 679 } |
677 | 680 |
678 TEST_P(PrefHashFilterTest, EmptyCleared) { | 681 TEST_P(PrefHashFilterTest, EmptyCleared) { |
679 ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL)); | 682 ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL)); |
680 ASSERT_FALSE(pref_store_contents_.Get(kSplitPref, NULL)); | 683 ASSERT_FALSE(pref_store_contents_.Get(kSplitPref, NULL)); |
681 mock_pref_hash_store_->SetCheckResult(kAtomicPref, | 684 mock_pref_hash_store_->SetCheckResult(kAtomicPref, |
682 PrefHashStoreTransaction::CLEARED); | 685 PrefHashStoreTransaction::CLEARED); |
683 mock_pref_hash_store_->SetCheckResult(kSplitPref, | 686 mock_pref_hash_store_->SetCheckResult(kSplitPref, |
684 PrefHashStoreTransaction::CLEARED); | 687 PrefHashStoreTransaction::CLEARED); |
685 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 688 ASSERT_FALSE(pref_hash_filter_->FilterOnLoad(&pref_store_contents_)); |
686 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 689 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
687 mock_pref_hash_store_->checked_paths_count()); | 690 mock_pref_hash_store_->checked_paths_count()); |
688 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); | 691 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); |
689 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | 692 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); |
690 | 693 |
691 // Regardless of the enforcement level, the only thing that should be done is | 694 // Regardless of the enforcement level, the only thing that should be done is |
692 // to restore the hash for NULL. The value itself should still be NULL. | 695 // to restore the hash for NULL. The value itself should still be NULL. |
693 ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL)); | 696 ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL)); |
694 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = | 697 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = |
695 mock_pref_hash_store_->stored_value(kAtomicPref); | 698 mock_pref_hash_store_->stored_value(kAtomicPref); |
(...skipping 14 matching lines...) Expand all Loading... |
710 | 713 |
711 // Ownership of this value is transfered to |pref_store_contents_|. | 714 // Ownership of this value is transfered to |pref_store_contents_|. |
712 base::ListValue* list_value = new base::ListValue; | 715 base::ListValue* list_value = new base::ListValue; |
713 list_value->Append(base::Value::CreateStringValue("test")); | 716 list_value->Append(base::Value::CreateStringValue("test")); |
714 pref_store_contents_.Set(kAtomicPref, list_value); | 717 pref_store_contents_.Set(kAtomicPref, list_value); |
715 | 718 |
716 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL)); | 719 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL)); |
717 | 720 |
718 mock_pref_hash_store_->SetCheckResult(kAtomicPref, | 721 mock_pref_hash_store_->SetCheckResult(kAtomicPref, |
719 PrefHashStoreTransaction::WEAK_LEGACY); | 722 PrefHashStoreTransaction::WEAK_LEGACY); |
720 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 723 |
| 724 ASSERT_EQ(GetParam() >= PrefHashFilter::ENFORCE_ON_LOAD, |
| 725 pref_hash_filter_->FilterOnLoad(&pref_store_contents_)); |
721 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 726 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
722 mock_pref_hash_store_->checked_paths_count()); | 727 mock_pref_hash_store_->checked_paths_count()); |
723 ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count()); | 728 ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count()); |
724 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | 729 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); |
725 | 730 |
726 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = | 731 MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value = |
727 mock_pref_hash_store_->stored_value(kAtomicPref); | 732 mock_pref_hash_store_->stored_value(kAtomicPref); |
728 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, | 733 ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, |
729 stored_atomic_value.second); | 734 stored_atomic_value.second); |
730 if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) { | 735 if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) { |
(...skipping 25 matching lines...) Expand all Loading... |
756 dict_value->SetInteger("b", 1234); | 761 dict_value->SetInteger("b", 1234); |
757 pref_store_contents_.Set(kSplitPref, dict_value); | 762 pref_store_contents_.Set(kSplitPref, dict_value); |
758 | 763 |
759 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL)); | 764 ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL)); |
760 ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL)); | 765 ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL)); |
761 | 766 |
762 mock_pref_hash_store_->SetCheckResult( | 767 mock_pref_hash_store_->SetCheckResult( |
763 kAtomicPref, PrefHashStoreTransaction::SECURE_LEGACY); | 768 kAtomicPref, PrefHashStoreTransaction::SECURE_LEGACY); |
764 mock_pref_hash_store_->SetCheckResult( | 769 mock_pref_hash_store_->SetCheckResult( |
765 kSplitPref, PrefHashStoreTransaction::SECURE_LEGACY); | 770 kSplitPref, PrefHashStoreTransaction::SECURE_LEGACY); |
766 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 771 ASSERT_FALSE(pref_hash_filter_->FilterOnLoad(&pref_store_contents_)); |
767 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 772 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
768 mock_pref_hash_store_->checked_paths_count()); | 773 mock_pref_hash_store_->checked_paths_count()); |
769 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | 774 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); |
770 | 775 |
771 // Ensure that both the atomic and split hashes were restored. | 776 // Ensure that both the atomic and split hashes were restored. |
772 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); | 777 ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count()); |
773 | 778 |
774 // In all cases, the values should have remained intact and the hashes should | 779 // In all cases, the values should have remained intact and the hashes should |
775 // have been updated to match them. | 780 // have been updated to match them. |
776 | 781 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
813 ASSERT_TRUE(pref_store_contents_.Get(kReportOnlySplitPref, NULL)); | 818 ASSERT_TRUE(pref_store_contents_.Get(kReportOnlySplitPref, NULL)); |
814 | 819 |
815 mock_pref_hash_store_->SetCheckResult(kAtomicPref, | 820 mock_pref_hash_store_->SetCheckResult(kAtomicPref, |
816 PrefHashStoreTransaction::CHANGED); | 821 PrefHashStoreTransaction::CHANGED); |
817 mock_pref_hash_store_->SetCheckResult(kAtomicPref2, | 822 mock_pref_hash_store_->SetCheckResult(kAtomicPref2, |
818 PrefHashStoreTransaction::CHANGED); | 823 PrefHashStoreTransaction::CHANGED); |
819 mock_pref_hash_store_->SetCheckResult(kReportOnlyPref, | 824 mock_pref_hash_store_->SetCheckResult(kReportOnlyPref, |
820 PrefHashStoreTransaction::CHANGED); | 825 PrefHashStoreTransaction::CHANGED); |
821 mock_pref_hash_store_->SetCheckResult(kReportOnlySplitPref, | 826 mock_pref_hash_store_->SetCheckResult(kReportOnlySplitPref, |
822 PrefHashStoreTransaction::CHANGED); | 827 PrefHashStoreTransaction::CHANGED); |
823 pref_hash_filter_->FilterOnLoad(&pref_store_contents_); | 828 |
| 829 ASSERT_EQ(GetParam() >= PrefHashFilter::ENFORCE_ON_LOAD, |
| 830 pref_hash_filter_->FilterOnLoad(&pref_store_contents_)); |
824 // All prefs should be checked and a new hash should be stored for each tested | 831 // All prefs should be checked and a new hash should be stored for each tested |
825 // pref. | 832 // pref. |
826 ASSERT_EQ(arraysize(kTestTrackedPrefs), | 833 ASSERT_EQ(arraysize(kTestTrackedPrefs), |
827 mock_pref_hash_store_->checked_paths_count()); | 834 mock_pref_hash_store_->checked_paths_count()); |
828 ASSERT_EQ(4u, mock_pref_hash_store_->stored_paths_count()); | 835 ASSERT_EQ(4u, mock_pref_hash_store_->stored_paths_count()); |
829 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); | 836 ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed()); |
830 | 837 |
831 // No matter what the enforcement level is, the report only pref should never | 838 // No matter what the enforcement level is, the report only pref should never |
832 // be reset. | 839 // be reset. |
833 ASSERT_TRUE(pref_store_contents_.Get(kReportOnlyPref, NULL)); | 840 ASSERT_TRUE(pref_store_contents_.Get(kReportOnlyPref, NULL)); |
(...skipping 120 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
954 ASSERT_EQ("foobar3", value); | 961 ASSERT_EQ("foobar3", value); |
955 ASSERT_FALSE(destination->GetValue(kAtomicPref4, NULL)); | 962 ASSERT_FALSE(destination->GetValue(kAtomicPref4, NULL)); |
956 ASSERT_FALSE(destination->GetValue(kReportOnlyPref, NULL)); | 963 ASSERT_FALSE(destination->GetValue(kReportOnlyPref, NULL)); |
957 } | 964 } |
958 } | 965 } |
959 | 966 |
960 INSTANTIATE_TEST_CASE_P( | 967 INSTANTIATE_TEST_CASE_P( |
961 PrefHashFilterTestInstance, PrefHashFilterTest, | 968 PrefHashFilterTestInstance, PrefHashFilterTest, |
962 testing::Values(PrefHashFilter::NO_ENFORCEMENT, | 969 testing::Values(PrefHashFilter::NO_ENFORCEMENT, |
963 PrefHashFilter::ENFORCE_ON_LOAD)); | 970 PrefHashFilter::ENFORCE_ON_LOAD)); |
OLD | NEW |