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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: components/user_prefs/tracked/pref_hash_filter_unittest.cc

Issue 2722483005: Change configuration of user prefs to use mojo. (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 side-by-side diff with in-line comments
Download patch
« no previous file with comments | « components/user_prefs/tracked/pref_hash_filter.cc ('k') | components/user_prefs/tracked/tracked_preference_helper.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: components/user_prefs/tracked/pref_hash_filter_unittest.cc
diff --git a/components/user_prefs/tracked/pref_hash_filter_unittest.cc b/components/user_prefs/tracked/pref_hash_filter_unittest.cc
index a03d069eb80695c35cf38bcbc051abfa3bdb6eb4..9b0994b3ba6fbfd0f969fdbe8d51f17977dca0ba 100644
--- a/components/user_prefs/tracked/pref_hash_filter_unittest.cc
+++ b/components/user_prefs/tracked/pref_hash_filter_unittest.cc
@@ -42,41 +42,27 @@ const char kReportOnlySplitPref[] = "report_only_split_pref";
const char kSplitPref[] = "split_pref";
const PrefHashFilter::TrackedPreferenceMetadata kTestTrackedPrefs[] = {
- {0,
- kAtomicPref,
- PrefHashFilter::ENFORCE_ON_LOAD,
- PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
- PrefHashFilter::VALUE_PERSONAL},
- {1,
- kReportOnlyPref,
- PrefHashFilter::NO_ENFORCEMENT,
- PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
- PrefHashFilter::VALUE_IMPERSONAL},
- {2,
- kSplitPref,
- PrefHashFilter::ENFORCE_ON_LOAD,
- PrefHashFilter::TRACKING_STRATEGY_SPLIT,
- PrefHashFilter::VALUE_IMPERSONAL},
- {3,
- kReportOnlySplitPref,
- PrefHashFilter::NO_ENFORCEMENT,
- PrefHashFilter::TRACKING_STRATEGY_SPLIT,
- PrefHashFilter::VALUE_IMPERSONAL},
- {4,
- kAtomicPref2,
- PrefHashFilter::ENFORCE_ON_LOAD,
- PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
- PrefHashFilter::VALUE_IMPERSONAL},
- {5,
- kAtomicPref3,
- PrefHashFilter::ENFORCE_ON_LOAD,
- PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
- PrefHashFilter::VALUE_IMPERSONAL},
- {6,
- kAtomicPref4,
- PrefHashFilter::ENFORCE_ON_LOAD,
- PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
- PrefHashFilter::VALUE_IMPERSONAL},
+ {0, kAtomicPref, PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
+ PrefHashFilter::PrefTrackingStrategy::ATOMIC,
+ PrefHashFilter::ValueType::PERSONAL},
+ {1, kReportOnlyPref, PrefHashFilter::EnforcementLevel::NO_ENFORCEMENT,
+ PrefHashFilter::PrefTrackingStrategy::ATOMIC,
+ PrefHashFilter::ValueType::IMPERSONAL},
+ {2, kSplitPref, PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
+ PrefHashFilter::PrefTrackingStrategy::SPLIT,
+ PrefHashFilter::ValueType::IMPERSONAL},
+ {3, kReportOnlySplitPref, PrefHashFilter::EnforcementLevel::NO_ENFORCEMENT,
+ PrefHashFilter::PrefTrackingStrategy::SPLIT,
+ PrefHashFilter::ValueType::IMPERSONAL},
+ {4, kAtomicPref2, PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
+ PrefHashFilter::PrefTrackingStrategy::ATOMIC,
+ PrefHashFilter::ValueType::IMPERSONAL},
+ {5, kAtomicPref3, PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
+ PrefHashFilter::PrefTrackingStrategy::ATOMIC,
+ PrefHashFilter::ValueType::IMPERSONAL},
+ {6, kAtomicPref4, PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
+ PrefHashFilter::PrefTrackingStrategy::ATOMIC,
+ PrefHashFilter::ValueType::IMPERSONAL},
};
} // namespace
@@ -312,14 +298,14 @@ MockPrefHashStore::MockPrefHashStoreTransaction::CheckValue(
const std::string& path,
const base::Value* value) const {
return outer_->RecordCheckValue(path, value,
- PrefHashFilter::TRACKING_STRATEGY_ATOMIC);
+ PrefHashFilter::PrefTrackingStrategy::ATOMIC);
}
void MockPrefHashStore::MockPrefHashStoreTransaction::StoreHash(
const std::string& path,
const base::Value* new_value) {
outer_->RecordStoreHash(path, new_value,
- PrefHashFilter::TRACKING_STRATEGY_ATOMIC);
+ PrefHashFilter::PrefTrackingStrategy::ATOMIC);
}
PrefHashStoreTransaction::ValueState
@@ -338,14 +324,14 @@ MockPrefHashStore::MockPrefHashStoreTransaction::CheckSplitValue(
}
return outer_->RecordCheckValue(path, initial_split_value,
- PrefHashFilter::TRACKING_STRATEGY_SPLIT);
+ PrefHashFilter::PrefTrackingStrategy::SPLIT);
}
void MockPrefHashStore::MockPrefHashStoreTransaction::StoreSplitHash(
const std::string& path,
const base::DictionaryValue* new_value) {
outer_->RecordStoreHash(path, new_value,
- PrefHashFilter::TRACKING_STRATEGY_SPLIT);
+ PrefHashFilter::PrefTrackingStrategy::SPLIT);
}
bool MockPrefHashStore::MockPrefHashStoreTransaction::HasHash(
@@ -719,7 +705,7 @@ TEST_P(PrefHashFilterTest, FilterTrackedPrefUpdate) {
MockPrefHashStore::ValuePtrStrategyPair stored_value =
mock_pref_hash_store_->stored_value(kAtomicPref);
ASSERT_EQ(string_value, stored_value.first);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, stored_value.second);
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::ATOMIC, stored_value.second);
ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
VerifyRecordedReset(false);
@@ -779,7 +765,7 @@ TEST_P(PrefHashFilterTest, FilterSplitPrefUpdate) {
MockPrefHashStore::ValuePtrStrategyPair stored_value =
mock_pref_hash_store_->stored_value(kSplitPref);
ASSERT_EQ(dict_value, stored_value.first);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_value.second);
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::SPLIT, stored_value.second);
ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
VerifyRecordedReset(false);
@@ -835,20 +821,21 @@ TEST_P(PrefHashFilterTest, MultiplePrefsFilterSerializeData) {
MockPrefHashStore::ValuePtrStrategyPair stored_value_atomic1 =
mock_pref_hash_store_->stored_value(kAtomicPref);
ASSERT_EQ(int_value1, stored_value_atomic1.first);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::ATOMIC,
stored_value_atomic1.second);
ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
MockPrefHashStore::ValuePtrStrategyPair stored_value_atomic3 =
mock_pref_hash_store_->stored_value(kAtomicPref3);
ASSERT_EQ(int_value5, stored_value_atomic3.first);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::ATOMIC,
stored_value_atomic3.second);
MockPrefHashStore::ValuePtrStrategyPair stored_value_split =
mock_pref_hash_store_->stored_value(kSplitPref);
ASSERT_EQ(dict_value, stored_value_split.first);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_value_split.second);
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::SPLIT,
+ stored_value_split.second);
}
TEST_P(PrefHashFilterTest, UnknownNullValue) {
@@ -868,13 +855,14 @@ TEST_P(PrefHashFilterTest, UnknownNullValue) {
MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
mock_pref_hash_store_->stored_value(kAtomicPref);
ASSERT_EQ(NULL, stored_atomic_value.first);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::ATOMIC,
stored_atomic_value.second);
MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
mock_pref_hash_store_->stored_value(kSplitPref);
ASSERT_EQ(NULL, stored_split_value.first);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_split_value.second);
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::SPLIT,
+ stored_split_value.second);
// Delegate saw all prefs, two of which had the expected value_state.
ASSERT_EQ(arraysize(kTestTrackedPrefs),
@@ -887,12 +875,12 @@ TEST_P(PrefHashFilterTest, UnknownNullValue) {
const MockValidationDelegateRecord::ValidationEvent* validated_split_pref =
mock_validation_delegate_record_->GetEventForPath(kSplitPref);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT,
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::SPLIT,
validated_split_pref->strategy);
ASSERT_FALSE(validated_split_pref->is_personal);
const MockValidationDelegateRecord::ValidationEvent* validated_atomic_pref =
mock_validation_delegate_record_->GetEventForPath(kAtomicPref);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::ATOMIC,
validated_atomic_pref->strategy);
ASSERT_TRUE(validated_atomic_pref->is_personal);
}
@@ -915,7 +903,8 @@ TEST_P(PrefHashFilterTest, InitialValueUnknown) {
mock_pref_hash_store_->SetCheckResult(
kSplitPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE);
// If we are enforcing, expect this to report changes.
- DoFilterOnLoad(GetParam() >= PrefHashFilter::ENFORCE_ON_LOAD);
+ DoFilterOnLoad(GetParam() >=
+ PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD);
ASSERT_EQ(arraysize(kTestTrackedPrefs),
mock_pref_hash_store_->checked_paths_count());
ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
@@ -934,10 +923,11 @@ TEST_P(PrefHashFilterTest, InitialValueUnknown) {
mock_pref_hash_store_->stored_value(kAtomicPref);
MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
mock_pref_hash_store_->stored_value(kSplitPref);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::ATOMIC,
stored_atomic_value.second);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_split_value.second);
- if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) {
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::SPLIT,
+ stored_split_value.second);
+ if (GetParam() == PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD) {
// Ensure the prefs were cleared and the hashes for NULL were restored if
// the current enforcement level denies seeding.
ASSERT_FALSE(pref_store_contents_->Get(kAtomicPref, NULL));
@@ -1003,7 +993,7 @@ TEST_P(PrefHashFilterTest, InitialValueTrustedUnknown) {
MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
mock_pref_hash_store_->stored_value(kAtomicPref);
ASSERT_EQ(string_value, stored_atomic_value.first);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::ATOMIC,
stored_atomic_value.second);
const base::Value* split_value_in_store;
@@ -1012,7 +1002,8 @@ TEST_P(PrefHashFilterTest, InitialValueTrustedUnknown) {
MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
mock_pref_hash_store_->stored_value(kSplitPref);
ASSERT_EQ(dict_value, stored_split_value.first);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_split_value.second);
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::SPLIT,
+ stored_split_value.second);
}
TEST_P(PrefHashFilterTest, InitialValueChanged) {
@@ -1040,7 +1031,8 @@ TEST_P(PrefHashFilterTest, InitialValueChanged) {
mock_invalid_keys.push_back("c");
mock_pref_hash_store_->SetInvalidKeysResult(kSplitPref, mock_invalid_keys);
- DoFilterOnLoad(GetParam() >= PrefHashFilter::ENFORCE_ON_LOAD);
+ DoFilterOnLoad(GetParam() >=
+ PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD);
ASSERT_EQ(arraysize(kTestTrackedPrefs),
mock_pref_hash_store_->checked_paths_count());
ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
@@ -1050,10 +1042,11 @@ TEST_P(PrefHashFilterTest, InitialValueChanged) {
mock_pref_hash_store_->stored_value(kAtomicPref);
MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
mock_pref_hash_store_->stored_value(kSplitPref);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::ATOMIC,
stored_atomic_value.second);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_split_value.second);
- if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) {
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::SPLIT,
+ stored_split_value.second);
+ if (GetParam() == PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD) {
// Ensure the atomic pref was cleared and the hash for NULL was restored if
// the current enforcement level prevents changes.
ASSERT_FALSE(pref_store_contents_->Get(kAtomicPref, NULL));
@@ -1121,14 +1114,15 @@ TEST_P(PrefHashFilterTest, EmptyCleared) {
MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
mock_pref_hash_store_->stored_value(kAtomicPref);
ASSERT_EQ(NULL, stored_atomic_value.first);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::ATOMIC,
stored_atomic_value.second);
ASSERT_FALSE(pref_store_contents_->Get(kSplitPref, NULL));
MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
mock_pref_hash_store_->stored_value(kSplitPref);
ASSERT_EQ(NULL, stored_split_value.first);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_split_value.second);
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::SPLIT,
+ stored_split_value.second);
}
TEST_P(PrefHashFilterTest, InitialValueUnchangedLegacyId) {
@@ -1170,7 +1164,7 @@ TEST_P(PrefHashFilterTest, InitialValueUnchangedLegacyId) {
MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
mock_pref_hash_store_->stored_value(kAtomicPref);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::ATOMIC,
stored_atomic_value.second);
const base::Value* atomic_value_in_store;
ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, &atomic_value_in_store));
@@ -1179,7 +1173,8 @@ TEST_P(PrefHashFilterTest, InitialValueUnchangedLegacyId) {
MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
mock_pref_hash_store_->stored_value(kSplitPref);
- ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_split_value.second);
+ ASSERT_EQ(PrefHashFilter::PrefTrackingStrategy::SPLIT,
+ stored_split_value.second);
const base::Value* split_value_in_store;
ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, &split_value_in_store));
ASSERT_EQ(dict_value, split_value_in_store);
@@ -1214,7 +1209,8 @@ TEST_P(PrefHashFilterTest, DontResetReportOnly) {
mock_pref_hash_store_->SetCheckResult(kReportOnlySplitPref,
PrefHashStoreTransaction::CHANGED);
- DoFilterOnLoad(GetParam() >= PrefHashFilter::ENFORCE_ON_LOAD);
+ DoFilterOnLoad(GetParam() >=
+ PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD);
// All prefs should be checked and a new hash should be stored for each tested
// pref.
ASSERT_EQ(arraysize(kTestTrackedPrefs),
@@ -1241,7 +1237,7 @@ TEST_P(PrefHashFilterTest, DontResetReportOnly) {
mock_pref_hash_store_->stored_value(kReportOnlySplitPref).first);
// All other prefs should have been reset if the enforcement level allows it.
- if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) {
+ if (GetParam() == PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD) {
ASSERT_FALSE(pref_store_contents_->Get(kAtomicPref, NULL));
ASSERT_FALSE(pref_store_contents_->Get(kAtomicPref2, NULL));
ASSERT_EQ(NULL, mock_pref_hash_store_->stored_value(kAtomicPref).first);
@@ -1391,7 +1387,8 @@ TEST_P(PrefHashFilterTest, ExternalValidationValueChanged) {
PrefHashStoreTransaction::UNCHANGED));
}
-INSTANTIATE_TEST_CASE_P(PrefHashFilterTestInstance,
- PrefHashFilterTest,
- testing::Values(PrefHashFilter::NO_ENFORCEMENT,
- PrefHashFilter::ENFORCE_ON_LOAD));
+INSTANTIATE_TEST_CASE_P(
+ PrefHashFilterTestInstance,
+ PrefHashFilterTest,
+ testing::Values(PrefHashFilter::EnforcementLevel::NO_ENFORCEMENT,
+ PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD));
« no previous file with comments | « components/user_prefs/tracked/pref_hash_filter.cc ('k') | components/user_prefs/tracked/tracked_preference_helper.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698