Replace uses of uint8 with uint8_t.

content/child/webcrypto/nss/aes_kw_nss.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 <secerr.h>
 
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/nss/aes_key_nss.h"
 #include "content/child/webcrypto/nss/key_nss.h"
 #include "content/child/webcrypto/nss/sym_key_nss.h"
@@ skipping 70 matching lines @@
   if (!NSS_VersionCheck("3.16") && PORT_GetError() == SEC_ERROR_BAD_DATA)
     return Status::OperationError();
 #endif
 
   *unwrapped_key = new_key.Pass();
   return Status::Success();
 }
 
 Status WrapSymKeyAesKw(PK11SymKey* key,
                        PK11SymKey* wrapping_key,
-                       std::vector<uint8>* buffer) {
+                       std::vector<uint8_t>* buffer) {
   // The data size must be at least 16 bytes and a multiple of 8 bytes.
   // RFC 3394 does not specify a maximum allowed data length, but since only
   // keys are being wrapped in this application (which are small), a reasonable
   // max limit is whatever will fit into an unsigned. For the max size test,
   // note that AES Key Wrap always adds 8 bytes to the input data size.
   const unsigned int input_length = PK11_GetKeyLength(key);
   DCHECK_GE(input_length, 16u);
   DCHECK((input_length % 8) == 0);
   if (input_length > UINT_MAX - 8)
     return Status::ErrorDataTooLarge();
@@ skipping 26 matching lines @@
   AesKwCryptoAlgorithmNss()
       : AesAlgorithm(
             CKM_NSS_AES_KEY_WRAP,
             CKF_WRAP | CKF_WRAP,
             blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey,
             "KW") {}
 
   virtual Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& wrapping_key,
                          const CryptoData& data,
-                         std::vector<uint8>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const OVERRIDE {
     if (data.byte_length() < 16)
       return Status::ErrorDataTooSmall();
     if (data.byte_length() % 8)
       return Status::ErrorInvalidAesKwDataLength();
 
     // Due to limitations in the NSS API for the AES-KW algorithm, |data| must
     // be temporarily viewed as a symmetric key to be wrapped (encrypted).
     SECItem data_item = MakeSECItemForBuffer(data);
     crypto::ScopedPK11Slot slot(PK11_GetInternalSlot());
     crypto::ScopedPK11SymKey data_as_sym_key(
         PK11_ImportSymKey(slot.get(),
                           CKK_GENERIC_SECRET,
                           PK11_OriginUnwrap,
                           CKA_SIGN,
                           &data_item,
                           NULL));
     if (!data_as_sym_key)
       return Status::OperationError();
 
     return WrapSymKeyAesKw(
         data_as_sym_key.get(), SymKeyNss::Cast(wrapping_key)->key(), buffer);
   }
 
   virtual Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
                          const blink::WebCryptoKey& wrapping_key,
                          const CryptoData& data,
-                         std::vector<uint8>* buffer) const OVERRIDE {
+                         std::vector<uint8_t>* buffer) const OVERRIDE {
     if (data.byte_length() < 24)
       return Status::ErrorDataTooSmall();
     if (data.byte_length() % 8)
       return Status::ErrorInvalidAesKwDataLength();
 
     // Due to limitations in the NSS API for the AES-KW algorithm, |data| must
     // be temporarily viewed as a symmetric key to be unwrapped (decrypted).
     crypto::ScopedPK11SymKey decrypted;
     Status status = DoUnwrapSymKeyAesKw(data,
                                         SymKeyNss::Cast(wrapping_key)->key(),
@@ skipping 18 matching lines @@
 
 }  // namespace
 
 AlgorithmImplementation* CreatePlatformAesKwImplementation() {
   return new AesKwCryptoAlgorithmNss;
 }
 
 }  // namespace webcrypto
 
 }  // namespace content