Componentize //chrome/browser/prefs/tracked.

components/user_prefs/tracked/pref_hash_calculator.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 "chrome/browser/prefs/tracked/pref_hash_calculator.h"
+#include "components/user_prefs/tracked/pref_hash_calculator.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "crypto/hmac.h"
@@ skipping 12 matching lines @@
   return base::HexEncode(&digest[0], digest.size());
 }
 
 // Verifies that |digest_string| is a valid HMAC of |message| using |key|.
 // |digest_string| must be encoded as a hexadecimal string.
 bool VerifyDigestString(const std::string& key,
                         const std::string& message,
                         const std::string& digest_string) {
   crypto::HMAC hmac(crypto::HMAC::SHA256);
   std::vector<uint8> digest;
-  return base::HexStringToBytes(digest_string, &digest) &&
-      hmac.Init(key) &&
-      hmac.Verify(message,
-                  base::StringPiece(reinterpret_cast<char*>(&digest[0]),
-                                    digest.size()));
+  return base::HexStringToBytes(digest_string, &digest) && hmac.Init(key) &&
+         hmac.Verify(message,
+                     base::StringPiece(reinterpret_cast<char*>(&digest[0]),
+                                       digest.size()));
 }
 
 // Renders |value| as a string. |value| may be NULL, in which case the result
 // is an empty string. This method can be expensive and its result should be
 // re-used rather than recomputed where possible.
 std::string ValueAsString(const base::Value* value) {
   // Dictionary values may contain empty lists and sub-dictionaries. Make a
   // deep copy with those removed to make the hash more stable.
   const base::DictionaryValue* dict_value;
   scoped_ptr<base::DictionaryValue> canonical_dict_value;
@@ skipping 36 matching lines @@
   return base::StringToLowerASCII(
       GetDigestString(original_device_id, "PrefMetricsService"));
 }
 
 }  // namespace
 
 PrefHashCalculator::PrefHashCalculator(const std::string& seed,
                                        const std::string& device_id)
     : seed_(seed),
       device_id_(device_id),
-      legacy_device_id_(GenerateDeviceIdLikePrefMetricsServiceDid(device_id)) {}
+      legacy_device_id_(GenerateDeviceIdLikePrefMetricsServiceDid(device_id)) {
+}
 
-PrefHashCalculator::~PrefHashCalculator() {}
+PrefHashCalculator::~PrefHashCalculator() {
+}
 
 std::string PrefHashCalculator::Calculate(const std::string& path,
                                           const base::Value* value) const {
   return GetDigestString(seed_,
                          GetMessage(device_id_, path, ValueAsString(value)));
 }
 
 PrefHashCalculator::ValidationResult PrefHashCalculator::Validate(
     const std::string& path,
     const base::Value* value,
     const std::string& digest_string) const {
   const std::string value_as_string(ValueAsString(value));
   if (VerifyDigestString(seed_, GetMessage(device_id_, path, value_as_string),
                          digest_string)) {
     return VALID;
   }
   if (VerifyDigestString(seed_,
                          GetMessage(legacy_device_id_, path, value_as_string),
                          digest_string)) {
     return VALID_SECURE_LEGACY;
   }
   return INVALID;
 }