Move tracked prefs into services/preferences/tracked.

services/preferences/tracked/pref_hash_store_impl_unittest.cc

Index: services/preferences/tracked/pref_hash_store_impl_unittest.cc
diff --git a/components/user_prefs/tracked/pref_hash_store_impl_unittest.cc b/services/preferences/tracked/pref_hash_store_impl_unittest.cc
similarity index 82%
rename from components/user_prefs/tracked/pref_hash_store_impl_unittest.cc
rename to services/preferences/tracked/pref_hash_store_impl_unittest.cc
index 3abbf911cc22ebbc3b7faf639593a163b63003bf..3c6ca13126f0594fdcdf8b92d2e36997078b4cd5 100644
--- a/components/user_prefs/tracked/pref_hash_store_impl_unittest.cc
+++ b/services/preferences/tracked/pref_hash_store_impl_unittest.cc
@@ -2,18 +2,20 @@
 // 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_store_impl.h"
+#include "services/preferences/tracked/pref_hash_store_impl.h"
 
 #include <string>
 
 #include "base/macros.h"
 #include "base/values.h"
-#include "components/user_prefs/tracked/dictionary_hash_store_contents.h"
-#include "components/user_prefs/tracked/hash_store_contents.h"
-#include "components/user_prefs/tracked/pref_hash_store_impl.h"
-#include "components/user_prefs/tracked/pref_hash_store_transaction.h"
+#include "services/preferences/tracked/dictionary_hash_store_contents.h"
+#include "services/preferences/tracked/hash_store_contents.h"
+#include "services/preferences/tracked/pref_hash_store_transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ValueState =
+    prefs::mojom::TrackedPreferenceValidationDelegate::ValueState;
+
 class PrefHashStoreImplTest : public testing::Test {
  public:
   PrefHashStoreImplTest() : contents_(&pref_store_contents_) {}
@@ -80,21 +82,18 @@ TEST_F(PrefHashStoreImplTest, AtomicHashStoreAndCheck) {
         pref_hash_store.BeginTransaction(GetHashStoreContents()));
 
     // Only NULL should be trusted in the absence of a hash.
-    EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
+    EXPECT_EQ(ValueState::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("path1", &string_1));
-    EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_NULL_VALUE,
+    EXPECT_EQ(ValueState::TRUSTED_NULL_VALUE,
               transaction->CheckValue("path1", NULL));
 
     transaction->StoreHash("path1", &string_1);
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
+    EXPECT_EQ(ValueState::UNCHANGED,
               transaction->CheckValue("path1", &string_1));
-    EXPECT_EQ(PrefHashStoreTransaction::CLEARED,
-              transaction->CheckValue("path1", NULL));
+    EXPECT_EQ(ValueState::CLEARED, transaction->CheckValue("path1", NULL));
     transaction->StoreHash("path1", NULL);
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
-              transaction->CheckValue("path1", NULL));
-    EXPECT_EQ(PrefHashStoreTransaction::CHANGED,
-              transaction->CheckValue("path1", &string_2));
+    EXPECT_EQ(ValueState::UNCHANGED, transaction->CheckValue("path1", NULL));
+    EXPECT_EQ(ValueState::CHANGED, transaction->CheckValue("path1", &string_2));
 
     base::DictionaryValue dict;
     dict.Set("a", new base::Value("foo"));
@@ -103,8 +102,7 @@ TEST_F(PrefHashStoreImplTest, AtomicHashStoreAndCheck) {
     dict.Set("c", new base::Value("baz"));
 
     transaction->StoreHash("path1", &dict);
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
-              transaction->CheckValue("path1", &dict));
+    EXPECT_EQ(ValueState::UNCHANGED, transaction->CheckValue("path1", &dict));
   }
 
   ASSERT_FALSE(GetHashStoreContents()->GetSuperMac().empty());
@@ -115,11 +113,11 @@ TEST_F(PrefHashStoreImplTest, AtomicHashStoreAndCheck) {
     PrefHashStoreImpl pref_hash_store2(std::string(32, 0), "device_id", true);
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store2.BeginTransaction(GetHashStoreContents()));
-    EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
+    EXPECT_EQ(ValueState::TRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("new_path", &string_1));
-    EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
+    EXPECT_EQ(ValueState::TRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("new_path", &string_2));
-    EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_NULL_VALUE,
+    EXPECT_EQ(ValueState::TRUSTED_NULL_VALUE,
               transaction->CheckValue("new_path", NULL));
   }
 
@@ -132,11 +130,11 @@ TEST_F(PrefHashStoreImplTest, AtomicHashStoreAndCheck) {
     PrefHashStoreImpl pref_hash_store3(std::string(32, 0), "device_id", true);
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store3.BeginTransaction(GetHashStoreContents()));
-    EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
+    EXPECT_EQ(ValueState::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("new_path", &string_1));
-    EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
+    EXPECT_EQ(ValueState::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("new_path", &string_2));
-    EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_NULL_VALUE,
+    EXPECT_EQ(ValueState::TRUSTED_NULL_VALUE,
               transaction->CheckValue("new_path", NULL));
   }
 }
@@ -158,10 +156,9 @@ TEST_F(PrefHashStoreImplTest, ImportExportOperations) {
     transaction->StoreHash("path1", &string_1);
 
     ASSERT_TRUE(transaction->HasHash("path1"));
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
+    EXPECT_EQ(ValueState::UNCHANGED,
               transaction->CheckValue("path1", &string_1));
-    EXPECT_EQ(PrefHashStoreTransaction::CHANGED,
-              transaction->CheckValue("path1", &string_2));
+    EXPECT_EQ(ValueState::CHANGED, transaction->CheckValue("path1", &string_2));
   }
 
   // Make a copy of the stored hash for future use.
@@ -183,9 +180,9 @@ TEST_F(PrefHashStoreImplTest, ImportExportOperations) {
 
     // The effects of the clear should be immediately visible.
     ASSERT_FALSE(transaction->HasHash("path1"));
-    EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_NULL_VALUE,
+    EXPECT_EQ(ValueState::TRUSTED_NULL_VALUE,
               transaction->CheckValue("path1", NULL));
-    EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
+    EXPECT_EQ(ValueState::TRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("path1", &string_1));
   }
 
@@ -214,7 +211,7 @@ TEST_F(PrefHashStoreImplTest, ImportExportOperations) {
     ASSERT_TRUE(transaction->HasHash("path1"));
 
     // The imported hash should be usable for validating the original value.
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
+    EXPECT_EQ(ValueState::UNCHANGED,
               transaction->CheckValue("path1", &string_1));
   }
 
@@ -225,15 +222,15 @@ TEST_F(PrefHashStoreImplTest, ImportExportOperations) {
         pref_hash_store.BeginTransaction(GetHashStoreContents()));
     ASSERT_FALSE(transaction->IsSuperMACValid());
     ASSERT_TRUE(transaction->HasHash("path1"));
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
+    EXPECT_EQ(ValueState::UNCHANGED,
               transaction->CheckValue("path1", &string_1));
 
     // After clearing the hash, non-null values are UNTRUSTED_UNKNOWN.
     transaction->ClearHash("path1");
 
-    EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_NULL_VALUE,
+    EXPECT_EQ(ValueState::TRUSTED_NULL_VALUE,
               transaction->CheckValue("path1", NULL));
-    EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
+    EXPECT_EQ(ValueState::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("path1", &string_1));
   }
 
@@ -256,9 +253,8 @@ TEST_F(PrefHashStoreImplTest, ImportExportOperations) {
 
     // Store the hash of a different value to test an "over-import".
     transaction->StoreHash("path1", &string_2);
-    EXPECT_EQ(PrefHashStoreTransaction::CHANGED,
-              transaction->CheckValue("path1", &string_1));
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
+    EXPECT_EQ(ValueState::CHANGED, transaction->CheckValue("path1", &string_1));
+    EXPECT_EQ(ValueState::UNCHANGED,
               transaction->CheckValue("path1", &string_2));
   }
 
@@ -270,10 +266,9 @@ TEST_F(PrefHashStoreImplTest, ImportExportOperations) {
 
     // "Over-import". An import should preserve validity.
     transaction->ImportHash("path1", path_1_string_1_hash_copy.get());
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
+    EXPECT_EQ(ValueState::UNCHANGED,
               transaction->CheckValue("path1", &string_1));
-    EXPECT_EQ(PrefHashStoreTransaction::CHANGED,
-              transaction->CheckValue("path1", &string_2));
+    EXPECT_EQ(ValueState::CHANGED, transaction->CheckValue("path1", &string_2));
   }
 
   // Verify that validity was preserved and the "over-import" took effect.
@@ -282,10 +277,9 @@ TEST_F(PrefHashStoreImplTest, ImportExportOperations) {
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store.BeginTransaction(GetHashStoreContents()));
     ASSERT_TRUE(transaction->IsSuperMACValid());
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
+    EXPECT_EQ(ValueState::UNCHANGED,
               transaction->CheckValue("path1", &string_1));
-    EXPECT_EQ(PrefHashStoreTransaction::CHANGED,
-              transaction->CheckValue("path1", &string_2));
+    EXPECT_EQ(ValueState::CHANGED, transaction->CheckValue("path1", &string_2));
   }
 }
 
@@ -300,7 +294,7 @@ TEST_F(PrefHashStoreImplTest, SuperMACDisabled) {
         pref_hash_store.BeginTransaction(GetHashStoreContents()));
 
     transaction->StoreHash("path1", &string_2);
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
+    EXPECT_EQ(ValueState::UNCHANGED,
               transaction->CheckValue("path1", &string_2));
   }
 
@@ -310,7 +304,7 @@ TEST_F(PrefHashStoreImplTest, SuperMACDisabled) {
     PrefHashStoreImpl pref_hash_store2(std::string(32, 0), "device_id", false);
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store2.BeginTransaction(GetHashStoreContents()));
-    EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
+    EXPECT_EQ(ValueState::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("new_path", &string_1));
   }
 }
@@ -337,35 +331,33 @@ TEST_F(PrefHashStoreImplTest, SplitHashStoreAndCheck) {
 
     // No hashes stored yet and hashes dictionary is empty (and thus not
     // trusted).
-    EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
+    EXPECT_EQ(ValueState::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckSplitValue("path1", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
 
     transaction->StoreSplitHash("path1", &dict);
 
     // Verify match post storage.
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
+    EXPECT_EQ(ValueState::UNCHANGED,
               transaction->CheckSplitValue("path1", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
 
     // Verify new path is still unknown.
-    EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
+    EXPECT_EQ(ValueState::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckSplitValue("path2", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
 
     // Verify NULL or empty dicts are declared as having been cleared.
-    EXPECT_EQ(PrefHashStoreTransaction::CLEARED,
+    EXPECT_EQ(ValueState::CLEARED,
               transaction->CheckSplitValue("path1", NULL, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
-    EXPECT_EQ(
-        PrefHashStoreTransaction::CLEARED,
-        transaction->CheckSplitValue("path1", &empty_dict, &invalid_keys));
+    EXPECT_EQ(ValueState::CLEARED, transaction->CheckSplitValue(
+                                       "path1", &empty_dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
 
     // Verify changes are properly detected.
-    EXPECT_EQ(
-        PrefHashStoreTransaction::CHANGED,
-        transaction->CheckSplitValue("path1", &modified_dict, &invalid_keys));
+    EXPECT_EQ(ValueState::CHANGED, transaction->CheckSplitValue(
+                                       "path1", &modified_dict, &invalid_keys));
     std::vector<std::string> expected_invalid_keys1;
     expected_invalid_keys1.push_back("a");
     expected_invalid_keys1.push_back("c");
@@ -374,7 +366,7 @@ TEST_F(PrefHashStoreImplTest, SplitHashStoreAndCheck) {
     invalid_keys.clear();
 
     // Verify |dict| still matches post check.
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
+    EXPECT_EQ(ValueState::UNCHANGED,
               transaction->CheckSplitValue("path1", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
 
@@ -383,12 +375,12 @@ TEST_F(PrefHashStoreImplTest, SplitHashStoreAndCheck) {
 
     // Verify |modified_dict| is now the one that verifies correctly.
     EXPECT_EQ(
-        PrefHashStoreTransaction::UNCHANGED,
+        ValueState::UNCHANGED,
         transaction->CheckSplitValue("path1", &modified_dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
 
     // Verify old dict no longer matches.
-    EXPECT_EQ(PrefHashStoreTransaction::CHANGED,
+    EXPECT_EQ(ValueState::CHANGED,
               transaction->CheckSplitValue("path1", &dict, &invalid_keys));
     std::vector<std::string> expected_invalid_keys2;
     expected_invalid_keys2.push_back("a");
@@ -404,7 +396,7 @@ TEST_F(PrefHashStoreImplTest, SplitHashStoreAndCheck) {
     PrefHashStoreImpl pref_hash_store2(std::string(32, 0), "device_id", true);
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store2.BeginTransaction(GetHashStoreContents()));
-    EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
+    EXPECT_EQ(ValueState::TRUSTED_UNKNOWN_VALUE,
               transaction->CheckSplitValue("new_path", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
   }
@@ -418,7 +410,7 @@ TEST_F(PrefHashStoreImplTest, SplitHashStoreAndCheck) {
     PrefHashStoreImpl pref_hash_store3(std::string(32, 0), "device_id", true);
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store3.BeginTransaction(GetHashStoreContents()));
-    EXPECT_EQ(PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE,
+    EXPECT_EQ(ValueState::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckSplitValue("new_path", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
   }
@@ -441,22 +433,20 @@ TEST_F(PrefHashStoreImplTest, EmptyAndNULLSplitDict) {
 
     // Verify stored empty dictionary matches NULL and empty dictionary back.
     transaction->StoreSplitHash("path1", &empty_dict);
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
+    EXPECT_EQ(ValueState::UNCHANGED,
               transaction->CheckSplitValue("path1", NULL, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
-    EXPECT_EQ(
-        PrefHashStoreTransaction::UNCHANGED,
-        transaction->CheckSplitValue("path1", &empty_dict, &invalid_keys));
+    EXPECT_EQ(ValueState::UNCHANGED, transaction->CheckSplitValue(
+                                         "path1", &empty_dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
 
     // Same when storing NULL directly.
     transaction->StoreSplitHash("path1", NULL);
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
+    EXPECT_EQ(ValueState::UNCHANGED,
               transaction->CheckSplitValue("path1", NULL, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
-    EXPECT_EQ(
-        PrefHashStoreTransaction::UNCHANGED,
-        transaction->CheckSplitValue("path1", &empty_dict, &invalid_keys));
+    EXPECT_EQ(ValueState::UNCHANGED, transaction->CheckSplitValue(
+                                         "path1", &empty_dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
   }
 
@@ -474,7 +464,7 @@ TEST_F(PrefHashStoreImplTest, EmptyAndNULLSplitDict) {
     tested_dict.Set("a", new base::Value("foo"));
     tested_dict.Set("b", new base::Value("bar"));
     EXPECT_EQ(
-        PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
+        ValueState::TRUSTED_UNKNOWN_VALUE,
         transaction->CheckSplitValue("new_path", &tested_dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
   }
@@ -501,8 +491,7 @@ TEST_F(PrefHashStoreImplTest, TrustedUnknownSplitValueFromExistingAtomic) {
         pref_hash_store.BeginTransaction(GetHashStoreContents()));
 
     transaction->StoreHash("path1", &string);
-    EXPECT_EQ(PrefHashStoreTransaction::UNCHANGED,
-              transaction->CheckValue("path1", &string));
+    EXPECT_EQ(ValueState::UNCHANGED, transaction->CheckValue("path1", &string));
   }
 
   {
@@ -511,7 +500,7 @@ TEST_F(PrefHashStoreImplTest, TrustedUnknownSplitValueFromExistingAtomic) {
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store2.BeginTransaction(GetHashStoreContents()));
     std::vector<std::string> invalid_keys;
-    EXPECT_EQ(PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE,
+    EXPECT_EQ(ValueState::TRUSTED_UNKNOWN_VALUE,
               transaction->CheckSplitValue("path1", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
   }