Change configuration of user prefs to use mojo.

components/user_prefs/tracked/pref_hash_filter_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/user_prefs/tracked/pref_hash_filter.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 24 matching lines @@
 
 const char kAtomicPref[] = "atomic_pref";
 const char kAtomicPref2[] = "atomic_pref2";
 const char kAtomicPref3[] = "pref3";
 const char kAtomicPref4[] = "pref4";
 const char kReportOnlyPref[] = "report_only";
 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
 
 // A PrefHashStore that allows simulation of CheckValue results and captures
 // checked and stored values.
 class MockPrefHashStore : public PrefHashStore {
  public:
   typedef std::pair<const void*, PrefHashFilter::PrefTrackingStrategy>
       ValuePtrStrategyPair;
@@ skipping 215 matching lines @@
 base::StringPiece
 MockPrefHashStore::MockPrefHashStoreTransaction::GetStoreUMASuffix() const {
   return "unused";
 }
 
 PrefHashStoreTransaction::ValueState
 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
 MockPrefHashStore::MockPrefHashStoreTransaction::CheckSplitValue(
     const std::string& path,
     const base::DictionaryValue* initial_split_value,
     std::vector<std::string>* invalid_keys) const {
   EXPECT_TRUE(invalid_keys && invalid_keys->empty());
 
   std::map<std::string, std::vector<std::string>>::const_iterator
       invalid_keys_result = outer_->invalid_keys_results_.find(path);
   if (invalid_keys_result != outer_->invalid_keys_results_.end()) {
     invalid_keys->insert(invalid_keys->begin(),
                          invalid_keys_result->second.begin(),
                          invalid_keys_result->second.end());
   }
 
   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(
     const std::string& path) const {
   ADD_FAILURE() << "Unexpected call.";
   return false;
 }
 
 void MockPrefHashStore::MockPrefHashStoreTransaction::ImportHash(
     const std::string& path,
@@ skipping 353 matching lines @@
   // No path should be stored on FilterUpdate.
   pref_hash_filter_->FilterUpdate(kAtomicPref);
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // One path should be stored on FilterSerializeData.
   pref_hash_filter_->FilterSerializeData(&root_dict);
   ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count());
   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);
 }
 
 TEST_P(PrefHashFilterTest, ReportSuperMacValidity) {
   // Do this once just to force the histogram to be defined.
   DoFilterOnLoad(false);
 
   base::HistogramBase* histogram = base::StatisticsRecorder::FindHistogram(
@@ skipping 39 matching lines @@
   // No path should be stored on FilterUpdate.
   pref_hash_filter_->FilterUpdate(kSplitPref);
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // One path should be stored on FilterSerializeData.
   pref_hash_filter_->FilterSerializeData(&root_dict);
   ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count());
   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);
 }
 
 TEST_P(PrefHashFilterTest, FilterUntrackedPrefUpdate) {
   base::DictionaryValue root_dict;
   root_dict.Set("untracked", new base::StringValue("some value"));
   pref_hash_filter_->FilterUpdate("untracked");
 
@@ skipping 35 matching lines @@
   root_dict.Set(kAtomicPref3, int_value5);
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // On FilterSerializeData, only kAtomicPref, kAtomicPref3, and kSplitPref
   // should get a new hash.
   pref_hash_filter_->FilterSerializeData(&root_dict);
   ASSERT_EQ(3u, mock_pref_hash_store_->stored_paths_count());
   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) {
   ASSERT_FALSE(pref_store_contents_->Get(kAtomicPref, NULL));
   ASSERT_FALSE(pref_store_contents_->Get(kSplitPref, NULL));
   // NULL values are always trusted by the PrefHashStore.
   mock_pref_hash_store_->SetCheckResult(
       kAtomicPref, PrefHashStoreTransaction::TRUSTED_NULL_VALUE);
   mock_pref_hash_store_->SetCheckResult(
       kSplitPref, PrefHashStoreTransaction::TRUSTED_NULL_VALUE);
   DoFilterOnLoad(false);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   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),
             mock_validation_delegate_record_->recorded_validations_count());
   ASSERT_EQ(2u, mock_validation_delegate_record_->CountValidationsOfState(
                     PrefHashStoreTransaction::TRUSTED_NULL_VALUE));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
             mock_validation_delegate_record_->CountValidationsOfState(
                 PrefHashStoreTransaction::UNCHANGED));
 
   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);
 }
 
 TEST_P(PrefHashFilterTest, InitialValueUnknown) {
   // Ownership of these values is transfered to |pref_store_contents_|.
   base::StringValue* string_value = new base::StringValue("string value");
   pref_store_contents_->Set(kAtomicPref, string_value);
 
   base::DictionaryValue* dict_value = new base::DictionaryValue;
   dict_value->SetString("a", "foo");
   dict_value->SetInteger("b", 1234);
   pref_store_contents_->Set(kSplitPref, dict_value);
 
   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(
       kAtomicPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE);
   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());
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   // Delegate saw all prefs, two of which had the expected value_state.
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_validation_delegate_record_->recorded_validations_count());
   ASSERT_EQ(2u, mock_validation_delegate_record_->CountValidationsOfState(
                     PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
             mock_validation_delegate_record_->CountValidationsOfState(
                 PrefHashStoreTransaction::UNCHANGED));
 
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
       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));
     ASSERT_EQ(NULL, stored_atomic_value.first);
 
     ASSERT_FALSE(pref_store_contents_->Get(kSplitPref, NULL));
     ASSERT_EQ(NULL, stored_split_value.first);
 
     VerifyRecordedReset(true);
   } else {
@@ skipping 45 matching lines @@
             mock_validation_delegate_record_->CountValidationsOfState(
                 PrefHashStoreTransaction::UNCHANGED));
 
   // Seeding is always allowed for trusted unknown values.
   const base::Value* atomic_value_in_store;
   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, &atomic_value_in_store));
   ASSERT_EQ(string_value, atomic_value_in_store);
   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;
   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, &split_value_in_store));
   ASSERT_EQ(dict_value, split_value_in_store);
   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) {
   // Ownership of this value is transfered to |pref_store_contents_|.
   base::Value* int_value = new base::Value(1234);
   pref_store_contents_->Set(kAtomicPref, int_value);
 
   base::DictionaryValue* dict_value = new base::DictionaryValue;
   dict_value->SetString("a", "foo");
   dict_value->SetInteger("b", 1234);
   dict_value->SetInteger("c", 56);
   dict_value->SetBoolean("d", false);
   pref_store_contents_->Set(kSplitPref, dict_value);
 
   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(kAtomicPref,
                                         PrefHashStoreTransaction::CHANGED);
   mock_pref_hash_store_->SetCheckResult(kSplitPref,
                                         PrefHashStoreTransaction::CHANGED);
 
   std::vector<std::string> mock_invalid_keys;
   mock_invalid_keys.push_back("a");
   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());
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
       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));
     ASSERT_EQ(NULL, stored_atomic_value.first);
 
     // The split pref on the other hand should only have been stripped of its
     // invalid keys.
     const base::Value* split_value_in_store;
     ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, &split_value_in_store));
     ASSERT_EQ(2U, dict_value->size());
@@ skipping 47 matching lines @@
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
             mock_validation_delegate_record_->CountValidationsOfState(
                 PrefHashStoreTransaction::UNCHANGED));
 
   // Regardless of the enforcement level, the only thing that should be done is
   // to restore the hash for NULL. The value itself should still be NULL.
   ASSERT_FALSE(pref_store_contents_->Get(kAtomicPref, NULL));
   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) {
   // Ownership of these values is transfered to |pref_store_contents_|.
   base::StringValue* string_value = new base::StringValue("string value");
   pref_store_contents_->Set(kAtomicPref, string_value);
 
   base::DictionaryValue* dict_value = new base::DictionaryValue;
   dict_value->SetString("a", "foo");
   dict_value->SetInteger("b", 1234);
@@ skipping 21 matching lines @@
                 PrefHashStoreTransaction::UNCHANGED));
 
   // Ensure that both the atomic and split hashes were restored.
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
 
   // In all cases, the values should have remained intact and the hashes should
   // have been updated to match them.
 
   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));
   ASSERT_EQ(string_value, atomic_value_in_store);
   ASSERT_EQ(string_value, stored_atomic_value.first);
 
   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);
   ASSERT_EQ(dict_value, stored_split_value.first);
 
   VerifyRecordedReset(false);
 }
 
 TEST_P(PrefHashFilterTest, DontResetReportOnly) {
   // Ownership of these values is transfered to |pref_store_contents_|.
@@ skipping 14 matching lines @@
 
   mock_pref_hash_store_->SetCheckResult(kAtomicPref,
                                         PrefHashStoreTransaction::CHANGED);
   mock_pref_hash_store_->SetCheckResult(kAtomicPref2,
                                         PrefHashStoreTransaction::CHANGED);
   mock_pref_hash_store_->SetCheckResult(kReportOnlyPref,
                                         PrefHashStoreTransaction::CHANGED);
   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),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(4u, mock_pref_hash_store_->stored_paths_count());
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   // Delegate saw all prefs, four of which had the expected value_state.
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_validation_delegate_record_->recorded_validations_count());
   ASSERT_EQ(4u, mock_validation_delegate_record_->CountValidationsOfState(
                     PrefHashStoreTransaction::CHANGED));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 4u,
             mock_validation_delegate_record_->CountValidationsOfState(
                 PrefHashStoreTransaction::UNCHANGED));
 
   // No matter what the enforcement level is, the report only pref should never
   // be reset.
   ASSERT_TRUE(pref_store_contents_->Get(kReportOnlyPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kReportOnlySplitPref, NULL));
   ASSERT_EQ(report_only_val,
             mock_pref_hash_store_->stored_value(kReportOnlyPref).first);
   ASSERT_EQ(report_only_split_val,
             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);
     ASSERT_EQ(NULL, mock_pref_hash_store_->stored_value(kAtomicPref2).first);
 
     VerifyRecordedReset(true);
   } else {
     const base::Value* value_in_store;
     const base::Value* value_in_store2;
     ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, &value_in_store));
@@ skipping 129 matching lines @@
 
   // External validation should have two CHANGED prefs (kAtomic and kSplit).
   ASSERT_EQ(2u,
             mock_validation_delegate_record_->CountExternalValidationsOfState(
                 PrefHashStoreTransaction::CHANGED));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
             mock_validation_delegate_record_->CountExternalValidationsOfState(
                 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));