Switch to standard integer types in components/, part 4 of 4.

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 "components/user_prefs/tracked/pref_hash_calculator.h"
 
+#include <stdint.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"
 
 namespace {
 
 // Calculates an HMAC of |message| using |key|, encoded as a hexadecimal string.
 std::string GetDigestString(const std::string& key,
                             const std::string& message) {
   crypto::HMAC hmac(crypto::HMAC::SHA256);
-  std::vector<uint8> digest(hmac.DigestLength());
+  std::vector<uint8_t> digest(hmac.DigestLength());
   if (!hmac.Init(key) || !hmac.Sign(message, &digest[0], digest.size())) {
     NOTREACHED();
     return std::string();
   }
   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;
+  std::vector<uint8_t> digest;
   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) {
@@ skipping 68 matching lines @@
                          digest_string)) {
     return VALID;
   }
   if (VerifyDigestString(seed_,
                          GetMessage(legacy_device_id_, path, value_as_string),
                          digest_string)) {
     return VALID_SECURE_LEGACY;
   }
   return INVALID;
 }