Move tracked prefs into services/preferences/tracked.

services/preferences/tracked/pref_hash_store_impl.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_store_impl.h"
+#include "services/preferences/tracked/pref_hash_store_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
-#include "components/user_prefs/tracked/device_id.h"
-#include "components/user_prefs/tracked/hash_store_contents.h"
+#include "services/preferences/tracked/device_id.h"
+#include "services/preferences/tracked/hash_store_contents.h"
 
 namespace {
 
+using ValueState =
+    prefs::mojom::TrackedPreferenceValidationDelegate::ValueState;
+
 // Returns a deterministic ID for this machine.
 std::string GenerateDeviceId() {
   static std::string cached_device_id;
   if (!cached_device_id.empty())
     return cached_device_id;
 
   std::string device_id;
   MachineIdStatus status = GetDeterministicMachineSpecificId(&device_id);
   if (status != MachineIdStatus::NOT_IMPLEMENTED) {
     // TODO(proberge): Remove this histogram once we validate that machine id
@@ skipping 47 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PrefHashStoreTransactionImpl);
 };
 
 PrefHashStoreImpl::PrefHashStoreImpl(const std::string& seed,
                                      const std::string& legacy_device_id,
                                      bool use_super_mac)
     : pref_hash_calculator_(seed, GenerateDeviceId(), legacy_device_id),
       use_super_mac_(use_super_mac) {}
 
-PrefHashStoreImpl::~PrefHashStoreImpl() {
-}
+PrefHashStoreImpl::~PrefHashStoreImpl() {}
 
 std::unique_ptr<PrefHashStoreTransaction> PrefHashStoreImpl::BeginTransaction(
     HashStoreContents* storage) {
   return std::unique_ptr<PrefHashStoreTransaction>(
       new PrefHashStoreTransactionImpl(this, std::move(storage)));
 }
 
 std::string PrefHashStoreImpl::ComputeMac(const std::string& path,
                                           const base::Value* value) {
   return pref_hash_calculator_.Calculate(path, value);
@@ skipping 50 matching lines @@
     const base::DictionaryValue* hashes_dict = contents_->GetContents();
     contents_->SetSuperMac(outer_->ComputeMac("", hashes_dict));
   }
 }
 
 base::StringPiece
 PrefHashStoreImpl::PrefHashStoreTransactionImpl::GetStoreUMASuffix() const {
   return contents_->GetUMASuffix();
 }
 
-PrefHashStoreTransaction::ValueState
-PrefHashStoreImpl::PrefHashStoreTransactionImpl::CheckValue(
+ValueState PrefHashStoreImpl::PrefHashStoreTransactionImpl::CheckValue(
     const std::string& path,
     const base::Value* initial_value) const {
   std::string last_hash;
   contents_->GetMac(path, &last_hash);
 
   if (last_hash.empty()) {
     // In the absence of a hash for this pref, always trust a NULL value, but
     // only trust an existing value if the initial hashes dictionary is trusted.
     if (!initial_value)
-      return TRUSTED_NULL_VALUE;
+      return ValueState::TRUSTED_NULL_VALUE;
     else if (super_mac_valid_)
-      return TRUSTED_UNKNOWN_VALUE;
+      return ValueState::TRUSTED_UNKNOWN_VALUE;
     else
-      return UNTRUSTED_UNKNOWN_VALUE;
+      return ValueState::UNTRUSTED_UNKNOWN_VALUE;
   }
 
   PrefHashCalculator::ValidationResult validation_result =
       outer_->pref_hash_calculator_.Validate(path, initial_value, last_hash);
   switch (validation_result) {
     case PrefHashCalculator::VALID:
-      return UNCHANGED;
+      return ValueState::UNCHANGED;
     case PrefHashCalculator::VALID_SECURE_LEGACY:
-      return SECURE_LEGACY;
+      return ValueState::SECURE_LEGACY;
     case PrefHashCalculator::INVALID:
-      return initial_value ? CHANGED : CLEARED;
+      return initial_value ? ValueState::CHANGED : ValueState::CLEARED;
   }
   NOTREACHED() << "Unexpected PrefHashCalculator::ValidationResult: "
                << validation_result;
-  return UNTRUSTED_UNKNOWN_VALUE;
+  return ValueState::UNTRUSTED_UNKNOWN_VALUE;
 }
 
 void PrefHashStoreImpl::PrefHashStoreTransactionImpl::StoreHash(
     const std::string& path,
     const base::Value* new_value) {
   const std::string mac = outer_->ComputeMac(path, new_value);
   contents_->SetMac(path, mac);
   super_mac_dirty_ = true;
 }
 
-PrefHashStoreTransaction::ValueState
-PrefHashStoreImpl::PrefHashStoreTransactionImpl::CheckSplitValue(
+ValueState PrefHashStoreImpl::PrefHashStoreTransactionImpl::CheckSplitValue(
     const std::string& path,
     const base::DictionaryValue* initial_split_value,
     std::vector<std::string>* invalid_keys) const {
   DCHECK(invalid_keys && invalid_keys->empty());
 
   std::map<std::string, std::string> split_macs;
   const bool has_hashes = contents_->GetSplitMacs(path, &split_macs);
 
   // Treat NULL and empty the same; otherwise we would need to store a hash for
   // the entire dictionary (or some other special beacon) to differentiate these
   // two cases which are really the same for dictionaries.
   if (!initial_split_value || initial_split_value->empty())
-    return has_hashes ? CLEARED : UNCHANGED;
+    return has_hashes ? ValueState::CLEARED : ValueState::UNCHANGED;
 
   if (!has_hashes)
-    return super_mac_valid_ ? TRUSTED_UNKNOWN_VALUE : UNTRUSTED_UNKNOWN_VALUE;
+    return super_mac_valid_ ? ValueState::TRUSTED_UNKNOWN_VALUE
+                            : ValueState::UNTRUSTED_UNKNOWN_VALUE;
 
   bool has_secure_legacy_id_hashes = false;
   std::string keyed_path(path);
   keyed_path.push_back('.');
   const size_t common_part_length = keyed_path.length();
   for (base::DictionaryValue::Iterator it(*initial_split_value); !it.IsAtEnd();
        it.Advance()) {
     std::map<std::string, std::string>::iterator entry =
         split_macs.find(it.key());
     if (entry == split_macs.end()) {
       invalid_keys->push_back(it.key());
     } else {
       // Keep the common part from the old |keyed_path| and replace the key to
       // get the new |keyed_path|.
       keyed_path.replace(common_part_length, std::string::npos, it.key());
       switch (outer_->pref_hash_calculator_.Validate(keyed_path, &it.value(),
                                                      entry->second)) {
         case PrefHashCalculator::VALID:
           break;
-        case SECURE_LEGACY:
+        case PrefHashCalculator::VALID_SECURE_LEGACY:
           // Secure legacy device IDs based hashes are still accepted, but we
           // should make sure to notify the caller for them to update the legacy
           // hashes.
           has_secure_legacy_id_hashes = true;
           break;
         case PrefHashCalculator::INVALID:
           invalid_keys->push_back(it.key());
           break;
       }
       // Remove processed MACs, remaining MACs at the end will also be
       // considered invalid.
       split_macs.erase(entry);
     }
   }
 
   // Anything left in the map is missing from the data.
   for (std::map<std::string, std::string>::const_iterator it =
            split_macs.begin();
        it != split_macs.end(); ++it) {
     invalid_keys->push_back(it->first);
   }
 
   return invalid_keys->empty()
-             ? (has_secure_legacy_id_hashes ? SECURE_LEGACY : UNCHANGED)
-             : CHANGED;
+             ? (has_secure_legacy_id_hashes ? ValueState::SECURE_LEGACY
+                                            : ValueState::UNCHANGED)
+             : ValueState::CHANGED;
 }
 
 void PrefHashStoreImpl::PrefHashStoreTransactionImpl::StoreSplitHash(
     const std::string& path,
     const base::DictionaryValue* split_value) {
   contents_->RemoveEntry(path);
 
   if (split_value) {
     std::unique_ptr<base::DictionaryValue> split_macs =
         outer_->ComputeSplitMacs(path, split_value);
@@ skipping 39 matching lines @@
 bool PrefHashStoreImpl::PrefHashStoreTransactionImpl::IsSuperMACValid() const {
   return super_mac_valid_;
 }
 
 bool PrefHashStoreImpl::PrefHashStoreTransactionImpl::StampSuperMac() {
   if (!outer_->use_super_mac_ || super_mac_valid_)
     return false;
   super_mac_dirty_ = true;
   return true;
 }