Move tracked prefs into services/preferences/tracked.

services/preferences/tracked/pref_hash_filter_unittest.cc

Index: services/preferences/tracked/pref_hash_filter_unittest.cc
diff --git a/components/user_prefs/tracked/pref_hash_filter_unittest.cc b/services/preferences/tracked/pref_hash_filter_unittest.cc
similarity index 88%
rename from components/user_prefs/tracked/pref_hash_filter_unittest.cc
rename to services/preferences/tracked/pref_hash_filter_unittest.cc
index a3c701bbbbd13ac68a1c27d4465087c92c1cbaf0..59bdf9819de4c9076c9a5b9088507f9ff3878b0b 100644
--- a/components/user_prefs/tracked/pref_hash_filter_unittest.cc
+++ b/services/preferences/tracked/pref_hash_filter_unittest.cc
@@ -2,7 +2,7 @@
 // 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 "services/preferences/tracked/pref_hash_filter.h"
 
 #include <stddef.h>
 
@@ -24,18 +24,23 @@
 #include "base/metrics/statistics_recorder.h"
 #include "base/values.h"
 #include "components/prefs/testing_pref_store.h"
-#include "components/user_prefs/tracked/hash_store_contents.h"
-#include "components/user_prefs/tracked/mock_validation_delegate.h"
-#include "components/user_prefs/tracked/pref_hash_store.h"
-#include "components/user_prefs/tracked/pref_hash_store_transaction.h"
-#include "components/user_prefs/tracked/pref_names.h"
+#include "services/preferences/public/cpp/tracked/configuration.h"
+#include "services/preferences/public/cpp/tracked/mock_validation_delegate.h"
+#include "services/preferences/public/cpp/tracked/pref_names.h"
+#include "services/preferences/tracked/hash_store_contents.h"
+#include "services/preferences/tracked/pref_hash_store.h"
+#include "services/preferences/tracked/pref_hash_store_transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
-using EnforcementLevel = PrefHashFilter::EnforcementLevel;
-using PrefTrackingStrategy = PrefHashFilter::PrefTrackingStrategy;
-using ValueType = PrefHashFilter::ValueType;
+using EnforcementLevel =
+    prefs::mojom::TrackedPreferenceMetadata::EnforcementLevel;
+using PrefTrackingStrategy =
+    prefs::mojom::TrackedPreferenceMetadata::PrefTrackingStrategy;
+using ValueType = prefs::mojom::TrackedPreferenceMetadata::ValueType;
+using ValueState =
+    prefs::mojom::TrackedPreferenceValidationDelegate::ValueState;
 
 const char kAtomicPref[] = "atomic_pref";
 const char kAtomicPref2[] = "atomic_pref2";
@@ -45,7 +50,7 @@ const char kReportOnlyPref[] = "report_only";
 const char kReportOnlySplitPref[] = "report_only_split_pref";
 const char kSplitPref[] = "split_pref";
 
-const PrefHashFilter::TrackedPreferenceMetadata kTestTrackedPrefs[] = {
+const prefs::TrackedPreferenceMetadata kTestTrackedPrefs[] = {
     {0, kAtomicPref, EnforcementLevel::ENFORCE_ON_LOAD,
      PrefTrackingStrategy::ATOMIC, ValueType::PERSONAL},
     {1, kReportOnlyPref, EnforcementLevel::NO_ENFORCEMENT,
@@ -68,8 +73,7 @@ const PrefHashFilter::TrackedPreferenceMetadata kTestTrackedPrefs[] = {
 // checked and stored values.
 class MockPrefHashStore : public PrefHashStore {
  public:
-  typedef std::pair<const void*, PrefHashFilter::PrefTrackingStrategy>
-      ValuePtrStrategyPair;
+  typedef std::pair<const void*, PrefTrackingStrategy> ValuePtrStrategyPair;
 
   MockPrefHashStore()
       : stamp_super_mac_result_(false),
@@ -81,8 +85,7 @@ class MockPrefHashStore : public PrefHashStore {
 
   // Set the result that will be returned when |path| is passed to
   // |CheckValue/CheckSplitValue|.
-  void SetCheckResult(const std::string& path,
-                      PrefHashStoreTransaction::ValueState result);
+  void SetCheckResult(const std::string& path, ValueState result);
 
   // Set the invalid_keys that will be returned when |path| is passed to
   // |CheckSplitValue|. SetCheckResult should already have been called for
@@ -120,9 +123,8 @@ class MockPrefHashStore : public PrefHashStore {
         checked_values_.find(path);
     if (value != checked_values_.end())
       return value->second;
-    return std::make_pair(
-        reinterpret_cast<void*>(0xBAD),
-        static_cast<PrefHashFilter::PrefTrackingStrategy>(-1));
+    return std::make_pair(reinterpret_cast<void*>(0xBAD),
+                          static_cast<PrefTrackingStrategy>(-1));
   }
 
   // Returns the pointer value that was passed to |StoreHash/StoreSplitHash| for
@@ -133,9 +135,8 @@ class MockPrefHashStore : public PrefHashStore {
         stored_values_.find(path);
     if (value != stored_values_.end())
       return value->second;
-    return std::make_pair(
-        reinterpret_cast<void*>(0xBAD),
-        static_cast<PrefHashFilter::PrefTrackingStrategy>(-1));
+    return std::make_pair(reinterpret_cast<void*>(0xBAD),
+                          static_cast<PrefTrackingStrategy>(-1));
   }
 
   // PrefHashStore implementation.
@@ -164,12 +165,11 @@ class MockPrefHashStore : public PrefHashStore {
 
     // PrefHashStoreTransaction implementation.
     base::StringPiece GetStoreUMASuffix() const override;
-    PrefHashStoreTransaction::ValueState CheckValue(
-        const std::string& path,
-        const base::Value* value) const override;
+    ValueState CheckValue(const std::string& path,
+                          const base::Value* value) const override;
     void StoreHash(const std::string& path,
                    const base::Value* new_value) override;
-    PrefHashStoreTransaction::ValueState CheckSplitValue(
+    ValueState CheckSplitValue(
         const std::string& path,
         const base::DictionaryValue* initial_split_value,
         std::vector<std::string>* invalid_keys) const override;
@@ -188,17 +188,16 @@ class MockPrefHashStore : public PrefHashStore {
   };
 
   // Records a call to this mock's CheckValue/CheckSplitValue methods.
-  PrefHashStoreTransaction::ValueState RecordCheckValue(
-      const std::string& path,
-      const base::Value* value,
-      PrefHashFilter::PrefTrackingStrategy strategy);
+  ValueState RecordCheckValue(const std::string& path,
+                              const base::Value* value,
+                              PrefTrackingStrategy strategy);
 
   // Records a call to this mock's StoreHash/StoreSplitHash methods.
   void RecordStoreHash(const std::string& path,
                        const base::Value* new_value,
-                       PrefHashFilter::PrefTrackingStrategy strategy);
+                       PrefTrackingStrategy strategy);
 
-  std::map<std::string, PrefHashStoreTransaction::ValueState> check_results_;
+  std::map<std::string, ValueState> check_results_;
   std::map<std::string, std::vector<std::string>> invalid_keys_results_;
 
   bool stamp_super_mac_result_;
@@ -217,9 +216,8 @@ class MockPrefHashStore : public PrefHashStore {
   DISALLOW_COPY_AND_ASSIGN(MockPrefHashStore);
 };
 
-void MockPrefHashStore::SetCheckResult(
-    const std::string& path,
-    PrefHashStoreTransaction::ValueState result) {
+void MockPrefHashStore::SetCheckResult(const std::string& path,
+                                       ValueState result) {
   check_results_.insert(std::make_pair(path, result));
 }
 
@@ -227,10 +225,10 @@ void MockPrefHashStore::SetInvalidKeysResult(
     const std::string& path,
     const std::vector<std::string>& invalid_keys_result) {
   // Ensure |check_results_| has a CHANGED entry for |path|.
-  std::map<std::string, PrefHashStoreTransaction::ValueState>::const_iterator
-      result = check_results_.find(path);
+  std::map<std::string, ValueState>::const_iterator result =
+      check_results_.find(path);
   ASSERT_TRUE(result != check_results_.end());
-  ASSERT_EQ(PrefHashStoreTransaction::CHANGED, result->second);
+  ASSERT_EQ(ValueState::CHANGED, result->second);
 
   invalid_keys_results_.insert(std::make_pair(path, invalid_keys_result));
 }
@@ -259,39 +257,36 @@ std::unique_ptr<base::DictionaryValue> MockPrefHashStore::ComputeSplitMacs(
   return macs_dict;
 };
 
-PrefHashStoreTransaction::ValueState MockPrefHashStore::RecordCheckValue(
-    const std::string& path,
-    const base::Value* value,
-    PrefHashFilter::PrefTrackingStrategy strategy) {
+ValueState MockPrefHashStore::RecordCheckValue(const std::string& path,
+                                               const base::Value* value,
+                                               PrefTrackingStrategy strategy) {
   // Record that |path| was checked and validate that it wasn't previously
   // checked.
-  EXPECT_TRUE(checked_values_.insert(std::make_pair(
-                                         path, std::make_pair(value, strategy)))
+  EXPECT_TRUE(checked_values_
+                  .insert(std::make_pair(path, std::make_pair(value, strategy)))
                   .second);
-  std::map<std::string, PrefHashStoreTransaction::ValueState>::const_iterator
-      result = check_results_.find(path);
+  std::map<std::string, ValueState>::const_iterator result =
+      check_results_.find(path);
   if (result != check_results_.end())
     return result->second;
-  return PrefHashStoreTransaction::UNCHANGED;
+  return ValueState::UNCHANGED;
 }
 
-void MockPrefHashStore::RecordStoreHash(
-    const std::string& path,
-    const base::Value* new_value,
-    PrefHashFilter::PrefTrackingStrategy strategy) {
+void MockPrefHashStore::RecordStoreHash(const std::string& path,
+                                        const base::Value* new_value,
+                                        PrefTrackingStrategy strategy) {
   EXPECT_TRUE(
-      stored_values_.insert(std::make_pair(path,
-                                           std::make_pair(new_value, strategy)))
+      stored_values_
+          .insert(std::make_pair(path, std::make_pair(new_value, strategy)))
           .second);
 }
 
 base::StringPiece
-MockPrefHashStore::MockPrefHashStoreTransaction::GetStoreUMASuffix() const {
+MockPrefHashStore::MockPrefHashStoreTransaction ::GetStoreUMASuffix() const {
   return "unused";
 }
 
-PrefHashStoreTransaction::ValueState
-MockPrefHashStore::MockPrefHashStoreTransaction::CheckValue(
+ValueState MockPrefHashStore::MockPrefHashStoreTransaction::CheckValue(
     const std::string& path,
     const base::Value* value) const {
   return outer_->RecordCheckValue(path, value, PrefTrackingStrategy::ATOMIC);
@@ -303,8 +298,7 @@ void MockPrefHashStore::MockPrefHashStoreTransaction::StoreHash(
   outer_->RecordStoreHash(path, new_value, PrefTrackingStrategy::ATOMIC);
 }
 
-PrefHashStoreTransaction::ValueState
-MockPrefHashStore::MockPrefHashStoreTransaction::CheckSplitValue(
+ValueState MockPrefHashStore::MockPrefHashStoreTransaction::CheckSplitValue(
     const std::string& path,
     const base::DictionaryValue* initial_split_value,
     std::vector<std::string>* invalid_keys) const {
@@ -354,15 +348,12 @@ bool MockPrefHashStore::MockPrefHashStoreTransaction::StampSuperMac() {
   return outer_->stamp_super_mac_result_;
 }
 
-std::vector<PrefHashFilter::TrackedPreferenceMetadata> GetConfiguration(
-    PrefHashFilter::EnforcementLevel max_enforcement_level) {
-  std::vector<PrefHashFilter::TrackedPreferenceMetadata> configuration(
-      kTestTrackedPrefs, kTestTrackedPrefs + arraysize(kTestTrackedPrefs));
-  for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it =
-           configuration.begin();
-       it != configuration.end(); ++it) {
-    if (it->enforcement_level > max_enforcement_level)
-      it->enforcement_level = max_enforcement_level;
+std::vector<prefs::mojom::TrackedPreferenceMetadataPtr> GetConfiguration(
+    EnforcementLevel max_enforcement_level) {
+  auto configuration = prefs::ConstructTrackedConfiguration(kTestTrackedPrefs);
+  for (const auto& metadata : configuration) {
+    if (metadata->enforcement_level > max_enforcement_level)
+      metadata->enforcement_level = max_enforcement_level;
   }
   return configuration;
 }
@@ -550,8 +541,7 @@ void MockHashStoreContents::SetSuperMac(const std::string& super_mac) {
   ADD_FAILURE() << "Unexpected call.";
 }
 
-class PrefHashFilterTest
-    : public testing::TestWithParam<PrefHashFilter::EnforcementLevel> {
+class PrefHashFilterTest : public testing::TestWithParam<EnforcementLevel> {
  public:
   PrefHashFilterTest()
       : mock_pref_hash_store_(NULL),
@@ -575,8 +565,8 @@ class PrefHashFilterTest
   // Initializes |pref_hash_filter_| with a PrefHashFilter that uses a
   // MockPrefHashStore. The raw pointer to the MockPrefHashStore (owned by the
   // PrefHashFilter) is stored in |mock_pref_hash_store_|.
-  void InitializePrefHashFilter(const std::vector<
-      PrefHashFilter::TrackedPreferenceMetadata>& configuration) {
+  void InitializePrefHashFilter(
+      std::vector<prefs::mojom::TrackedPreferenceMetadataPtr> configuration) {
     std::unique_ptr<MockPrefHashStore> temp_mock_pref_hash_store(
         new MockPrefHashStore);
     std::unique_ptr<MockPrefHashStore>
@@ -594,7 +584,7 @@ class PrefHashFilterTest
         PrefHashFilter::StoreContentsPair(
             std::move(temp_mock_external_validation_pref_hash_store),
             std::move(temp_mock_external_validation_hash_store_contents)),
-        configuration,
+        std::move(configuration),
         base::Bind(&PrefHashFilterTest::RecordReset, base::Unretained(this)),
         &mock_validation_delegate_, arraysize(kTestTrackedPrefs), true));
   }
@@ -603,9 +593,8 @@ class PrefHashFilterTest
   // that kPreferenceResetTime was set (or not) accordingly.
   void VerifyRecordedReset(bool reset_expected) {
     EXPECT_EQ(reset_expected, reset_recorded_);
-    EXPECT_EQ(reset_expected,
-              pref_store_contents_->Get(
-                  user_prefs::kPreferenceResetTime, NULL));
+    EXPECT_EQ(reset_expected, pref_store_contents_->Get(
+                                  user_prefs::kPreferenceResetTime, NULL));
   }
 
   // Calls FilterOnLoad() on |pref_hash_Filter_|. |pref_store_contents_| is
@@ -672,7 +661,7 @@ TEST_P(PrefHashFilterTest, EmptyAndUnchanged) {
             mock_validation_delegate_record_->recorded_validations_count());
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_validation_delegate_record_->CountValidationsOfState(
-                PrefHashStoreTransaction::UNCHANGED));
+                ValueState::UNCHANGED));
 }
 
 TEST_P(PrefHashFilterTest, StampSuperMACAltersStore) {
@@ -833,10 +822,10 @@ 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);
+  mock_pref_hash_store_->SetCheckResult(kAtomicPref,
+                                        ValueState::TRUSTED_NULL_VALUE);
+  mock_pref_hash_store_->SetCheckResult(kSplitPref,
+                                        ValueState::TRUSTED_NULL_VALUE);
   DoFilterOnLoad(false);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
@@ -857,10 +846,10 @@ TEST_P(PrefHashFilterTest, UnknownNullValue) {
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_validation_delegate_record_->recorded_validations_count());
   ASSERT_EQ(2u, mock_validation_delegate_record_->CountValidationsOfState(
-                    PrefHashStoreTransaction::TRUSTED_NULL_VALUE));
+                    ValueState::TRUSTED_NULL_VALUE));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
             mock_validation_delegate_record_->CountValidationsOfState(
-                PrefHashStoreTransaction::UNCHANGED));
+                ValueState::UNCHANGED));
 
   const MockValidationDelegateRecord::ValidationEvent* validated_split_pref =
       mock_validation_delegate_record_->GetEventForPath(kSplitPref);
@@ -885,10 +874,10 @@ TEST_P(PrefHashFilterTest, InitialValueUnknown) {
   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);
+  mock_pref_hash_store_->SetCheckResult(kAtomicPref,
+                                        ValueState::UNTRUSTED_UNKNOWN_VALUE);
+  mock_pref_hash_store_->SetCheckResult(kSplitPref,
+                                        ValueState::UNTRUSTED_UNKNOWN_VALUE);
   // If we are enforcing, expect this to report changes.
   DoFilterOnLoad(GetParam() >= EnforcementLevel::ENFORCE_ON_LOAD);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
@@ -900,10 +889,10 @@ TEST_P(PrefHashFilterTest, InitialValueUnknown) {
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_validation_delegate_record_->recorded_validations_count());
   ASSERT_EQ(2u, mock_validation_delegate_record_->CountValidationsOfState(
-                    PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE));
+                    ValueState::UNTRUSTED_UNKNOWN_VALUE));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
             mock_validation_delegate_record_->CountValidationsOfState(
-                PrefHashStoreTransaction::UNCHANGED));
+                ValueState::UNCHANGED));
 
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
       mock_pref_hash_store_->stored_value(kAtomicPref);
@@ -951,10 +940,10 @@ TEST_P(PrefHashFilterTest, InitialValueTrustedUnknown) {
   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 
-  mock_pref_hash_store_->SetCheckResult(
-      kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE);
-  mock_pref_hash_store_->SetCheckResult(
-      kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE);
+  mock_pref_hash_store_->SetCheckResult(kAtomicPref,
+                                        ValueState::TRUSTED_UNKNOWN_VALUE);
+  mock_pref_hash_store_->SetCheckResult(kSplitPref,
+                                        ValueState::TRUSTED_UNKNOWN_VALUE);
   DoFilterOnLoad(false);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
@@ -965,10 +954,10 @@ TEST_P(PrefHashFilterTest, InitialValueTrustedUnknown) {
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_validation_delegate_record_->recorded_validations_count());
   ASSERT_EQ(2u, mock_validation_delegate_record_->CountValidationsOfState(
-                    PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE));
+                    ValueState::TRUSTED_UNKNOWN_VALUE));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
             mock_validation_delegate_record_->CountValidationsOfState(
-                PrefHashStoreTransaction::UNCHANGED));
+                ValueState::UNCHANGED));
 
   // Seeding is always allowed for trusted unknown values.
   const base::Value* atomic_value_in_store;
@@ -1003,10 +992,8 @@ TEST_P(PrefHashFilterTest, InitialValueChanged) {
   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);
+  mock_pref_hash_store_->SetCheckResult(kAtomicPref, ValueState::CHANGED);
+  mock_pref_hash_store_->SetCheckResult(kSplitPref, ValueState::CHANGED);
 
   std::vector<std::string> mock_invalid_keys;
   mock_invalid_keys.push_back("a");
@@ -1068,10 +1055,8 @@ TEST_P(PrefHashFilterTest, InitialValueChanged) {
 TEST_P(PrefHashFilterTest, EmptyCleared) {
   ASSERT_FALSE(pref_store_contents_->Get(kAtomicPref, NULL));
   ASSERT_FALSE(pref_store_contents_->Get(kSplitPref, NULL));
-  mock_pref_hash_store_->SetCheckResult(kAtomicPref,
-                                        PrefHashStoreTransaction::CLEARED);
-  mock_pref_hash_store_->SetCheckResult(kSplitPref,
-                                        PrefHashStoreTransaction::CLEARED);
+  mock_pref_hash_store_->SetCheckResult(kAtomicPref, ValueState::CLEARED);
+  mock_pref_hash_store_->SetCheckResult(kSplitPref, ValueState::CLEARED);
   DoFilterOnLoad(false);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
@@ -1082,10 +1067,10 @@ TEST_P(PrefHashFilterTest, EmptyCleared) {
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_validation_delegate_record_->recorded_validations_count());
   ASSERT_EQ(2u, mock_validation_delegate_record_->CountValidationsOfState(
-                    PrefHashStoreTransaction::CLEARED));
+                    ValueState::CLEARED));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
             mock_validation_delegate_record_->CountValidationsOfState(
-                PrefHashStoreTransaction::UNCHANGED));
+                ValueState::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.
@@ -1115,10 +1100,8 @@ TEST_P(PrefHashFilterTest, InitialValueUnchangedLegacyId) {
   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 
-  mock_pref_hash_store_->SetCheckResult(
-      kAtomicPref, PrefHashStoreTransaction::SECURE_LEGACY);
-  mock_pref_hash_store_->SetCheckResult(
-      kSplitPref, PrefHashStoreTransaction::SECURE_LEGACY);
+  mock_pref_hash_store_->SetCheckResult(kAtomicPref, ValueState::SECURE_LEGACY);
+  mock_pref_hash_store_->SetCheckResult(kSplitPref, ValueState::SECURE_LEGACY);
   DoFilterOnLoad(false);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
@@ -1128,10 +1111,10 @@ TEST_P(PrefHashFilterTest, InitialValueUnchangedLegacyId) {
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_validation_delegate_record_->recorded_validations_count());
   ASSERT_EQ(2u, mock_validation_delegate_record_->CountValidationsOfState(
-                    PrefHashStoreTransaction::SECURE_LEGACY));
+                    ValueState::SECURE_LEGACY));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
             mock_validation_delegate_record_->CountValidationsOfState(
-                PrefHashStoreTransaction::UNCHANGED));
+                ValueState::UNCHANGED));
 
   // Ensure that both the atomic and split hashes were restored.
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
@@ -1175,14 +1158,11 @@ TEST_P(PrefHashFilterTest, DontResetReportOnly) {
   ASSERT_TRUE(pref_store_contents_->Get(kReportOnlyPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kReportOnlySplitPref, NULL));
 
-  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(kAtomicPref, ValueState::CHANGED);
+  mock_pref_hash_store_->SetCheckResult(kAtomicPref2, ValueState::CHANGED);
+  mock_pref_hash_store_->SetCheckResult(kReportOnlyPref, ValueState::CHANGED);
   mock_pref_hash_store_->SetCheckResult(kReportOnlySplitPref,
-                                        PrefHashStoreTransaction::CHANGED);
+                                        ValueState::CHANGED);
 
   DoFilterOnLoad(GetParam() >= EnforcementLevel::ENFORCE_ON_LOAD);
   // All prefs should be checked and a new hash should be stored for each tested
@@ -1196,10 +1176,10 @@ TEST_P(PrefHashFilterTest, DontResetReportOnly) {
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_validation_delegate_record_->recorded_validations_count());
   ASSERT_EQ(4u, mock_validation_delegate_record_->CountValidationsOfState(
-                    PrefHashStoreTransaction::CHANGED));
+                    ValueState::CHANGED));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 4u,
             mock_validation_delegate_record_->CountValidationsOfState(
-                PrefHashStoreTransaction::UNCHANGED));
+                ValueState::UNCHANGED));
 
   // No matter what the enforcement level is, the report only pref should never
   // be reset.
@@ -1325,9 +1305,9 @@ TEST_P(PrefHashFilterTest, ExternalValidationValueChanged) {
   pref_store_contents_->Set(kSplitPref, dict_value);
 
   mock_external_validation_pref_hash_store_->SetCheckResult(
-      kAtomicPref, PrefHashStoreTransaction::CHANGED);
+      kAtomicPref, ValueState::CHANGED);
   mock_external_validation_pref_hash_store_->SetCheckResult(
-      kSplitPref, PrefHashStoreTransaction::CHANGED);
+      kSplitPref, ValueState::CHANGED);
 
   std::vector<std::string> mock_invalid_keys;
   mock_invalid_keys.push_back("a");
@@ -1350,15 +1330,15 @@ TEST_P(PrefHashFilterTest, ExternalValidationValueChanged) {
   // Regular validation should not have any CHANGED prefs.
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_validation_delegate_record_->CountValidationsOfState(
-                PrefHashStoreTransaction::UNCHANGED));
+                ValueState::UNCHANGED));
 
   // External validation should have two CHANGED prefs (kAtomic and kSplit).
   ASSERT_EQ(2u,
             mock_validation_delegate_record_->CountExternalValidationsOfState(
-                PrefHashStoreTransaction::CHANGED));
+                ValueState::CHANGED));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
             mock_validation_delegate_record_->CountExternalValidationsOfState(
-                PrefHashStoreTransaction::UNCHANGED));
+                ValueState::UNCHANGED));
 }
 
 INSTANTIATE_TEST_CASE_P(PrefHashFilterTestInstance,