Replace uses of uint8 with uint8_t.

content/child/webcrypto/shared_crypto_unittest.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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
@@ skipping 85 matching lines @@
 }
 
 namespace {
 
 // -----------------------------------------------------------------------------
 
 // TODO(eroman): For Linux builds using system NSS, AES-GCM support is a
 // runtime dependency. Test it by trying to import a key.
 // TODO(padolph): Consider caching the result of the import key test.
 bool SupportsAesGcm() {
-  std::vector<uint8> key_raw(16, 0);
+  std::vector<uint8_t> key_raw(16, 0);
 
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   Status status = ImportKey(blink::WebCryptoKeyFormatRaw,
                             CryptoData(key_raw),
                             CreateAlgorithm(blink::WebCryptoAlgorithmIdAesGcm),
                             true,
                             blink::WebCryptoKeyUsageEncrypt,
                             &key);
 
   if (status.IsError())
@@ skipping 26 matching lines @@
     return false;
   }
 #endif
   return true;
 }
 
 blink::WebCryptoAlgorithm CreateRsaHashedKeyGenAlgorithm(
     blink::WebCryptoAlgorithmId algorithm_id,
     const blink::WebCryptoAlgorithmId hash_id,
     unsigned int modulus_length,
-    const std::vector<uint8>& public_exponent) {
+    const std::vector<uint8_t>& public_exponent) {
   DCHECK(algorithm_id == blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 ||
          algorithm_id == blink::WebCryptoAlgorithmIdRsaOaep);
   DCHECK(blink::WebCryptoAlgorithm::isHash(hash_id));
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       algorithm_id,
       new blink::WebCryptoRsaHashedKeyGenParams(
           CreateAlgorithm(hash_id),
           modulus_length,
           webcrypto::Uint8VectorStart(public_exponent),
           public_exponent.size()));
 }
 
 // Creates an RSA-OAEP algorithm
 blink::WebCryptoAlgorithm CreateRsaOaepAlgorithm(
-    const std::vector<uint8>& label) {
+    const std::vector<uint8_t>& label) {
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       blink::WebCryptoAlgorithmIdRsaOaep,
       new blink::WebCryptoRsaOaepParams(
           !label.empty(), Uint8VectorStart(label), label.size()));
 }
 
 // Creates an AES-CBC algorithm.
-blink::WebCryptoAlgorithm CreateAesCbcAlgorithm(const std::vector<uint8>& iv) {
+blink::WebCryptoAlgorithm CreateAesCbcAlgorithm(
+    const std::vector<uint8_t>& iv) {
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       blink::WebCryptoAlgorithmIdAesCbc,
       new blink::WebCryptoAesCbcParams(Uint8VectorStart(iv), iv.size()));
 }
 
 // Creates an AES-GCM algorithm.
 blink::WebCryptoAlgorithm CreateAesGcmAlgorithm(
-    const std::vector<uint8>& iv,
-    const std::vector<uint8>& additional_data,
+    const std::vector<uint8_t>& iv,
+    const std::vector<uint8_t>& additional_data,
     unsigned int tag_length_bits) {
   EXPECT_TRUE(SupportsAesGcm());
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       blink::WebCryptoAlgorithmIdAesGcm,
       new blink::WebCryptoAesGcmParams(Uint8VectorStart(iv),
                                        iv.size(),
                                        true,
                                        Uint8VectorStart(additional_data),
                                        additional_data.size(),
                                        true,
@@ skipping 11 matching lines @@
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       blink::WebCryptoAlgorithmIdHmac,
       new blink::WebCryptoHmacKeyGenParams(
           CreateAlgorithm(hash_id), (key_length_bits != 0), key_length_bits));
 }
 
 // Returns a slightly modified version of the input vector.
 //
 //  - For non-empty inputs a single bit is inverted.
 //  - For empty inputs, a byte is added.
-std::vector<uint8> Corrupted(const std::vector<uint8>& input) {
-  std::vector<uint8> corrupted_data(input);
+std::vector<uint8_t> Corrupted(const std::vector<uint8_t>& input) {
+  std::vector<uint8_t> corrupted_data(input);
   if (corrupted_data.empty())
     corrupted_data.push_back(0);
   corrupted_data[corrupted_data.size() / 2] ^= 0x01;
   return corrupted_data;
 }
 
-std::vector<uint8> HexStringToBytes(const std::string& hex) {
-  std::vector<uint8> bytes;
+std::vector<uint8_t> HexStringToBytes(const std::string& hex) {
+  std::vector<uint8_t> bytes;
   base::HexStringToBytes(hex, &bytes);
   return bytes;
 }
 
-std::vector<uint8> MakeJsonVector(const std::string& json_string) {
-  return std::vector<uint8>(json_string.begin(), json_string.end());
+std::vector<uint8_t> MakeJsonVector(const std::string& json_string) {
+  return std::vector<uint8_t>(json_string.begin(), json_string.end());
 }
 
-std::vector<uint8> MakeJsonVector(const base::DictionaryValue& dict) {
+std::vector<uint8_t> MakeJsonVector(const base::DictionaryValue& dict) {
   std::string json;
   base::JSONWriter::Write(&dict, &json);
   return MakeJsonVector(json);
 }
 
 // ----------------------------------------------------------------
 // Helpers for working with JSON data files for test expectations.
 // ----------------------------------------------------------------
 
 // Reads a file in "src/content/test/data/webcrypto" to a base::Value.
@@ skipping 46 matching lines @@
   ignore_result(json.release());
 
   return ::testing::AssertionSuccess();
 }
 
 // Read a string property from the dictionary with path |property_name|
 // (which can include periods for nested dictionaries). Interprets the
 // string as a hex encoded string and converts it to a bytes list.
 //
 // Returns empty vector on failure.
-std::vector<uint8> GetBytesFromHexString(base::DictionaryValue* dict,
-                                         const char* property_name) {
+std::vector<uint8_t> GetBytesFromHexString(base::DictionaryValue* dict,
+                                           const char* property_name) {
   std::string hex_string;
   if (!dict->GetString(property_name, &hex_string)) {
     EXPECT_TRUE(false) << "Couldn't get string property: " << property_name;
-    return std::vector<uint8>();
+    return std::vector<uint8_t>();
   }
 
   return HexStringToBytes(hex_string);
 }
 
 // Reads a string property with path "property_name" and converts it to a
 // WebCryptoAlgorith. Returns null algorithm on failure.
 blink::WebCryptoAlgorithm GetDigestAlgorithm(base::DictionaryValue* dict,
                                              const char* property_name) {
   std::string algorithm_name;
@@ skipping 43 matching lines @@
       "n",
       "qLOyhK-OtQs4cDSoYPFGxJGfMYdjzWxVmMiuSBGh4KvEx-CwgtaTpef87Wdc9GaFEncsDLxk"
       "p0LGxjD1M8jMcvYq6DPEC_JYQumEu3i9v5fAEH1VvbZi9cTg-rmEXLUUjvc5LdOq_5OuHmtm"
       "e7PUJHYW1PW6ENTP0ibeiNOfFvs");
   dict->SetString("e", "AQAB");
 }
 
 // Returns true if any of the vectors in the input list have identical content.
 // Dumb O(n^2) implementation but should be fast enough for the input sizes that
 // are used.
-bool CopiesExist(const std::vector<std::vector<uint8> >& bufs) {
+bool CopiesExist(const std::vector<std::vector<uint8_t> >& bufs) {
   for (size_t i = 0; i < bufs.size(); ++i) {
     for (size_t j = i + 1; j < bufs.size(); ++j) {
       if (CryptoData(bufs[i]) == CryptoData(bufs[j]))
         return true;
     }
   }
   return false;
 }
 
 blink::WebCryptoAlgorithm CreateAesKeyGenAlgorithm(
@@ skipping 63 matching lines @@
     "FFEDB162B4C0F283A12A88A394DFF526AB7291CBB307CEABFCE0B1DFD5CD9508096D5B2B"
     "8B6DF5D671EF6377C0921CB23C270A70E2598E6FF89D19F105ACC2D3F0CB35F29280E138"
     "6B6F64C4EF22E1E1F20D0CE8CFFB2249BD9A2137";
 const char* const kPublicKeyExponentHex = "010001";
 
 // TODO(eroman): Remove unnecessary test fixture.
 class SharedCryptoTest : public testing::Test {
 };
 
 blink::WebCryptoKey ImportSecretKeyFromRaw(
-    const std::vector<uint8>& key_raw,
+    const std::vector<uint8_t>& key_raw,
     const blink::WebCryptoAlgorithm& algorithm,
     blink::WebCryptoKeyUsageMask usage) {
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   bool extractable = true;
   EXPECT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(key_raw),
                       algorithm,
                       extractable,
                       usage,
                       &key));
 
   EXPECT_FALSE(key.isNull());
   EXPECT_TRUE(key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
   EXPECT_EQ(algorithm.id(), key.algorithm().id());
   EXPECT_EQ(extractable, key.extractable());
   EXPECT_EQ(usage, key.usages());
   return key;
 }
 
-void ImportRsaKeyPair(const std::vector<uint8>& spki_der,
-                      const std::vector<uint8>& pkcs8_der,
+void ImportRsaKeyPair(const std::vector<uint8_t>& spki_der,
+                      const std::vector<uint8_t>& pkcs8_der,
                       const blink::WebCryptoAlgorithm& algorithm,
                       bool extractable,
                       blink::WebCryptoKeyUsageMask public_key_usage_mask,
                       blink::WebCryptoKeyUsageMask private_key_usage_mask,
                       blink::WebCryptoKey* public_key,
                       blink::WebCryptoKey* private_key) {
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatSpki,
                       CryptoData(spki_der),
                       algorithm,
@@ skipping 16 matching lines @@
                       private_key));
   EXPECT_FALSE(private_key->isNull());
   EXPECT_TRUE(private_key->handle());
   EXPECT_EQ(blink::WebCryptoKeyTypePrivate, private_key->type());
   EXPECT_EQ(algorithm.id(), private_key->algorithm().id());
   EXPECT_EQ(extractable, private_key->extractable());
   EXPECT_EQ(private_key_usage_mask, private_key->usages());
 }
 
 Status AesGcmEncrypt(const blink::WebCryptoKey& key,
-                     const std::vector<uint8>& iv,
-                     const std::vector<uint8>& additional_data,
+                     const std::vector<uint8_t>& iv,
+                     const std::vector<uint8_t>& additional_data,
                      unsigned int tag_length_bits,
-                     const std::vector<uint8>& plain_text,
-                     std::vector<uint8>* cipher_text,
-                     std::vector<uint8>* authentication_tag) {
+                     const std::vector<uint8_t>& plain_text,
+                     std::vector<uint8_t>* cipher_text,
+                     std::vector<uint8_t>* authentication_tag) {
   EXPECT_TRUE(SupportsAesGcm());
   blink::WebCryptoAlgorithm algorithm =
       CreateAesGcmAlgorithm(iv, additional_data, tag_length_bits);
 
-  std::vector<uint8> output;
+  std::vector<uint8_t> output;
   Status status = Encrypt(algorithm, key, CryptoData(plain_text), &output);
   if (status.IsError())
     return status;
 
   if ((tag_length_bits % 8) != 0) {
     EXPECT_TRUE(false) << "Encrypt should have failed.";
     return Status::OperationError();
   }
 
   size_t tag_length_bytes = tag_length_bits / 8;
 
   if (tag_length_bytes > output.size()) {
     EXPECT_TRUE(false) << "tag length is larger than output";
     return Status::OperationError();
   }
 
   // The encryption result is cipher text with authentication tag appended.
   cipher_text->assign(output.begin(),
                       output.begin() + (output.size() - tag_length_bytes));
   authentication_tag->assign(output.begin() + cipher_text->size(),
                              output.end());
 
   return Status::Success();
 }
 
 Status AesGcmDecrypt(const blink::WebCryptoKey& key,
-                     const std::vector<uint8>& iv,
-                     const std::vector<uint8>& additional_data,
+                     const std::vector<uint8_t>& iv,
+                     const std::vector<uint8_t>& additional_data,
                      unsigned int tag_length_bits,
-                     const std::vector<uint8>& cipher_text,
-                     const std::vector<uint8>& authentication_tag,
-                     std::vector<uint8>* plain_text) {
+                     const std::vector<uint8_t>& cipher_text,
+                     const std::vector<uint8_t>& authentication_tag,
+                     std::vector<uint8_t>* plain_text) {
   EXPECT_TRUE(SupportsAesGcm());
   blink::WebCryptoAlgorithm algorithm =
       CreateAesGcmAlgorithm(iv, additional_data, tag_length_bits);
 
   // Join cipher text and authentication tag.
-  std::vector<uint8> cipher_text_with_tag;
+  std::vector<uint8_t> cipher_text_with_tag;
   cipher_text_with_tag.reserve(cipher_text.size() + authentication_tag.size());
   cipher_text_with_tag.insert(
       cipher_text_with_tag.end(), cipher_text.begin(), cipher_text.end());
   cipher_text_with_tag.insert(cipher_text_with_tag.end(),
                               authentication_tag.begin(),
                               authentication_tag.end());
 
   return Decrypt(algorithm, key, CryptoData(cipher_text_with_tag), plain_text);
 }
 
@@ skipping 17 matching lines @@
                             blink::WebCryptoKey* key) {
   return ImportKeyJwk(CryptoData(MakeJsonVector(dict)),
                       algorithm,
                       extractable,
                       usage_mask,
                       key);
 }
 
 // Parses a vector of JSON into a dictionary.
 scoped_ptr<base::DictionaryValue> GetJwkDictionary(
-    const std::vector<uint8>& json) {
+    const std::vector<uint8_t>& json) {
   base::StringPiece json_string(
       reinterpret_cast<const char*>(Uint8VectorStart(json)), json.size());
   base::Value* value = base::JSONReader::Read(json_string);
   EXPECT_TRUE(value);
   base::DictionaryValue* dict_value = NULL;
   value->GetAsDictionary(&dict_value);
   return scoped_ptr<base::DictionaryValue>(dict_value);
 }
 
 // Verifies the input dictionary contains the expected values. Exact matches are
@@ skipping 41 matching lines @@
     return ::testing::AssertionFailure()
            << "Expected 'key_ops' mask to be " << use_mask_expected
            << " but found " << key_ops_mask << " (" << value_string << ")";
 
   return ::testing::AssertionSuccess();
 }
 
 // Verifies that the JSON in the input vector contains the provided
 // expected values. Exact matches are required on the fields examined.
 ::testing::AssertionResult VerifySecretJwk(
-    const std::vector<uint8>& json,
+    const std::vector<uint8_t>& json,
     const std::string& alg_expected,
     const std::string& k_expected_hex,
     blink::WebCryptoKeyUsageMask use_mask_expected) {
   scoped_ptr<base::DictionaryValue> dict = GetJwkDictionary(json);
   if (!dict.get() || dict->empty())
     return ::testing::AssertionFailure() << "JSON parsing failed";
 
   // ---- k
   std::string value_string;
   if (!dict->GetString("k", &value_string))
     return ::testing::AssertionFailure() << "Missing 'k'";
   std::string k_value;
   if (!webcrypto::Base64DecodeUrlSafe(value_string, &k_value))
     return ::testing::AssertionFailure() << "Base64DecodeUrlSafe(k) failed";
   if (!LowerCaseEqualsASCII(base::HexEncode(k_value.data(), k_value.size()),
                             k_expected_hex.c_str())) {
     return ::testing::AssertionFailure() << "Expected 'k' to be "
                                          << k_expected_hex
                                          << " but found something different";
   }
 
   return VerifyJwk(dict, "oct", alg_expected, use_mask_expected);
 }
 
 // Verifies that the JSON in the input vector contains the provided
 // expected values. Exact matches are required on the fields examined.
 ::testing::AssertionResult VerifyPublicJwk(
-    const std::vector<uint8>& json,
+    const std::vector<uint8_t>& json,
     const std::string& alg_expected,
     const std::string& n_expected_hex,
     const std::string& e_expected_hex,
     blink::WebCryptoKeyUsageMask use_mask_expected) {
   scoped_ptr<base::DictionaryValue> dict = GetJwkDictionary(json);
   if (!dict.get() || dict->empty())
     return ::testing::AssertionFailure() << "JSON parsing failed";
 
   // ---- n
   std::string value_string;
@@ skipping 91 matching lines @@
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("digest.json", &tests));
 
   for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
     SCOPED_TRACE(test_index);
     base::DictionaryValue* test;
     ASSERT_TRUE(tests->GetDictionary(test_index, &test));
 
     blink::WebCryptoAlgorithm test_algorithm =
         GetDigestAlgorithm(test, "algorithm");
-    std::vector<uint8> test_input = GetBytesFromHexString(test, "input");
-    std::vector<uint8> test_output = GetBytesFromHexString(test, "output");
+    std::vector<uint8_t> test_input = GetBytesFromHexString(test, "input");
+    std::vector<uint8_t> test_output = GetBytesFromHexString(test, "output");
 
-    std::vector<uint8> output;
+    std::vector<uint8_t> output;
     ASSERT_EQ(Status::Success(),
               Digest(test_algorithm, CryptoData(test_input), &output));
     EXPECT_BYTES_EQ(test_output, output);
   }
 }
 
 TEST_F(SharedCryptoTest, DigestSampleSetsInChunks) {
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("digest.json", &tests));
 
   for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
     SCOPED_TRACE(test_index);
     base::DictionaryValue* test;
     ASSERT_TRUE(tests->GetDictionary(test_index, &test));
 
     blink::WebCryptoAlgorithm test_algorithm =
         GetDigestAlgorithm(test, "algorithm");
-    std::vector<uint8> test_input = GetBytesFromHexString(test, "input");
-    std::vector<uint8> test_output = GetBytesFromHexString(test, "output");
+    std::vector<uint8_t> test_input = GetBytesFromHexString(test, "input");
+    std::vector<uint8_t> test_output = GetBytesFromHexString(test, "output");
 
     // Test the chunk version of the digest functions. Test with 129 byte chunks
     // because the SHA-512 chunk size is 128 bytes.
     unsigned char* output;
     unsigned int output_length;
     static const size_t kChunkSizeBytes = 129;
     size_t length = test_input.size();
     scoped_ptr<blink::WebCryptoDigestor> digestor(
         CreateDigestor(test_algorithm.id()));
-    std::vector<uint8>::iterator begin = test_input.begin();
+    std::vector<uint8_t>::iterator begin = test_input.begin();
     size_t chunk_index = 0;
     while (begin != test_input.end()) {
       size_t chunk_length = std::min(kChunkSizeBytes, length - chunk_index);
-      std::vector<uint8> chunk(begin, begin + chunk_length);
+      std::vector<uint8_t> chunk(begin, begin + chunk_length);
       ASSERT_TRUE(chunk.size() > 0);
       EXPECT_TRUE(digestor->consume(&chunk.front(), chunk.size()));
       chunk_index = chunk_index + chunk_length;
       begin = begin + chunk_length;
     }
     EXPECT_TRUE(digestor->finish(output, output_length));
     EXPECT_BYTES_EQ(test_output, CryptoData(output, output_length));
   }
 }
 
 TEST_F(SharedCryptoTest, HMACSampleSets) {
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("hmac.json", &tests));
   // TODO(padolph): Missing known answer tests for HMAC SHA384, and SHA512.
   for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
     SCOPED_TRACE(test_index);
     base::DictionaryValue* test;
     ASSERT_TRUE(tests->GetDictionary(test_index, &test));
 
     blink::WebCryptoAlgorithm test_hash = GetDigestAlgorithm(test, "hash");
-    const std::vector<uint8> test_key = GetBytesFromHexString(test, "key");
-    const std::vector<uint8> test_message =
+    const std::vector<uint8_t> test_key = GetBytesFromHexString(test, "key");
+    const std::vector<uint8_t> test_message =
         GetBytesFromHexString(test, "message");
-    const std::vector<uint8> test_mac = GetBytesFromHexString(test, "mac");
+    const std::vector<uint8_t> test_mac = GetBytesFromHexString(test, "mac");
 
     blink::WebCryptoAlgorithm algorithm =
         CreateAlgorithm(blink::WebCryptoAlgorithmIdHmac);
 
     blink::WebCryptoAlgorithm import_algorithm =
         CreateHmacImportAlgorithm(test_hash.id());
 
     blink::WebCryptoKey key = ImportSecretKeyFromRaw(
         test_key,
         import_algorithm,
         blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify);
 
     EXPECT_EQ(test_hash.id(), key.algorithm().hmacParams()->hash().id());
     EXPECT_EQ(test_key.size() * 8, key.algorithm().hmacParams()->lengthBits());
 
     // Verify exported raw key is identical to the imported data
-    std::vector<uint8> raw_key;
+    std::vector<uint8_t> raw_key;
     EXPECT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
     EXPECT_BYTES_EQ(test_key, raw_key);
 
-    std::vector<uint8> output;
+    std::vector<uint8_t> output;
 
     ASSERT_EQ(Status::Success(),
               Sign(algorithm, key, CryptoData(test_message), &output));
 
     EXPECT_BYTES_EQ(test_mac, output);
 
     bool signature_match = false;
     EXPECT_EQ(Status::Success(),
               Verify(algorithm,
                      key,
@@ skipping 33 matching lines @@
 }
 
 TEST_F(SharedCryptoTest, AesCbcFailures) {
   const std::string key_hex = "2b7e151628aed2a6abf7158809cf4f3c";
   blink::WebCryptoKey key = ImportSecretKeyFromRaw(
       HexStringToBytes(key_hex),
       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt);
 
   // Verify exported raw key is identical to the imported data
-  std::vector<uint8> raw_key;
+  std::vector<uint8_t> raw_key;
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
   EXPECT_BYTES_EQ_HEX(key_hex, raw_key);
 
-  std::vector<uint8> output;
+  std::vector<uint8_t> output;
 
   // Use an invalid |iv| (fewer than 16 bytes)
   {
-    std::vector<uint8> input(32);
-    std::vector<uint8> iv;
+    std::vector<uint8_t> input(32);
+    std::vector<uint8_t> iv;
     EXPECT_EQ(Status::ErrorIncorrectSizeAesCbcIv(),
               Encrypt(webcrypto::CreateAesCbcAlgorithm(iv),
                       key,
                       CryptoData(input),
                       &output));
     EXPECT_EQ(Status::ErrorIncorrectSizeAesCbcIv(),
               Decrypt(webcrypto::CreateAesCbcAlgorithm(iv),
                       key,
                       CryptoData(input),
                       &output));
   }
 
   // Use an invalid |iv| (more than 16 bytes)
   {
-    std::vector<uint8> input(32);
-    std::vector<uint8> iv(17);
+    std::vector<uint8_t> input(32);
+    std::vector<uint8_t> iv(17);
     EXPECT_EQ(Status::ErrorIncorrectSizeAesCbcIv(),
               Encrypt(webcrypto::CreateAesCbcAlgorithm(iv),
                       key,
                       CryptoData(input),
                       &output));
     EXPECT_EQ(Status::ErrorIncorrectSizeAesCbcIv(),
               Decrypt(webcrypto::CreateAesCbcAlgorithm(iv),
                       key,
                       CryptoData(input),
                       &output));
   }
 
   // Give an input that is too large (would cause integer overflow when
   // narrowing to an int).
   {
-    std::vector<uint8> iv(16);
+    std::vector<uint8_t> iv(16);
 
     // Pretend the input is large. Don't pass data pointer as NULL in case that
     // is special cased; the implementation shouldn't actually dereference the
     // data.
     CryptoData input(&iv[0], INT_MAX - 3);
 
     EXPECT_EQ(Status::ErrorDataTooLarge(),
               Encrypt(CreateAesCbcAlgorithm(iv), key, input, &output));
     EXPECT_EQ(Status::ErrorDataTooLarge(),
               Decrypt(CreateAesCbcAlgorithm(iv), key, input, &output));
   }
 
   // Fail importing the key (too few bytes specified)
   {
-    std::vector<uint8> key_raw(1);
-    std::vector<uint8> iv(16);
+    std::vector<uint8_t> key_raw(1);
+    std::vector<uint8_t> iv(16);
 
     blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
     EXPECT_EQ(Status::ErrorImportAesKeyLength(),
               ImportKey(blink::WebCryptoKeyFormatRaw,
                         CryptoData(key_raw),
                         CreateAesCbcAlgorithm(iv),
                         true,
                         blink::WebCryptoKeyUsageEncrypt,
                         &key));
   }
@@ skipping 19 matching lines @@
 
 TEST_F(SharedCryptoTest, MAYBE(AesCbcSampleSets)) {
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("aes_cbc.json", &tests));
 
   for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
     SCOPED_TRACE(test_index);
     base::DictionaryValue* test;
     ASSERT_TRUE(tests->GetDictionary(test_index, &test));
 
-    std::vector<uint8> test_key = GetBytesFromHexString(test, "key");
-    std::vector<uint8> test_iv = GetBytesFromHexString(test, "iv");
-    std::vector<uint8> test_plain_text =
+    std::vector<uint8_t> test_key = GetBytesFromHexString(test, "key");
+    std::vector<uint8_t> test_iv = GetBytesFromHexString(test, "iv");
+    std::vector<uint8_t> test_plain_text =
         GetBytesFromHexString(test, "plain_text");
-    std::vector<uint8> test_cipher_text =
+    std::vector<uint8_t> test_cipher_text =
         GetBytesFromHexString(test, "cipher_text");
 
     blink::WebCryptoKey key = ImportSecretKeyFromRaw(
         test_key,
         CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
         blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt);
 
     EXPECT_EQ(test_key.size() * 8, key.algorithm().aesParams()->lengthBits());
 
     // Verify exported raw key is identical to the imported data
-    std::vector<uint8> raw_key;
+    std::vector<uint8_t> raw_key;
     EXPECT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
     EXPECT_BYTES_EQ(test_key, raw_key);
 
-    std::vector<uint8> output;
+    std::vector<uint8_t> output;
 
     // Test encryption.
     EXPECT_EQ(Status::Success(),
               Encrypt(webcrypto::CreateAesCbcAlgorithm(test_iv),
                       key,
                       CryptoData(test_plain_text),
                       &output));
     EXPECT_BYTES_EQ(test_cipher_text, output);
 
     // Test decryption.
@@ skipping 35 matching lines @@
   // allowed key length.
   std::vector<blink::WebCryptoAlgorithm> algorithm;
   const unsigned short kKeyLength[] = {128, 256};
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kKeyLength); ++i) {
     algorithm.push_back(CreateAesCbcKeyGenAlgorithm(kKeyLength[i]));
     algorithm.push_back(CreateAesKwKeyGenAlgorithm(kKeyLength[i]));
     if (SupportsAesGcm())
       algorithm.push_back(CreateAesGcmKeyGenAlgorithm(kKeyLength[i]));
   }
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
-  std::vector<std::vector<uint8> > keys;
-  std::vector<uint8> key_bytes;
+  std::vector<std::vector<uint8_t> > keys;
+  std::vector<uint8_t> key_bytes;
   for (size_t i = 0; i < algorithm.size(); ++i) {
     SCOPED_TRACE(i);
     // Generate a small sample of keys.
     keys.clear();
     for (int j = 0; j < 16; ++j) {
       ASSERT_EQ(Status::Success(),
                 GenerateSecretKey(algorithm[i], true, 0, &key));
       EXPECT_TRUE(key.handle());
       EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
       ASSERT_EQ(Status::Success(),
@@ skipping 22 matching lines @@
     if (SupportsAesGcm()) {
       EXPECT_EQ(Status::ErrorGenerateKeyLength(),
                 GenerateSecretKey(
                     CreateAesGcmKeyGenAlgorithm(kKeyLen[i]), true, 0, &key));
     }
   }
 }
 
 TEST_F(SharedCryptoTest, MAYBE(GenerateKeyHmac)) {
   // Generate a small sample of HMAC keys.
-  std::vector<std::vector<uint8> > keys;
+  std::vector<std::vector<uint8_t> > keys;
   for (int i = 0; i < 16; ++i) {
-    std::vector<uint8> key_bytes;
+    std::vector<uint8_t> key_bytes;
     blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
     blink::WebCryptoAlgorithm algorithm =
         CreateHmacKeyGenAlgorithm(blink::WebCryptoAlgorithmIdSha1, 512);
     ASSERT_EQ(Status::Success(), GenerateSecretKey(algorithm, true, 0, &key));
     EXPECT_FALSE(key.isNull());
     EXPECT_TRUE(key.handle());
     EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
     EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
     EXPECT_EQ(blink::WebCryptoAlgorithmIdSha1,
               key.algorithm().hmacParams()->hash().id());
     EXPECT_EQ(512u, key.algorithm().hmacParams()->lengthBits());
 
-    std::vector<uint8> raw_key;
+    std::vector<uint8_t> raw_key;
     ASSERT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
     EXPECT_EQ(64U, raw_key.size());
     keys.push_back(raw_key);
   }
   // Ensure all entries in the key sample set are unique. This is a simplistic
   // estimate of whether the generated keys appear random.
   EXPECT_FALSE(CopiesExist(keys));
 }
 
 // If the key length is not provided, then the block size is used.
 TEST_F(SharedCryptoTest, MAYBE(GenerateKeyHmacNoLength)) {
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   blink::WebCryptoAlgorithm algorithm =
       CreateHmacKeyGenAlgorithm(blink::WebCryptoAlgorithmIdSha1, 0);
   ASSERT_EQ(Status::Success(), GenerateSecretKey(algorithm, true, 0, &key));
   EXPECT_TRUE(key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha1,
             key.algorithm().hmacParams()->hash().id());
   EXPECT_EQ(512u, key.algorithm().hmacParams()->lengthBits());
-  std::vector<uint8> raw_key;
+  std::vector<uint8_t> raw_key;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
   EXPECT_EQ(64U, raw_key.size());
 
   // The block size for HMAC SHA-512 is larger.
   algorithm = CreateHmacKeyGenAlgorithm(blink::WebCryptoAlgorithmIdSha512, 0);
   ASSERT_EQ(Status::Success(), GenerateSecretKey(algorithm, true, 0, &key));
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha512,
             key.algorithm().hmacParams()->hash().id());
@@ skipping 155 matching lines @@
   EXPECT_EQ(Status::Success(),
             ImportKeyJwkFromDict(dict, algorithm, false, usage_mask, &key));
 
   // Fail on empty JSON.
   EXPECT_EQ(
       Status::ErrorImportEmptyKeyData(),
       ImportKeyJwk(
           CryptoData(MakeJsonVector("")), algorithm, false, usage_mask, &key));
 
   // Fail on invalid JSON.
-  const std::vector<uint8> bad_json_vec = MakeJsonVector(
+  const std::vector<uint8_t> bad_json_vec = MakeJsonVector(
       "{"
       "\"kty\"         : \"oct\","
       "\"alg\"         : \"HS256\","
       "\"use\"         : ");
   EXPECT_EQ(Status::ErrorJwkNotDictionary(),
             ImportKeyJwk(
                 CryptoData(bad_json_vec), algorithm, false, usage_mask, &key));
 
   // Fail on JWK alg present but incorrect (expecting A128CBC).
   dict.SetString("alg", "A127CBC");
@@ skipping 209 matching lines @@
     blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
     ASSERT_EQ(Status::Success(),
               ImportKey(blink::WebCryptoKeyFormatSpki,
                         CryptoData(HexStringToBytes(kPublicKeySpkiDerHex)),
                         test.algorithm,
                         true,
                         test.usage,
                         &public_key));
 
     // Export the public key as JWK and verify its contents
-    std::vector<uint8> jwk;
+    std::vector<uint8_t> jwk;
     ASSERT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatJwk, public_key, &jwk));
     EXPECT_TRUE(VerifyPublicJwk(jwk,
                                 test.jwk_alg,
                                 kPublicKeyModulusHex,
                                 kPublicKeyExponentHex,
                                 test.usage));
 
     // Import the JWK back in to create a new key
     blink::WebCryptoKey public_key2 = blink::WebCryptoKey::createNull();
     ASSERT_EQ(
         Status::Success(),
         ImportKeyJwk(
             CryptoData(jwk), test.algorithm, true, test.usage, &public_key2));
     ASSERT_TRUE(public_key2.handle());
     EXPECT_EQ(blink::WebCryptoKeyTypePublic, public_key2.type());
     EXPECT_TRUE(public_key2.extractable());
     EXPECT_EQ(test.algorithm.id(), public_key2.algorithm().id());
 
     // Only perform SPKI consistency test for RSA-SSA as its
     // export format is the same as kPublicKeySpkiDerHex
     if (test.algorithm.id() == blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5) {
       // Export the new key as spki and compare to the original.
-      std::vector<uint8> spki;
+      std::vector<uint8_t> spki;
       ASSERT_EQ(Status::Success(),
                 ExportKey(blink::WebCryptoKeyFormatSpki, public_key2, &spki));
       EXPECT_BYTES_EQ_HEX(kPublicKeySpkiDerHex, CryptoData(spki));
     }
   }
 }
 
 TEST_F(SharedCryptoTest, MAYBE(ImportJwkRsaFailures)) {
   base::DictionaryValue dict;
   RestoreJwkRsaDictionary(&dict);
@@ skipping 48 matching lines @@
 
   // Consistency rules when JWK value is not present: Inputs should be used.
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   bool extractable = false;
   blink::WebCryptoAlgorithm algorithm =
       CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha256);
   blink::WebCryptoKeyUsageMask usage_mask = blink::WebCryptoKeyUsageVerify;
   base::DictionaryValue dict;
   dict.SetString("kty", "oct");
   dict.SetString("k", "l3nZEgZCeX8XRwJdWyK3rGB8qwjhdY8vOkbIvh4lxTuMao9Y_--hdg");
-  std::vector<uint8> json_vec = MakeJsonVector(dict);
+  std::vector<uint8_t> json_vec = MakeJsonVector(dict);
   EXPECT_EQ(
       Status::Success(),
       ImportKeyJwk(
           CryptoData(json_vec), algorithm, extractable, usage_mask, &key));
   EXPECT_TRUE(key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
   EXPECT_EQ(extractable, key.extractable());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha256,
             key.algorithm().hmacParams()->hash().id());
@@ skipping 126 matching lines @@
   dict.SetBoolean("ext", false);
   dict.SetString("k", "l3nZEgZCeX8XRwJdWyK3rGB8qwjhdY8vOkbIvh4lxTuMao9Y_--hdg");
 
   ASSERT_EQ(
       Status::Success(),
       ImportKeyJwkFromDict(dict, algorithm, extractable, usage_mask, &key));
 
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha256,
             key.algorithm().hmacParams()->hash().id());
 
-  const std::vector<uint8> message_raw = HexStringToBytes(
+  const std::vector<uint8_t> message_raw = HexStringToBytes(
       "b1689c2591eaf3c9e66070f8a77954ffb81749f1b00346f9dfe0b2ee905dcc288baf4a"
       "92de3f4001dd9f44c468c3d07d6c6ee82faceafc97c2fc0fc0601719d2dcd0aa2aec92"
       "d1b0ae933c65eb06a03c9c935c2bad0459810241347ab87e9f11adb30415424c6c7f5f"
       "22a003b8ab8de54f6ded0e3ab9245fa79568451dfa258e");
 
-  std::vector<uint8> output;
+  std::vector<uint8_t> output;
 
   ASSERT_EQ(Status::Success(),
             Sign(CreateAlgorithm(blink::WebCryptoAlgorithmIdHmac),
                  key,
                  CryptoData(message_raw),
                  &output));
 
   const std::string mac_raw =
       "769f00d3e6a6cc1fb426a14a4f76c6462e6149726e0dee0ec0cf97a16605ac8b";
 
@@ skipping 70 matching lines @@
        blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt |
            blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey,
        "A256CBC"},
       // Zero usage value
       {key_hex_512, hmac_sha_512_alg, 0, "HS512"},
   };
 
   // Round-trip import/export each key.
 
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
-  std::vector<uint8> json;
+  std::vector<uint8_t> json;
   for (size_t test_index = 0; test_index < ARRAYSIZE_UNSAFE(kTests);
        ++test_index) {
     SCOPED_TRACE(test_index);
     const TestCase& test = kTests[test_index];
 
     // Skip AES-GCM tests where not supported.
     if (test.algorithm.id() == blink::WebCryptoAlgorithmIdAesGcm &&
         !SupportsAesGcm()) {
       continue;
     }
@@ skipping 11 matching lines @@
     ASSERT_EQ(
         Status::Success(),
         ImportKeyJwk(CryptoData(json), test.algorithm, true, test.usage, &key));
     EXPECT_TRUE(key.handle());
     EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
     EXPECT_EQ(test.algorithm.id(), key.algorithm().id());
     EXPECT_EQ(true, key.extractable());
     EXPECT_EQ(test.usage, key.usages());
 
     // Export the key in raw format and compare to the original.
-    std::vector<uint8> key_raw_out;
+    std::vector<uint8_t> key_raw_out;
     ASSERT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatRaw, key, &key_raw_out));
     EXPECT_BYTES_EQ_HEX(test.key_hex, key_raw_out);
   }
 }
 
 TEST_F(SharedCryptoTest, MAYBE(ExportJwkEmptySymmetricKey)) {
   const blink::WebCryptoAlgorithm import_algorithm =
       webcrypto::CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha1);
 
   blink::WebCryptoKeyUsageMask usages = blink::WebCryptoKeyUsageSign;
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
 
   // Import a zero-byte HMAC key.
   const char key_data_hex[] = "";
   key = ImportSecretKeyFromRaw(
       HexStringToBytes(key_data_hex), import_algorithm, usages);
   EXPECT_EQ(0u, key.algorithm().hmacParams()->lengthBits());
 
   // Export the key in JWK format and validate.
-  std::vector<uint8> json;
+  std::vector<uint8_t> json;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatJwk, key, &json));
   EXPECT_TRUE(VerifySecretJwk(json, "HS1", key_data_hex, usages));
 
   // Now try re-importing the JWK key.
   key = blink::WebCryptoKey::createNull();
   EXPECT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatJwk,
                       CryptoData(json),
                       import_algorithm,
                       true,
                       usages,
                       &key));
 
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
   EXPECT_EQ(0u, key.algorithm().hmacParams()->lengthBits());
 
-  std::vector<uint8> exported_key_data;
+  std::vector<uint8_t> exported_key_data;
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &exported_key_data));
 
   EXPECT_EQ(0u, exported_key_data.size());
 }
 
 TEST_F(SharedCryptoTest, MAYBE(ImportExportSpki)) {
   if (!SupportsRsaKeyImport())
     return;
 
@@ skipping 15 matching lines @@
   EXPECT_EQ(kModulusLengthBits,
             key.algorithm().rsaHashedParams()->modulusLengthBits());
   EXPECT_BYTES_EQ_HEX(
       "010001",
       CryptoData(key.algorithm().rsaHashedParams()->publicExponent()));
 
   // Failing case: Empty SPKI data
   EXPECT_EQ(
       Status::ErrorImportEmptyKeyData(),
       ImportKey(blink::WebCryptoKeyFormatSpki,
-                CryptoData(std::vector<uint8>()),
+                CryptoData(std::vector<uint8_t>()),
                 CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5),
                 true,
                 blink::WebCryptoKeyUsageVerify,
                 &key));
 
   // Failing case: Bad DER encoding.
   EXPECT_EQ(
       Status::DataError(),
       ImportKey(blink::WebCryptoKeyFormatSpki,
                 CryptoData(HexStringToBytes("618333c4cb")),
                 CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5),
                 true,
                 blink::WebCryptoKeyUsageVerify,
                 &key));
 
   // Failing case: Import RSA key but provide an inconsistent input algorithm.
   EXPECT_EQ(Status::ErrorUnsupportedImportKeyFormat(),
             ImportKey(blink::WebCryptoKeyFormatSpki,
                       CryptoData(HexStringToBytes(kPublicKeySpkiDerHex)),
                       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &key));
 
   // Passing case: Export a previously imported RSA public key in SPKI format
   // and compare to original data.
-  std::vector<uint8> output;
+  std::vector<uint8_t> output;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatSpki, key, &output));
   EXPECT_BYTES_EQ_HEX(kPublicKeySpkiDerHex, output);
 
   // Failing case: Try to export a previously imported RSA public key in raw
   // format (not allowed for a public key).
   EXPECT_EQ(Status::ErrorUnsupportedExportKeyFormat(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &output));
 
   // Failing case: Try to export a non-extractable key
@@ skipping 39 matching lines @@
   EXPECT_TRUE(key.extractable());
   EXPECT_EQ(blink::WebCryptoKeyUsageSign, key.usages());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha1,
             key.algorithm().rsaHashedParams()->hash().id());
   EXPECT_EQ(kModulusLengthBits,
             key.algorithm().rsaHashedParams()->modulusLengthBits());
   EXPECT_BYTES_EQ_HEX(
       "010001",
       CryptoData(key.algorithm().rsaHashedParams()->publicExponent()));
 
-  std::vector<uint8> exported_key;
+  std::vector<uint8_t> exported_key;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatPkcs8, key, &exported_key));
   EXPECT_BYTES_EQ_HEX(kPrivateKeyPkcs8DerHex, exported_key);
 
   // Failing case: Empty PKCS#8 data
   EXPECT_EQ(Status::ErrorImportEmptyKeyData(),
             ImportKey(blink::WebCryptoKeyFormatPkcs8,
-                      CryptoData(std::vector<uint8>()),
+                      CryptoData(std::vector<uint8_t>()),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                           blink::WebCryptoAlgorithmIdSha1),
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &key));
 
   // Failing case: Bad DER encoding.
   EXPECT_EQ(
       Status::DataError(),
@@ skipping 29 matching lines @@
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatPkcs8,
                       CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                           blink::WebCryptoAlgorithmIdSha1),
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &key));
 
-  std::vector<uint8> exported_key_jwk;
+  std::vector<uint8_t> exported_key_jwk;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatJwk, key, &exported_key_jwk));
 
   // All of the optional parameters (p, q, dp, dq, qi) should be present in the
   // output.
   const char* expected_jwk =
       "{\"alg\":\"RS1\",\"d\":\"M6UEKpCyfU9UUcqbu9C0R3GhAa-IQ0Cu-YhfKku-"
       "kuiUpySsPFaMj5eFOtB8AmbIxqPKCSnx6PESMYhEKfxNmuVf7olqEM5wfD7X5zTkRyejlXRQ"
       "GlMmgxCcKrrKuig8MbS9L1PD7jfjUs7jT55QO9gMBiKtecbc7og1R8ajsyU\",\"dp\":"
       "\"KPoTk4ZVvh-"
@@ skipping 16 matching lines @@
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatJwk,
                       CryptoData(exported_key_jwk),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                           blink::WebCryptoAlgorithmIdSha1),
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &key));
 
-  std::vector<uint8> exported_key_pkcs8;
+  std::vector<uint8_t> exported_key_pkcs8;
   ASSERT_EQ(
       Status::Success(),
       ExportKey(blink::WebCryptoKeyFormatPkcs8, key, &exported_key_pkcs8));
 
   ASSERT_EQ(CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
             CryptoData(exported_key_pkcs8));
 }
 
 // Tests importing multiple RSA private keys from JWK, and then exporting to
 // PKCS8.
@@ skipping 19 matching lines @@
     base::DictionaryValue* key_values;
     ASSERT_TRUE(key_list->GetDictionary(key_index, &key_values));
 
     // Get the JWK representation of the key.
     base::DictionaryValue* key_jwk;
     ASSERT_TRUE(key_values->GetDictionary("jwk", &key_jwk));
 
     // Get the PKCS8 representation of the key.
     std::string pkcs8_hex_string;
     ASSERT_TRUE(key_values->GetString("pkcs8", &pkcs8_hex_string));
-    std::vector<uint8> pkcs8_bytes = HexStringToBytes(pkcs8_hex_string);
+    std::vector<uint8_t> pkcs8_bytes = HexStringToBytes(pkcs8_hex_string);
 
     // Get the modulus length for the key.
     int modulus_length_bits = 0;
     ASSERT_TRUE(key_values->GetInteger("modulusLength", &modulus_length_bits));
 
     blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
 
     // Import the key from JWK.
     ASSERT_EQ(
         Status::Success(),
         ImportKeyJwkFromDict(*key_jwk,
                              CreateRsaHashedImportAlgorithm(
                                  blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                  blink::WebCryptoAlgorithmIdSha256),
                              true,
                              blink::WebCryptoKeyUsageSign,
                              &private_key));
 
     live_keys.push_back(private_key);
 
     EXPECT_EQ(
         modulus_length_bits,
         static_cast<int>(
             private_key.algorithm().rsaHashedParams()->modulusLengthBits()));
 
     // Export to PKCS8 and verify that it matches expectation.
-    std::vector<uint8> exported_key_pkcs8;
+    std::vector<uint8_t> exported_key_pkcs8;
     ASSERT_EQ(
         Status::Success(),
         ExportKey(
             blink::WebCryptoKeyFormatPkcs8, private_key, &exported_key_pkcs8));
 
     EXPECT_BYTES_EQ(pkcs8_bytes, exported_key_pkcs8);
   }
 }
 
 // Import an RSA private key using JWK. Next import a JWK containing the same
@@ skipping 134 matching lines @@
                                  blink::WebCryptoKeyUsageSign,
                                  &key));
 
 }
 
 TEST_F(SharedCryptoTest, MAYBE(GenerateKeyPairRsa)) {
   // Note: using unrealistic short key lengths here to avoid bogging down tests.
 
   // Successful WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 key generation (sha256)
   const unsigned int modulus_length = 256;
-  const std::vector<uint8> public_exponent = HexStringToBytes("010001");
+  const std::vector<uint8_t> public_exponent = HexStringToBytes("010001");
   blink::WebCryptoAlgorithm algorithm =
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256,
                                      modulus_length,
                                      public_exponent);
   bool extractable = true;
   const blink::WebCryptoKeyUsageMask usage_mask = 0;
   blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
   blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
 
@@ skipping 12 matching lines @@
             public_key.algorithm().rsaHashedParams()->hash().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha256,
             private_key.algorithm().rsaHashedParams()->hash().id());
   EXPECT_TRUE(public_key.extractable());
   EXPECT_EQ(extractable, private_key.extractable());
   EXPECT_EQ(usage_mask, public_key.usages());
   EXPECT_EQ(usage_mask, private_key.usages());
 
   // Try exporting the generated key pair, and then re-importing to verify that
   // the exported data was valid.
-  std::vector<uint8> public_key_spki;
+  std::vector<uint8_t> public_key_spki;
   EXPECT_EQ(
       Status::Success(),
       ExportKey(blink::WebCryptoKeyFormatSpki, public_key, &public_key_spki));
 
   if (SupportsRsaKeyImport()) {
     public_key = blink::WebCryptoKey::createNull();
     EXPECT_EQ(Status::Success(),
               ImportKey(blink::WebCryptoKeyFormatSpki,
                         CryptoData(public_key_spki),
                         CreateRsaHashedImportAlgorithm(
                             blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                             blink::WebCryptoAlgorithmIdSha256),
                         true,
                         usage_mask,
                         &public_key));
     EXPECT_EQ(modulus_length,
               public_key.algorithm().rsaHashedParams()->modulusLengthBits());
 
-    std::vector<uint8> private_key_pkcs8;
+    std::vector<uint8_t> private_key_pkcs8;
     EXPECT_EQ(
         Status::Success(),
         ExportKey(
             blink::WebCryptoKeyFormatPkcs8, private_key, &private_key_pkcs8));
     private_key = blink::WebCryptoKey::createNull();
     EXPECT_EQ(Status::Success(),
               ImportKey(blink::WebCryptoKeyFormatPkcs8,
                         CryptoData(private_key_pkcs8),
                         CreateRsaHashedImportAlgorithm(
                             blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
@@ skipping 10 matching lines @@
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256,
                                      0,
                                      public_exponent);
   EXPECT_EQ(Status::ErrorGenerateRsaZeroModulus(),
             GenerateKeyPair(
                 algorithm, extractable, usage_mask, &public_key, &private_key));
 
   // Fail with bad exponent: larger than unsigned long.
   unsigned int exponent_length = sizeof(unsigned long) + 1;  // NOLINT
-  const std::vector<uint8> long_exponent(exponent_length, 0x01);
+  const std::vector<uint8_t> long_exponent(exponent_length, 0x01);
   algorithm =
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256,
                                      modulus_length,
                                      long_exponent);
   EXPECT_EQ(Status::ErrorGenerateKeyPublicExponent(),
             GenerateKeyPair(
                 algorithm, extractable, usage_mask, &public_key, &private_key));
 
   // Fail with bad exponent: empty.
-  const std::vector<uint8> empty_exponent;
+  const std::vector<uint8_t> empty_exponent;
   algorithm =
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256,
                                      modulus_length,
                                      empty_exponent);
   EXPECT_EQ(Status::ErrorGenerateKeyPublicExponent(),
             GenerateKeyPair(
                 algorithm, extractable, usage_mask, &public_key, &private_key));
 
   // Fail with bad exponent: all zeros.
-  std::vector<uint8> exponent_with_leading_zeros(15, 0x00);
+  std::vector<uint8_t> exponent_with_leading_zeros(15, 0x00);
   algorithm =
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256,
                                      modulus_length,
                                      exponent_with_leading_zeros);
   EXPECT_EQ(Status::ErrorGenerateKeyPublicExponent(),
             GenerateKeyPair(
                 algorithm, extractable, usage_mask, &public_key, &private_key));
 
   // Key generation success using exponent with leading zeros.
@@ skipping 40 matching lines @@
             private_key.algorithm().rsaHashedParams()->hash().id());
   // Even though "extractable" was set to false, the public key remains
   // extractable.
   EXPECT_TRUE(public_key.extractable());
   EXPECT_FALSE(private_key.extractable());
   EXPECT_EQ(usage_mask, public_key.usages());
   EXPECT_EQ(usage_mask, private_key.usages());
 
   // Exporting a private key as SPKI format doesn't make sense. However this
   // will first fail because the key is not extractable.
-  std::vector<uint8> output;
+  std::vector<uint8_t> output;
   EXPECT_EQ(Status::ErrorKeyNotExtractable(),
             ExportKey(blink::WebCryptoKeyFormatSpki, private_key, &output));
 
   // Re-generate an extractable private_key and try to export it as SPKI format.
   // This should fail since spki is for public keys.
   EXPECT_EQ(
       Status::Success(),
       GenerateKeyPair(algorithm, true, usage_mask, &public_key, &private_key));
   EXPECT_EQ(Status::ErrorUnexpectedKeyType(),
             ExportKey(blink::WebCryptoKeyFormatSpki, private_key, &output));
 }
 
 TEST_F(SharedCryptoTest, MAYBE(GenerateKeyPairRsaBadModulusLength)) {
   const unsigned int kBadModulus[] = {
       0,
       255,         // Not a multiple of 8.
       1023,        // Not a multiple of 8.
       0xFFFFFFFF,  // Cannot fit in a signed int.
       16384 + 8,   // 16384 is the maxmimum length that NSS succeeds for.
   };
 
-  const std::vector<uint8> public_exponent = HexStringToBytes("010001");
+  const std::vector<uint8_t> public_exponent = HexStringToBytes("010001");
 
   for (size_t i = 0; i < arraysize(kBadModulus); ++i) {
     const unsigned int modulus_length = kBadModulus[i];
     blink::WebCryptoAlgorithm algorithm = CreateRsaHashedKeyGenAlgorithm(
         blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
         blink::WebCryptoAlgorithmIdSha256,
         modulus_length,
         public_exponent);
     bool extractable = true;
     const blink::WebCryptoKeyUsageMask usage_mask = 0;
@@ skipping 55 matching lines @@
                        import_algorithm,
                        false,
                        blink::WebCryptoKeyUsageVerify,
                        blink::WebCryptoKeyUsageSign,
                        &public_key,
                        &private_key));
 
   blink::WebCryptoAlgorithm algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5);
 
-  std::vector<uint8> signature;
+  std::vector<uint8_t> signature;
   bool signature_match;
 
   // Compute a signature.
-  const std::vector<uint8> data = HexStringToBytes("010203040506070809");
+  const std::vector<uint8_t> data = HexStringToBytes("010203040506070809");
   ASSERT_EQ(Status::Success(),
             Sign(algorithm, private_key, CryptoData(data), &signature));
 
   // Ensure truncated signature does not verify by passing one less byte.
   EXPECT_EQ(
       Status::Success(),
       Verify(algorithm,
              public_key,
              CryptoData(Uint8VectorStart(signature), signature.size() - 1),
              CryptoData(data),
              &signature_match));
   EXPECT_FALSE(signature_match);
 
   // Ensure truncated signature does not verify by passing no bytes.
   EXPECT_EQ(Status::Success(),
             Verify(algorithm,
                    public_key,
                    CryptoData(),
                    CryptoData(data),
                    &signature_match));
   EXPECT_FALSE(signature_match);
 
   // Ensure corrupted signature does not verify.
-  std::vector<uint8> corrupt_sig = signature;
+  std::vector<uint8_t> corrupt_sig = signature;
   corrupt_sig[corrupt_sig.size() / 2] ^= 0x1;
   EXPECT_EQ(Status::Success(),
             Verify(algorithm,
                    public_key,
                    CryptoData(corrupt_sig),
                    CryptoData(data),
                    &signature_match));
   EXPECT_FALSE(signature_match);
 
   // Ensure signatures that are greater than the modulus size fail.
@@ skipping 87 matching lines @@
                        false,
                        blink::WebCryptoKeyUsageVerify,
                        blink::WebCryptoKeyUsageSign,
                        &public_key,
                        &private_key));
 
   blink::WebCryptoAlgorithm algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5);
 
   // Validate the signatures are computed and verified as expected.
-  std::vector<uint8> signature;
+  std::vector<uint8_t> signature;
   for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
     SCOPED_TRACE(test_index);
 
     base::DictionaryValue* test;
     ASSERT_TRUE(tests->GetDictionary(test_index, &test));
 
-    std::vector<uint8> test_message =
+    std::vector<uint8_t> test_message =
         GetBytesFromHexString(test, "message_hex");
-    std::vector<uint8> test_signature =
+    std::vector<uint8_t> test_signature =
         GetBytesFromHexString(test, "signature_hex");
 
     signature.clear();
     ASSERT_EQ(
         Status::Success(),
         Sign(algorithm, private_key, CryptoData(test_message), &signature));
     EXPECT_BYTES_EQ(test_signature, signature);
 
     bool is_match = false;
     ASSERT_EQ(Status::Success(),
@@ skipping 13 matching lines @@
 
   // Import a 128-bit Key Encryption Key (KEK)
   std::string key_raw_hex_in = "025a8cf3f08b4f6c5f33bbc76a471939";
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(HexStringToBytes(key_raw_hex_in)),
                       algorithm,
                       true,
                       blink::WebCryptoKeyUsageWrapKey,
                       &key));
-  std::vector<uint8> key_raw_out;
+  std::vector<uint8_t> key_raw_out;
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &key_raw_out));
   EXPECT_BYTES_EQ_HEX(key_raw_hex_in, key_raw_out);
 
   // Import a 192-bit KEK
   key_raw_hex_in = "c0192c6466b2370decbb62b2cfef4384544ffeb4d2fbc103";
   ASSERT_EQ(Status::ErrorAes192BitUnsupported(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(HexStringToBytes(key_raw_hex_in)),
                       algorithm,
@@ skipping 55 matching lines @@
                       blink::WebCryptoKeyUsageWrapKey,
                       &key));
 }
 
 TEST_F(SharedCryptoTest, MAYBE(UnwrapFailures)) {
   // This test exercises the code path common to all unwrap operations.
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("aes_kw.json", &tests));
   base::DictionaryValue* test;
   ASSERT_TRUE(tests->GetDictionary(0, &test));
-  const std::vector<uint8> test_kek = GetBytesFromHexString(test, "kek");
-  const std::vector<uint8> test_ciphertext =
+  const std::vector<uint8_t> test_kek = GetBytesFromHexString(test, "kek");
+  const std::vector<uint8_t> test_ciphertext =
       GetBytesFromHexString(test, "ciphertext");
 
   blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
 
   // Using a wrapping algorithm that does not match the wrapping key algorithm
   // should fail.
   blink::WebCryptoKey wrapping_key = ImportSecretKeyFromRaw(
       test_kek,
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw),
       blink::WebCryptoKeyUsageUnwrapKey);
@@ skipping 10 matching lines @@
 }
 
 TEST_F(SharedCryptoTest, MAYBE(AesKwRawSymkeyWrapUnwrapKnownAnswer)) {
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("aes_kw.json", &tests));
 
   for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
     SCOPED_TRACE(test_index);
     base::DictionaryValue* test;
     ASSERT_TRUE(tests->GetDictionary(test_index, &test));
-    const std::vector<uint8> test_kek = GetBytesFromHexString(test, "kek");
-    const std::vector<uint8> test_key = GetBytesFromHexString(test, "key");
-    const std::vector<uint8> test_ciphertext =
+    const std::vector<uint8_t> test_kek = GetBytesFromHexString(test, "kek");
+    const std::vector<uint8_t> test_key = GetBytesFromHexString(test, "key");
+    const std::vector<uint8_t> test_ciphertext =
         GetBytesFromHexString(test, "ciphertext");
     const blink::WebCryptoAlgorithm wrapping_algorithm =
         webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw);
 
     // Import the wrapping key.
     blink::WebCryptoKey wrapping_key = ImportSecretKeyFromRaw(
         test_kek,
         wrapping_algorithm,
         blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey);
 
     // Import the key to be wrapped.
     blink::WebCryptoKey key = ImportSecretKeyFromRaw(
         test_key,
         CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha1),
         blink::WebCryptoKeyUsageSign);
 
     // Wrap the key and verify the ciphertext result against the known answer.
-    std::vector<uint8> wrapped_key;
+    std::vector<uint8_t> wrapped_key;
     ASSERT_EQ(Status::Success(),
               WrapKey(blink::WebCryptoKeyFormatRaw,
                       key,
                       wrapping_key,
                       wrapping_algorithm,
                       &wrapped_key));
     EXPECT_BYTES_EQ(test_ciphertext, wrapped_key);
 
     // Unwrap the known ciphertext to get a new test_key.
     blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
     ASSERT_EQ(
         Status::Success(),
         UnwrapKey(blink::WebCryptoKeyFormatRaw,
                   CryptoData(test_ciphertext),
                   wrapping_key,
                   wrapping_algorithm,
                   CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha1),
                   true,
                   blink::WebCryptoKeyUsageSign,
                   &unwrapped_key));
     EXPECT_FALSE(key.isNull());
     EXPECT_TRUE(key.handle());
     EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
     EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
     EXPECT_EQ(true, key.extractable());
     EXPECT_EQ(blink::WebCryptoKeyUsageSign, key.usages());
 
     // Export the new key and compare its raw bytes with the original known key.
-    std::vector<uint8> raw_key;
+    std::vector<uint8_t> raw_key;
     EXPECT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatRaw, unwrapped_key, &raw_key));
     EXPECT_BYTES_EQ(test_key, raw_key);
   }
 }
 
 // Unwrap a HMAC key using AES-KW, and then try doing a sign/verify with the
 // unwrapped key
 TEST_F(SharedCryptoTest, MAYBE(AesKwRawSymkeyUnwrapSignVerifyHmac)) {
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("aes_kw.json", &tests));
 
   base::DictionaryValue* test;
   ASSERT_TRUE(tests->GetDictionary(0, &test));
-  const std::vector<uint8> test_kek = GetBytesFromHexString(test, "kek");
-  const std::vector<uint8> test_ciphertext =
+  const std::vector<uint8_t> test_kek = GetBytesFromHexString(test, "kek");
+  const std::vector<uint8_t> test_ciphertext =
       GetBytesFromHexString(test, "ciphertext");
   const blink::WebCryptoAlgorithm wrapping_algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw);
 
   // Import the wrapping key.
   blink::WebCryptoKey wrapping_key = ImportSecretKeyFromRaw(
       test_kek, wrapping_algorithm, blink::WebCryptoKeyUsageUnwrapKey);
 
   // Unwrap the known ciphertext.
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(
       Status::Success(),
       UnwrapKey(blink::WebCryptoKeyFormatRaw,
                 CryptoData(test_ciphertext),
                 wrapping_key,
                 wrapping_algorithm,
                 CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha1),
                 false,
                 blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify,
                 &key));
 
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
   EXPECT_FALSE(key.extractable());
   EXPECT_EQ(blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify,
             key.usages());
 
   // Sign an empty message and ensure it is verified.
-  std::vector<uint8> test_message;
-  std::vector<uint8> signature;
+  std::vector<uint8_t> test_message;
+  std::vector<uint8_t> signature;
 
   ASSERT_EQ(Status::Success(),
             Sign(CreateAlgorithm(blink::WebCryptoAlgorithmIdHmac),
                  key,
                  CryptoData(test_message),
                  &signature));
 
   EXPECT_GT(signature.size(), 0u);
 
   bool verify_result;
   ASSERT_EQ(Status::Success(),
             Verify(CreateAlgorithm(blink::WebCryptoAlgorithmIdHmac),
                    key,
                    CryptoData(signature),
                    CryptoData(test_message),
                    &verify_result));
 }
 
 TEST_F(SharedCryptoTest, MAYBE(AesKwRawSymkeyWrapUnwrapErrors)) {
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("aes_kw.json", &tests));
   base::DictionaryValue* test;
   // Use 256 bits of data with a 256-bit KEK
   ASSERT_TRUE(tests->GetDictionary(3, &test));
-  const std::vector<uint8> test_kek = GetBytesFromHexString(test, "kek");
-  const std::vector<uint8> test_key = GetBytesFromHexString(test, "key");
-  const std::vector<uint8> test_ciphertext =
+  const std::vector<uint8_t> test_kek = GetBytesFromHexString(test, "kek");
+  const std::vector<uint8_t> test_key = GetBytesFromHexString(test, "key");
+  const std::vector<uint8_t> test_ciphertext =
       GetBytesFromHexString(test, "ciphertext");
   const blink::WebCryptoAlgorithm wrapping_algorithm =
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw);
   const blink::WebCryptoAlgorithm key_algorithm =
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc);
   // Import the wrapping key.
   blink::WebCryptoKey wrapping_key = ImportSecretKeyFromRaw(
       test_kek,
       wrapping_algorithm,
       blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey);
   // Import the key to be wrapped.
   blink::WebCryptoKey key = ImportSecretKeyFromRaw(
       test_key,
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
       blink::WebCryptoKeyUsageEncrypt);
 
   // Unwrap with wrapped data too small must fail.
-  const std::vector<uint8> small_data(test_ciphertext.begin(),
-                                      test_ciphertext.begin() + 23);
+  const std::vector<uint8_t> small_data(test_ciphertext.begin(),
+                                        test_ciphertext.begin() + 23);
   blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
   EXPECT_EQ(Status::ErrorDataTooSmall(),
             UnwrapKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(small_data),
                       wrapping_key,
                       wrapping_algorithm,
                       key_algorithm,
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
 
   // Unwrap with wrapped data size not a multiple of 8 bytes must fail.
-  const std::vector<uint8> unaligned_data(test_ciphertext.begin(),
-                                          test_ciphertext.end() - 2);
+  const std::vector<uint8_t> unaligned_data(test_ciphertext.begin(),
+                                            test_ciphertext.end() - 2);
   EXPECT_EQ(Status::ErrorInvalidAesKwDataLength(),
             UnwrapKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(unaligned_data),
                       wrapping_key,
                       wrapping_algorithm,
                       key_algorithm,
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
 }
 
 TEST_F(SharedCryptoTest, MAYBE(AesKwRawSymkeyUnwrapCorruptData)) {
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("aes_kw.json", &tests));
   base::DictionaryValue* test;
   // Use 256 bits of data with a 256-bit KEK
   ASSERT_TRUE(tests->GetDictionary(3, &test));
-  const std::vector<uint8> test_kek = GetBytesFromHexString(test, "kek");
-  const std::vector<uint8> test_key = GetBytesFromHexString(test, "key");
-  const std::vector<uint8> test_ciphertext =
+  const std::vector<uint8_t> test_kek = GetBytesFromHexString(test, "kek");
+  const std::vector<uint8_t> test_key = GetBytesFromHexString(test, "key");
+  const std::vector<uint8_t> test_ciphertext =
       GetBytesFromHexString(test, "ciphertext");
   const blink::WebCryptoAlgorithm wrapping_algorithm =
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw);
 
   // Import the wrapping key.
   blink::WebCryptoKey wrapping_key = ImportSecretKeyFromRaw(
       test_kek,
       wrapping_algorithm,
       blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey);
 
@@ skipping 13 matching lines @@
 }
 
 TEST_F(SharedCryptoTest, MAYBE(AesKwJwkSymkeyUnwrapKnownData)) {
   // The following data lists a known HMAC SHA-256 key, then a JWK
   // representation of this key which was encrypted ("wrapped") using AES-KW and
   // the following wrapping key.
   // For reference, the intermediate clear JWK is
   // {"alg":"HS256","ext":true,"k":<b64urlKey>,"key_ops":["verify"],"kty":"oct"}
   // (Not shown is space padding to ensure the cleartext meets the size
   // requirements of the AES-KW algorithm.)
-  const std::vector<uint8> key_data = HexStringToBytes(
+  const std::vector<uint8_t> key_data = HexStringToBytes(
       "000102030405060708090A0B0C0D0E0F000102030405060708090A0B0C0D0E0F");
-  const std::vector<uint8> wrapped_key_data = HexStringToBytes(
+  const std::vector<uint8_t> wrapped_key_data = HexStringToBytes(
       "14E6380B35FDC5B72E1994764B6CB7BFDD64E7832894356AAEE6C3768FC3D0F115E6B0"
       "6729756225F999AA99FDF81FD6A359F1576D3D23DE6CB69C3937054EB497AC1E8C38D5"
       "5E01B9783A20C8D930020932CF25926103002213D0FC37279888154FEBCEDF31832158"
       "97938C5CFE5B10B4254D0C399F39D0");
-  const std::vector<uint8> wrapping_key_data =
+  const std::vector<uint8_t> wrapping_key_data =
       HexStringToBytes("000102030405060708090A0B0C0D0E0F");
   const blink::WebCryptoAlgorithm wrapping_algorithm =
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw);
 
   // Import the wrapping key.
   blink::WebCryptoKey wrapping_key = ImportSecretKeyFromRaw(
       wrapping_key_data, wrapping_algorithm, blink::WebCryptoKeyUsageUnwrapKey);
 
   // Unwrap the known wrapped key data to produce a new key
   blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
@@ skipping 13 matching lines @@
   EXPECT_TRUE(unwrapped_key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, unwrapped_key.type());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, unwrapped_key.algorithm().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha256,
             unwrapped_key.algorithm().hmacParams()->hash().id());
   EXPECT_EQ(256u, unwrapped_key.algorithm().hmacParams()->lengthBits());
   EXPECT_EQ(true, unwrapped_key.extractable());
   EXPECT_EQ(blink::WebCryptoKeyUsageVerify, unwrapped_key.usages());
 
   // Export the new key's raw data and compare to the known original.
-  std::vector<uint8> raw_key;
+  std::vector<uint8_t> raw_key;
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, unwrapped_key, &raw_key));
   EXPECT_BYTES_EQ(key_data, raw_key);
 }
 
 // TODO(eroman):
 //   * Test decryption when the tag length exceeds input size
 //   * Test decryption with empty input
 //   * Test decryption with tag length of 0.
 TEST_F(SharedCryptoTest, AesGcmSampleSets) {
   // Some Linux test runners may not have a new enough version of NSS.
   if (!SupportsAesGcm()) {
     LOG(WARNING) << "AES GCM not supported, skipping tests";
     return;
   }
 
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("aes_gcm.json", &tests));
 
   // Note that WebCrypto appends the authentication tag to the ciphertext.
   for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
     SCOPED_TRACE(test_index);
     base::DictionaryValue* test;
     ASSERT_TRUE(tests->GetDictionary(test_index, &test));
 
-    const std::vector<uint8> test_key = GetBytesFromHexString(test, "key");
-    const std::vector<uint8> test_iv = GetBytesFromHexString(test, "iv");
-    const std::vector<uint8> test_additional_data =
+    const std::vector<uint8_t> test_key = GetBytesFromHexString(test, "key");
+    const std::vector<uint8_t> test_iv = GetBytesFromHexString(test, "iv");
+    const std::vector<uint8_t> test_additional_data =
         GetBytesFromHexString(test, "additional_data");
-    const std::vector<uint8> test_plain_text =
+    const std::vector<uint8_t> test_plain_text =
         GetBytesFromHexString(test, "plain_text");
-    const std::vector<uint8> test_authentication_tag =
+    const std::vector<uint8_t> test_authentication_tag =
         GetBytesFromHexString(test, "authentication_tag");
     const unsigned int test_tag_size_bits = test_authentication_tag.size() * 8;
-    const std::vector<uint8> test_cipher_text =
+    const std::vector<uint8_t> test_cipher_text =
         GetBytesFromHexString(test, "cipher_text");
 
 #if defined(USE_OPENSSL)
     // TODO(eroman): Add support for 256-bit keys.
     if (test_key.size() == 32) {
       LOG(WARNING)
           << "OpenSSL doesn't support 256-bit keys for AES-GCM; skipping";
       continue;
     }
 #endif
 
     blink::WebCryptoKey key = ImportSecretKeyFromRaw(
         test_key,
         CreateAlgorithm(blink::WebCryptoAlgorithmIdAesGcm),
         blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt);
 
     // Verify exported raw key is identical to the imported data
-    std::vector<uint8> raw_key;
+    std::vector<uint8_t> raw_key;
     EXPECT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
 
     EXPECT_BYTES_EQ(test_key, raw_key);
 
     // Test encryption.
-    std::vector<uint8> cipher_text;
-    std::vector<uint8> authentication_tag;
+    std::vector<uint8_t> cipher_text;
+    std::vector<uint8_t> authentication_tag;
     EXPECT_EQ(Status::Success(),
               AesGcmEncrypt(key,
                             test_iv,
                             test_additional_data,
                             test_tag_size_bits,
                             test_plain_text,
                             &cipher_text,
                             &authentication_tag));
 
     EXPECT_BYTES_EQ(test_cipher_text, cipher_text);
     EXPECT_BYTES_EQ(test_authentication_tag, authentication_tag);
 
     // Test decryption.
-    std::vector<uint8> plain_text;
+    std::vector<uint8_t> plain_text;
     EXPECT_EQ(Status::Success(),
               AesGcmDecrypt(key,
                             test_iv,
                             test_additional_data,
                             test_tag_size_bits,
                             test_cipher_text,
                             test_authentication_tag,
                             &plain_text));
     EXPECT_BYTES_EQ(test_plain_text, plain_text);
 
@@ skipping 25 matching lines @@
     EXPECT_EQ(Status::OperationError(),
               AesGcmDecrypt(key,
                             test_iv,
                             test_additional_data,
                             test_tag_size_bits,
                             test_cipher_text,
                             Corrupted(test_authentication_tag),
                             &plain_text));
 
     // Try different incorrect tag lengths
-    uint8 kAlternateTagLengths[] = {0, 8, 96, 120, 128, 160, 255};
+    uint8_t kAlternateTagLengths[] = {0, 8, 96, 120, 128, 160, 255};
     for (size_t tag_i = 0; tag_i < arraysize(kAlternateTagLengths); ++tag_i) {
       unsigned int wrong_tag_size_bits = kAlternateTagLengths[tag_i];
       if (test_tag_size_bits == wrong_tag_size_bits)
         continue;
       EXPECT_NE(Status::Success(),
                 AesGcmDecrypt(key,
                               test_iv,
                               test_additional_data,
                               wrong_tag_size_bits,
                               test_cipher_text,
                               test_authentication_tag,
                               &plain_text));
     }
   }
 }
 
 // AES 192-bit is not allowed: http://crbug.com/381829
 TEST_F(SharedCryptoTest, MAYBE(ImportAesCbc192Raw)) {
-  std::vector<uint8> key_raw(24, 0);
+  std::vector<uint8_t> key_raw(24, 0);
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   Status status = ImportKey(blink::WebCryptoKeyFormatRaw,
                             CryptoData(key_raw),
                             CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
                             true,
                             blink::WebCryptoKeyUsageEncrypt,
                             &key);
   ASSERT_EQ(Status::ErrorAes192BitUnsupported(), status);
 }
 
@@ skipping 20 matching lines @@
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   Status status = GenerateSecretKey(CreateAesCbcKeyGenAlgorithm(192),
                                     true,
                                     blink::WebCryptoKeyUsageEncrypt,
                                     &key);
   ASSERT_EQ(Status::ErrorAes192BitUnsupported(), status);
 }
 
 // AES 192-bit is not allowed: http://crbug.com/381829
 TEST_F(SharedCryptoTest, MAYBE(UnwrapAesCbc192)) {
-  std::vector<uint8> wrapping_key_data(16, 0);
-  std::vector<uint8> wrapped_key = HexStringToBytes(
+  std::vector<uint8_t> wrapping_key_data(16, 0);
+  std::vector<uint8_t> wrapped_key = HexStringToBytes(
       "1A07ACAB6C906E50883173C29441DB1DE91D34F45C435B5F99C822867FB3956F");
 
   blink::WebCryptoKey wrapping_key =
       ImportSecretKeyFromRaw(wrapping_key_data,
                              CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw),
                              blink::WebCryptoKeyUsageUnwrapKey);
 
   blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
       ASSERT_EQ(Status::ErrorAes192BitUnsupported(),
                 UnwrapKey(blink::WebCryptoKeyFormatRaw,
@@ skipping 144 matching lines @@
     ASSERT_EQ(Status::Success(),
               ImportKeyJwkFromDict(
                   *jwk.get(),
                   CreateRsaHashedImportAlgorithm(
                       blink::WebCryptoAlgorithmIdRsaOaep, test_data.hash_alg),
                   true,
                   blink::WebCryptoKeyUsageEncrypt,
                   &public_key));
 
     // Now export the key as JWK and verify its contents
-    std::vector<uint8> jwk_data;
+    std::vector<uint8_t> jwk_data;
     ASSERT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatJwk, public_key, &jwk_data));
     EXPECT_TRUE(VerifyPublicJwk(jwk_data,
                                 test_data.expected_jwk_alg,
                                 kPublicKeyModulusHex,
                                 kPublicKeyExponentHex,
                                 blink::WebCryptoKeyUsageEncrypt));
   }
 }
 
 TEST_F(SharedCryptoRsaOaepTest, EncryptDecryptKnownAnswerTest) {
   if (!SupportsRsaOaep()) {
     LOG(WARNING) << "RSA-OAEP support not present; skipping.";
     return;
   }
 
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("rsa_oaep.json", &tests));
 
   for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
     SCOPED_TRACE(test_index);
 
     base::DictionaryValue* test = NULL;
     ASSERT_TRUE(tests->GetDictionary(test_index, &test));
 
     blink::WebCryptoAlgorithm digest_algorithm =
         GetDigestAlgorithm(test, "hash");
     ASSERT_FALSE(digest_algorithm.isNull());
-    std::vector<uint8> public_key_der =
+    std::vector<uint8_t> public_key_der =
         GetBytesFromHexString(test, "public_key");
-    std::vector<uint8> private_key_der =
+    std::vector<uint8_t> private_key_der =
         GetBytesFromHexString(test, "private_key");
-    std::vector<uint8> ciphertext = GetBytesFromHexString(test, "ciphertext");
-    std::vector<uint8> plaintext = GetBytesFromHexString(test, "plaintext");
-    std::vector<uint8> label = GetBytesFromHexString(test, "label");
+    std::vector<uint8_t> ciphertext = GetBytesFromHexString(test, "ciphertext");
+    std::vector<uint8_t> plaintext = GetBytesFromHexString(test, "plaintext");
+    std::vector<uint8_t> label = GetBytesFromHexString(test, "label");
 
     blink::WebCryptoAlgorithm import_algorithm = CreateRsaHashedImportAlgorithm(
         blink::WebCryptoAlgorithmIdRsaOaep, digest_algorithm.id());
     blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
     blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
 
     ASSERT_NO_FATAL_FAILURE(ImportRsaKeyPair(public_key_der,
                                              private_key_der,
                                              import_algorithm,
                                              false,
                                              blink::WebCryptoKeyUsageEncrypt,
                                              blink::WebCryptoKeyUsageDecrypt,
                                              &public_key,
                                              &private_key));
 
     blink::WebCryptoAlgorithm op_algorithm = CreateRsaOaepAlgorithm(label);
-    std::vector<uint8> decrypted_data;
+    std::vector<uint8_t> decrypted_data;
     ASSERT_EQ(Status::Success(),
               Decrypt(op_algorithm,
                       private_key,
                       CryptoData(ciphertext),
                       &decrypted_data));
     EXPECT_BYTES_EQ(plaintext, decrypted_data);
-    std::vector<uint8> encrypted_data;
+    std::vector<uint8_t> encrypted_data;
     ASSERT_EQ(
         Status::Success(),
         Encrypt(
             op_algorithm, public_key, CryptoData(plaintext), &encrypted_data));
-    std::vector<uint8> redecrypted_data;
+    std::vector<uint8_t> redecrypted_data;
     ASSERT_EQ(Status::Success(),
               Decrypt(op_algorithm,
                       private_key,
                       CryptoData(encrypted_data),
                       &redecrypted_data));
     EXPECT_BYTES_EQ(plaintext, redecrypted_data);
   }
 }
 
 TEST_F(SharedCryptoRsaOaepTest, EncryptWithLargeMessageFails) {
@@ skipping 19 matching lines @@
   // The maximum size of an encrypted message is:
   //   modulus length
   //   - 1 (leading octet)
   //   - hash size (maskedSeed)
   //   - hash size (lHash portion of maskedDB)
   //   - 1 (at least one octet for the padding string)
   size_t kMaxMessageSize = (kModulusLengthBits / 8) - 2 - (2 * kHashSize);
 
   // The label has no influence on the maximum message size. For simplicity,
   // use the empty string.
-  std::vector<uint8> label;
+  std::vector<uint8_t> label;
   blink::WebCryptoAlgorithm op_algorithm = CreateRsaOaepAlgorithm(label);
 
   // Test that a message just before the boundary succeeds.
   std::string large_message;
   large_message.resize(kMaxMessageSize - 1, 'A');
 
-  std::vector<uint8> ciphertext;
+  std::vector<uint8_t> ciphertext;
   ASSERT_EQ(
       Status::Success(),
       Encrypt(
           op_algorithm, public_key, CryptoData(large_message), &ciphertext));
 
   // Test that a message at the boundary succeeds.
   large_message.resize(kMaxMessageSize, 'A');
   ciphertext.clear();
 
   ASSERT_EQ(
@@ skipping 31 matching lines @@
   ASSERT_EQ(Status::Success(),
             ImportKeyJwkFromDict(*jwk.get(),
                                  CreateRsaHashedImportAlgorithm(
                                      blink::WebCryptoAlgorithmIdRsaOaep, kHash),
                                  true,
                                  blink::WebCryptoKeyUsageEncrypt,
                                  &public_key));
 
   // The label has no influence on the maximum message size. For simplicity,
   // use the empty string.
-  std::vector<uint8> label;
+  std::vector<uint8_t> label;
   blink::WebCryptoAlgorithm op_algorithm = CreateRsaOaepAlgorithm(label);
 
   std::string small_message("A");
-  std::vector<uint8> ciphertext;
+  std::vector<uint8_t> ciphertext;
   // This is an operation error, as the internal consistency checking of the
   // algorithm parameters is up to the implementation.
   ASSERT_EQ(
       Status::OperationError(),
       Encrypt(
           op_algorithm, public_key, CryptoData(small_message), &ciphertext));
 }
 
 TEST_F(SharedCryptoRsaOaepTest, DecryptWithLargeMessageFails) {
   if (!SupportsRsaOaep()) {
     LOG(WARNING) << "RSA-OAEP support not present; skipping.";
     return;
   }
 
   blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatPkcs8,
                       CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaOaep,
                           blink::WebCryptoAlgorithmIdSha1),
                       true,
                       blink::WebCryptoKeyUsageDecrypt,
                       &private_key));
 
   // The label has no influence on the maximum message size. For simplicity,
   // use the empty string.
-  std::vector<uint8> label;
+  std::vector<uint8_t> label;
   blink::WebCryptoAlgorithm op_algorithm = CreateRsaOaepAlgorithm(label);
 
   std::string large_dummy_message(kModulusLengthBits / 8, 'A');
-  std::vector<uint8> plaintext;
+  std::vector<uint8_t> plaintext;
 
   ASSERT_EQ(Status::OperationError(),
             Decrypt(op_algorithm,
                     private_key,
                     CryptoData(large_dummy_message),
                     &plaintext));
 }
 
 TEST_F(SharedCryptoRsaOaepTest, WrapUnwrapRawKey) {
   if (!SupportsRsaOaep()) {
     LOG(WARNING) << "RSA-OAEP support not present; skipping.";
     return;
   }
 
   blink::WebCryptoAlgorithm import_algorithm = CreateRsaHashedImportAlgorithm(
       blink::WebCryptoAlgorithmIdRsaOaep, blink::WebCryptoAlgorithmIdSha1);
   blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
   blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
 
   ASSERT_NO_FATAL_FAILURE(ImportRsaKeyPair(
       HexStringToBytes(kPublicKeySpkiDerHex),
       HexStringToBytes(kPrivateKeyPkcs8DerHex),
       import_algorithm,
       false,
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageWrapKey,
       blink::WebCryptoKeyUsageDecrypt | blink::WebCryptoKeyUsageUnwrapKey,
       &public_key,
       &private_key));
 
-  std::vector<uint8> label;
+  std::vector<uint8_t> label;
   blink::WebCryptoAlgorithm wrapping_algorithm = CreateRsaOaepAlgorithm(label);
 
   const std::string key_hex = "000102030405060708090A0B0C0D0E0F";
   const blink::WebCryptoAlgorithm key_algorithm =
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc);
 
   blink::WebCryptoKey key =
       ImportSecretKeyFromRaw(HexStringToBytes(key_hex),
                              key_algorithm,
                              blink::WebCryptoKeyUsageEncrypt);
   ASSERT_FALSE(key.isNull());
 
-  std::vector<uint8> wrapped_key;
+  std::vector<uint8_t> wrapped_key;
   ASSERT_EQ(Status::Success(),
             WrapKey(blink::WebCryptoKeyFormatRaw,
                     key,
                     public_key,
                     wrapping_algorithm,
                     &wrapped_key));
 
   // Verify that |wrapped_key| can be decrypted and yields the key data.
   // Because |private_key| supports both decrypt and unwrap, this is valid.
-  std::vector<uint8> decrypted_key;
+  std::vector<uint8_t> decrypted_key;
   ASSERT_EQ(Status::Success(),
             Decrypt(wrapping_algorithm,
                     private_key,
                     CryptoData(wrapped_key),
                     &decrypted_key));
   EXPECT_BYTES_EQ_HEX(key_hex, decrypted_key);
 
   // Now attempt to unwrap the key, which should also decrypt the data.
   blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             UnwrapKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(wrapped_key),
                       private_key,
                       wrapping_algorithm,
                       key_algorithm,
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
   ASSERT_FALSE(unwrapped_key.isNull());
 
-  std::vector<uint8> raw_key;
+  std::vector<uint8_t> raw_key;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, unwrapped_key, &raw_key));
   EXPECT_BYTES_EQ_HEX(key_hex, raw_key);
 }
 
 TEST_F(SharedCryptoRsaOaepTest, WrapUnwrapJwkSymKey) {
   if (!SupportsRsaOaep()) {
     LOG(WARNING) << "RSA-OAEP support not present; skipping.";
     return;
   }
@@ skipping 53 matching lines @@
   ASSERT_NO_FATAL_FAILURE(ImportRsaKeyPair(
       HexStringToBytes(kPublicKey2048SpkiDerHex),
       HexStringToBytes(kPrivateKey2048Pkcs8DerHex),
       import_algorithm,
       false,
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageWrapKey,
       blink::WebCryptoKeyUsageDecrypt | blink::WebCryptoKeyUsageUnwrapKey,
       &public_key,
       &private_key));
 
-  std::vector<uint8> label;
+  std::vector<uint8_t> label;
   blink::WebCryptoAlgorithm wrapping_algorithm = CreateRsaOaepAlgorithm(label);
 
   const std::string key_hex = "000102030405060708090a0b0c0d0e0f";
   const blink::WebCryptoAlgorithm key_algorithm =
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc);
 
   blink::WebCryptoKey key =
       ImportSecretKeyFromRaw(HexStringToBytes(key_hex),
                              key_algorithm,
                              blink::WebCryptoKeyUsageEncrypt);
   ASSERT_FALSE(key.isNull());
 
-  std::vector<uint8> wrapped_key;
+  std::vector<uint8_t> wrapped_key;
   ASSERT_EQ(Status::Success(),
             WrapKey(blink::WebCryptoKeyFormatJwk,
                     key,
                     public_key,
                     wrapping_algorithm,
                     &wrapped_key));
 
   // Verify that |wrapped_key| can be decrypted and yields a valid JWK object.
   // Because |private_key| supports both decrypt and unwrap, this is valid.
-  std::vector<uint8> decrypted_jwk;
+  std::vector<uint8_t> decrypted_jwk;
   ASSERT_EQ(Status::Success(),
             Decrypt(wrapping_algorithm,
                     private_key,
                     CryptoData(wrapped_key),
                     &decrypted_jwk));
   EXPECT_TRUE(VerifySecretJwk(
       decrypted_jwk, "A128CBC", key_hex, blink::WebCryptoKeyUsageEncrypt));
 
   // Now attempt to unwrap the key, which should also decrypt the data.
   blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             UnwrapKey(blink::WebCryptoKeyFormatJwk,
                       CryptoData(wrapped_key),
                       private_key,
                       wrapping_algorithm,
                       key_algorithm,
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
   ASSERT_FALSE(unwrapped_key.isNull());
 
-  std::vector<uint8> raw_key;
+  std::vector<uint8_t> raw_key;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, unwrapped_key, &raw_key));
   EXPECT_BYTES_EQ_HEX(key_hex, raw_key);
 }
 
 // Try importing an RSA-SSA public key with unsupported key usages using SPKI
 // format. RSA-SSA public keys only support the 'verify' usage.
 TEST_F(SharedCryptoTest, MAYBE(ImportRsaSsaPublicKeyBadUsage_SPKI)) {
   const blink::WebCryptoAlgorithm algorithm =
       CreateRsaHashedImportAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
@@ skipping 56 matching lines @@
   const blink::WebCryptoAlgorithm algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc);
 
   blink::WebCryptoKeyUsageMask bad_usages[] = {
       blink::WebCryptoKeyUsageSign,
       blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageDecrypt,
       blink::WebCryptoKeyUsageDeriveBits,
       blink::WebCryptoKeyUsageUnwrapKey | blink::WebCryptoKeyUsageVerify,
   };
 
-  std::vector<uint8> key_bytes(16);
+  std::vector<uint8_t> key_bytes(16);
 
   for (size_t i = 0; i < arraysize(bad_usages); ++i) {
     SCOPED_TRACE(i);
 
     blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
     ASSERT_EQ(Status::ErrorCreateKeyBadUsages(),
               ImportKey(blink::WebCryptoKeyFormatRaw,
                         CryptoData(key_bytes),
                         algorithm,
                         true,
@@ skipping 11 matching lines @@
 
   blink::WebCryptoKeyUsageMask bad_usages[] = {
       blink::WebCryptoKeyUsageEncrypt,
       blink::WebCryptoKeyUsageDecrypt,
       blink::WebCryptoKeyUsageSign,
       blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageUnwrapKey,
       blink::WebCryptoKeyUsageDeriveBits,
       blink::WebCryptoKeyUsageUnwrapKey | blink::WebCryptoKeyUsageVerify,
   };
 
-  std::vector<uint8> key_bytes(16);
+  std::vector<uint8_t> key_bytes(16);
 
   for (size_t i = 0; i < arraysize(bad_usages); ++i) {
     SCOPED_TRACE(i);
 
     blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
     ASSERT_EQ(Status::ErrorCreateKeyBadUsages(),
               ImportKey(blink::WebCryptoKeyFormatRaw,
                         CryptoData(key_bytes),
                         algorithm,
                         true,
@@ skipping 14 matching lines @@
       blink::WebCryptoKeyUsageDecrypt,
       blink::WebCryptoKeyUsageWrapKey,
       blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageWrapKey,
       blink::WebCryptoKeyUsageVerify | blink::WebCryptoKeyUsageDeriveKey,
   };
 
   // Import the wrapping key.
   blink::WebCryptoKey wrapping_key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
-                      CryptoData(std::vector<uint8>(16)),
+                      CryptoData(std::vector<uint8_t>(16)),
                       unwrap_algorithm,
                       true,
                       blink::WebCryptoKeyUsageUnwrapKey,
                       &wrapping_key));
 
   // The JWK plain text is:
   //   {   "kty": "oct","alg": "HS256","k": "GADWrMRHwQfoNaXU5fZvTg=="}
   const char* kWrappedJwk =
       "0AA245F17064FFB2A7A094436A39BEBFC962C627303D1327EA750CE9F917688C2782A943"
       "7AE7586547AC490E8AE7D5B02D63868D5C3BB57D36C4C8C5BF3962ACEC6F42E767E5706"
@@ skipping 29 matching lines @@
       blink::WebCryptoKeyUsageSign,
       blink::WebCryptoKeyUsageDecrypt,
       blink::WebCryptoKeyUsageWrapKey,
       blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageWrapKey,
   };
 
   // Import the wrapping key.
   blink::WebCryptoKey wrapping_key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
-                      CryptoData(std::vector<uint8>(16)),
+                      CryptoData(std::vector<uint8_t>(16)),
                       unwrap_algorithm,
                       true,
                       blink::WebCryptoKeyUsageUnwrapKey,
                       &wrapping_key));
 
   // The JWK plaintext is:
   // {    "kty": "RSA","alg": "RS256","n": "...","e": "AQAB"}
 
   const char* kWrappedJwk =
       "CE8DAEF99E977EE58958B8C4494755C846E883B2ECA575C5366622839AF71AB30875F152"
@@ skipping 45 matching lines @@
 // Generate an RSA-SSA key pair with invalid usages. RSA-SSA supports:
 //   'sign', 'verify'
 TEST_F(SharedCryptoTest, MAYBE(GenerateRsaSsaBadUsages)) {
   blink::WebCryptoKeyUsageMask bad_usages[] = {
       blink::WebCryptoKeyUsageDecrypt,
       blink::WebCryptoKeyUsageVerify | blink::WebCryptoKeyUsageDecrypt,
       blink::WebCryptoKeyUsageWrapKey,
   };
 
   const unsigned int modulus_length = 256;
-  const std::vector<uint8> public_exponent = HexStringToBytes("010001");
+  const std::vector<uint8_t> public_exponent = HexStringToBytes("010001");
 
   for (size_t i = 0; i < arraysize(bad_usages); ++i) {
     SCOPED_TRACE(i);
 
     blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
     blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
 
     ASSERT_EQ(Status::ErrorCreateKeyBadUsages(),
               GenerateKeyPair(CreateRsaHashedKeyGenAlgorithm(
                                   blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                   blink::WebCryptoAlgorithmIdSha256,
                                   modulus_length,
                                   public_exponent),
                               true,
                               bad_usages[i],
                               &public_key,
                               &private_key));
   }
 }
 
 // Generate an RSA-SSA key pair. The public and private keys should select the
 // key usages which are applicable, and not have the exact same usages as was
 // specified to GenerateKey
 TEST_F(SharedCryptoTest, MAYBE(GenerateRsaSsaKeyPairIntersectUsages)) {
   const unsigned int modulus_length = 256;
-  const std::vector<uint8> public_exponent = HexStringToBytes("010001");
+  const std::vector<uint8_t> public_exponent = HexStringToBytes("010001");
 
   blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
   blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
 
   ASSERT_EQ(Status::Success(),
             GenerateKeyPair(
                 CreateRsaHashedKeyGenAlgorithm(
                     blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                     blink::WebCryptoAlgorithmIdSha256,
                     modulus_length,
@@ skipping 33 matching lines @@
   blink::WebCryptoKey wrapping_key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             GenerateSecretKey(CreateAesCbcKeyGenAlgorithm(128),
                               true,
                               blink::WebCryptoKeyUsageWrapKey |
                                   blink::WebCryptoKeyUsageUnwrapKey,
                               &wrapping_key));
 
   // Generate an RSA key pair to be wrapped.
   const unsigned int modulus_length = 256;
-  const std::vector<uint8> public_exponent = HexStringToBytes("010001");
+  const std::vector<uint8_t> public_exponent = HexStringToBytes("010001");
 
   blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
   blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             GenerateKeyPair(CreateRsaHashedKeyGenAlgorithm(
                                 blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                 blink::WebCryptoAlgorithmIdSha256,
                                 modulus_length,
                                 public_exponent),
                             true,
                             0,
                             &public_key,
                             &private_key));
 
   // Export key pair as SPKI + PKCS8
-  std::vector<uint8> public_key_spki;
+  std::vector<uint8_t> public_key_spki;
   ASSERT_EQ(
       Status::Success(),
       ExportKey(blink::WebCryptoKeyFormatSpki, public_key, &public_key_spki));
 
-  std::vector<uint8> private_key_pkcs8;
+  std::vector<uint8_t> private_key_pkcs8;
   ASSERT_EQ(
       Status::Success(),
       ExportKey(
           blink::WebCryptoKeyFormatPkcs8, private_key, &private_key_pkcs8));
 
   // Wrap the key pair.
   blink::WebCryptoAlgorithm wrap_algorithm =
-      CreateAesCbcAlgorithm(std::vector<uint8>(16, 0));
+      CreateAesCbcAlgorithm(std::vector<uint8_t>(16, 0));
 
-  std::vector<uint8> wrapped_public_key;
+  std::vector<uint8_t> wrapped_public_key;
   ASSERT_EQ(Status::Success(),
             WrapKey(blink::WebCryptoKeyFormatSpki,
                     public_key,
                     wrapping_key,
                     wrap_algorithm,
                     &wrapped_public_key));
 
-  std::vector<uint8> wrapped_private_key;
+  std::vector<uint8_t> wrapped_private_key;
   ASSERT_EQ(Status::Success(),
             WrapKey(blink::WebCryptoKeyFormatPkcs8,
                     private_key,
                     wrapping_key,
                     wrap_algorithm,
                     &wrapped_private_key));
 
   // Unwrap the key pair.
   blink::WebCryptoAlgorithm rsa_import_algorithm =
       CreateRsaHashedImportAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
@@ skipping 17 matching lines @@
             UnwrapKey(blink::WebCryptoKeyFormatPkcs8,
                       CryptoData(wrapped_private_key),
                       wrapping_key,
                       wrap_algorithm,
                       rsa_import_algorithm,
                       true,
                       0,
                       &unwrapped_private_key));
 
   // Export unwrapped key pair as SPKI + PKCS8
-  std::vector<uint8> unwrapped_public_key_spki;
+  std::vector<uint8_t> unwrapped_public_key_spki;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatSpki,
                       unwrapped_public_key,
                       &unwrapped_public_key_spki));
 
-  std::vector<uint8> unwrapped_private_key_pkcs8;
+  std::vector<uint8_t> unwrapped_private_key_pkcs8;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatPkcs8,
                       unwrapped_private_key,
                       &unwrapped_private_key_pkcs8));
 
   EXPECT_EQ(public_key_spki, unwrapped_public_key_spki);
   EXPECT_EQ(private_key_pkcs8, unwrapped_private_key_pkcs8);
 
   EXPECT_NE(public_key_spki, wrapped_public_key);
   EXPECT_NE(private_key_pkcs8, wrapped_private_key);
 }
 
 }  // namespace webcrypto
 
 }  // namespace content