Replace uses of uint8 with uint8_t.

content/child/webcrypto/jwk.cc

 // Copyright 2014 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 "jwk.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>
 
@@ skipping 223 matching lines @@
     dict_.SetString(key, value);
   }
 
   void SetBase64Encoded(const std::string& key, const CryptoData& value) {
     dict_.SetString(key,
                     Base64EncodeUrlSafe(base::StringPiece(
                         reinterpret_cast<const char*>(value.bytes()),
                         value.byte_length())));
   }
 
-  void ToBytes(std::vector<uint8>* utf8_bytes) {
+  void ToBytes(std::vector<uint8_t>* utf8_bytes) {
     std::string json;
     base::JSONWriter::Write(&dict_, &json);
     utf8_bytes->assign(json.begin(), json.end());
   }
 
  private:
   base::DictionaryValue dict_;
 };
 
 // Extracts the required string property with key |path| from |dict| and saves
@@ skipping 220 matching lines @@
   if (status.IsError())
     return status;
 
   return Status::Success();
 }
 
 Status ReadSecretKeyNoExpectedAlg(
     const CryptoData& key_data,
     bool expected_extractable,
     blink::WebCryptoKeyUsageMask expected_usage_mask,
-    std::vector<uint8>* raw_key_data,
+    std::vector<uint8_t>* raw_key_data,
     scoped_ptr<base::DictionaryValue>* dict) {
   if (!key_data.byte_length())
     return Status::ErrorImportEmptyKeyData();
 
   std::string kty;
   Status status = ParseJwkCommon(
       key_data, expected_extractable, expected_usage_mask, &kty, dict);
   if (status.IsError())
     return status;
 
   if (kty != "oct")
     return Status::ErrorJwkUnexpectedKty("oct");
 
   std::string jwk_k_value;
   status = GetJwkBytes(dict->get(), "k", &jwk_k_value);
   if (status.IsError())
     return status;
   raw_key_data->assign(jwk_k_value.begin(), jwk_k_value.end());
 
   return Status::Success();
 }
 
 }  // namespace
 
 void WriteSecretKeyJwk(const CryptoData& raw_key_data,
                        const std::string& algorithm,
                        bool extractable,
                        blink::WebCryptoKeyUsageMask usage_mask,
-                       std::vector<uint8>* jwk_key_data) {
+                       std::vector<uint8_t>* jwk_key_data) {
   JwkWriter writer(algorithm, extractable, usage_mask, "oct");
   writer.SetBase64Encoded("k", raw_key_data);
   writer.ToBytes(jwk_key_data);
 }
 
 Status ReadSecretKeyJwk(const CryptoData& key_data,
                         const std::string& expected_algorithm,
                         bool expected_extractable,
                         blink::WebCryptoKeyUsageMask expected_usage_mask,
-                        std::vector<uint8>* raw_key_data) {
+                        std::vector<uint8_t>* raw_key_data) {
   scoped_ptr<base::DictionaryValue> dict;
   Status status = ReadSecretKeyNoExpectedAlg(
       key_data, expected_extractable, expected_usage_mask, raw_key_data, &dict);
   if (status.IsError())
     return status;
   return VerifyAlg(dict.get(), expected_algorithm);
 }
 
 std::string MakeJwkAesAlgorithmName(const std::string& suffix,
                                     unsigned int keylen_bytes) {
   if (keylen_bytes == 16)
     return std::string("A128") + suffix;
   if (keylen_bytes == 24)
     return std::string("A192") + suffix;
   if (keylen_bytes == 32)
     return std::string("A256") + suffix;
   return std::string();
 }
 
 Status ReadAesSecretKeyJwk(const CryptoData& key_data,
                            const std::string& algorithm_name_suffix,
                            bool expected_extractable,
                            blink::WebCryptoKeyUsageMask expected_usage_mask,
-                           std::vector<uint8>* raw_key_data) {
+                           std::vector<uint8_t>* raw_key_data) {
   scoped_ptr<base::DictionaryValue> dict;
   Status status = ReadSecretKeyNoExpectedAlg(
       key_data, expected_extractable, expected_usage_mask, raw_key_data, &dict);
   if (status.IsError())
     return status;
 
   bool has_jwk_alg;
   std::string jwk_alg;
   status = GetOptionalJwkString(dict.get(), "alg", &jwk_alg, &has_jwk_alg);
   if (status.IsError())
@@ skipping 16 matching lines @@
 
   return Status::Success();
 }
 
 // Writes an RSA public key to a JWK dictionary
 void WriteRsaPublicKeyJwk(const CryptoData& n,
                           const CryptoData& e,
                           const std::string& algorithm,
                           bool extractable,
                           blink::WebCryptoKeyUsageMask usage_mask,
-                          std::vector<uint8>* jwk_key_data) {
+                          std::vector<uint8_t>* jwk_key_data) {
   JwkWriter writer(algorithm, extractable, usage_mask, "RSA");
   writer.SetBase64Encoded("n", n);
   writer.SetBase64Encoded("e", e);
   writer.ToBytes(jwk_key_data);
 }
 
 // Writes an RSA private key to a JWK dictionary
 void WriteRsaPrivateKeyJwk(const CryptoData& n,
                            const CryptoData& e,
                            const CryptoData& d,
                            const CryptoData& p,
                            const CryptoData& q,
                            const CryptoData& dp,
                            const CryptoData& dq,
                            const CryptoData& qi,
                            const std::string& algorithm,
                            bool extractable,
                            blink::WebCryptoKeyUsageMask usage_mask,
-                           std::vector<uint8>* jwk_key_data) {
+                           std::vector<uint8_t>* jwk_key_data) {
   JwkWriter writer(algorithm, extractable, usage_mask, "RSA");
 
   writer.SetBase64Encoded("n", n);
   writer.SetBase64Encoded("e", e);
   writer.SetBase64Encoded("d", d);
   // Although these are "optional" in the JWA, WebCrypto spec requires them to
   // be emitted.
   writer.SetBase64Encoded("p", p);
   writer.SetBase64Encoded("q", q);
   writer.SetBase64Encoded("dp", dp);
@@ skipping 97 matching lines @@
     case blink::WebCryptoAlgorithmIdSha512:
       return "HS512";
     default:
       return NULL;
   }
 }
 
 }  // namespace webcrypto
 
 }  // namespace content