Replace uses of uint8 with uint8_t.

content/child/webcrypto/nss/rsa_key_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 "content/child/webcrypto/nss/rsa_key_nss.h"
 
 #include "base/logging.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/jwk.h"
 #include "content/child/webcrypto/nss/key_nss.h"
 #include "content/child/webcrypto/nss/util_nss.h"
 #include "content/child/webcrypto/status.h"
 #include "content/child/webcrypto/webcrypto_util.h"
 #include "crypto/scoped_nss_types.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 
 namespace content {
 
 namespace webcrypto {
 
 namespace {
 
 // Converts a (big-endian) WebCrypto BigInteger, with or without leading zeros,
 // to unsigned long.
-bool BigIntegerToLong(const uint8* data,
+bool BigIntegerToLong(const uint8_t* data,
                       unsigned int data_size,
                       unsigned long* result) {
   // TODO(eroman): Fix handling of empty biginteger. http://crubg.com/373552
   if (data_size == 0)
     return false;
 
   *result = 0;
   for (size_t i = 0; i < data_size; ++i) {
     size_t reverse_i = data_size - i - 1;
 
@@ skipping 266 matching lines @@
                             data.byte_length()};
   templ->push_back(attribute);
 }
 
 void AddOptionalAttribute(CK_ATTRIBUTE_TYPE type,
                           const std::string& data,
                           std::vector<CK_ATTRIBUTE>* templ) {
   AddOptionalAttribute(type, CryptoData(data), templ);
 }
 
-Status ExportKeyPkcs8Nss(SECKEYPrivateKey* key, std::vector<uint8>* buffer) {
+Status ExportKeyPkcs8Nss(SECKEYPrivateKey* key, std::vector<uint8_t>* buffer) {
   if (key->keyType != rsaKey)
     return Status::ErrorUnsupported();
 
 // TODO(rsleevi): Implement OAEP support according to the spec.
 
 #if defined(USE_NSS)
   // PK11_ExportDERPrivateKeyInfo isn't available. Use our fallback code.
   const SECOidTag algorithm = SEC_OID_PKCS1_RSA_ENCRYPTION;
   const int kPrivateKeyInfoVersion = 0;
 
@@ skipping 121 matching lines @@
   crypto::ScopedSECKEYPrivateKey private_key(
       SECKEY_CopyPrivateKey(private_key_tmp.get()));
 
   if (!private_key)
     return Status::OperationError();
 
   blink::WebCryptoKeyAlgorithm key_algorithm;
   if (!CreatePrivateKeyAlgorithm(algorithm, private_key.get(), &key_algorithm))
     return Status::ErrorUnexpected();
 
-  std::vector<uint8> pkcs8_data;
+  std::vector<uint8_t> pkcs8_data;
   status = ExportKeyPkcs8Nss(private_key.get(), &pkcs8_data);
   if (status.IsError())
     return status;
 
   scoped_ptr<PrivateKeyNss> key_handle(
       new PrivateKeyNss(private_key.Pass(), CryptoData(pkcs8_data)));
 
   *key = blink::WebCryptoKey::create(key_handle.release(),
                                      blink::WebCryptoKeyTypePrivate,
                                      extractable,
                                      key_algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
-Status ExportKeySpkiNss(SECKEYPublicKey* key, std::vector<uint8>* buffer) {
+Status ExportKeySpkiNss(SECKEYPublicKey* key, std::vector<uint8_t>* buffer) {
   const crypto::ScopedSECItem spki_der(
       SECKEY_EncodeDERSubjectPublicKeyInfo(key));
   if (!spki_der)
     return Status::OperationError();
 
   buffer->assign(spki_der->data, spki_der->data + spki_der->len);
   return Status::Success();
 }
 
 Status ImportRsaPublicKey(const blink::WebCryptoAlgorithm& algorithm,
@@ skipping 49 matching lines @@
   // Import the DER-encoded public key to create an RSA SECKEYPublicKey.
   crypto::ScopedSECKEYPublicKey pubkey(
       SECKEY_ImportDERPublicKey(pubkey_der.get(), CKK_RSA));
   if (!pubkey)
     return Status::OperationError();
 
   blink::WebCryptoKeyAlgorithm key_algorithm;
   if (!CreatePublicKeyAlgorithm(algorithm, pubkey.get(), &key_algorithm))
     return Status::ErrorUnexpected();
 
-  std::vector<uint8> spki_data;
+  std::vector<uint8_t> spki_data;
   Status status = ExportKeySpkiNss(pubkey.get(), &spki_data);
   if (status.IsError())
     return status;
 
   scoped_ptr<PublicKeyNss> key_handle(
       new PublicKeyNss(pubkey.Pass(), CryptoData(spki_data)));
 
   *key = blink::WebCryptoKey::create(key_handle.release(),
                                      blink::WebCryptoKeyTypePublic,
                                      extractable,
@@ skipping 71 matching lines @@
                                       generate_flags_,
                                       operation_flags_mask,
                                       NULL));
   if (!scoped_sec_private_key)
     return Status::OperationError();
 
   blink::WebCryptoKeyAlgorithm key_algorithm;
   if (!CreatePublicKeyAlgorithm(algorithm, sec_public_key, &key_algorithm))
     return Status::ErrorUnexpected();
 
-  std::vector<uint8> spki_data;
+  std::vector<uint8_t> spki_data;
   Status status = ExportKeySpkiNss(sec_public_key, &spki_data);
   if (status.IsError())
     return status;
 
   scoped_ptr<PublicKeyNss> public_key_handle(new PublicKeyNss(
       crypto::ScopedSECKEYPublicKey(sec_public_key), CryptoData(spki_data)));
 
-  std::vector<uint8> pkcs8_data;
+  std::vector<uint8_t> pkcs8_data;
   status = ExportKeyPkcs8Nss(scoped_sec_private_key.get(), &pkcs8_data);
   if (status.IsError())
     return status;
 
   scoped_ptr<PrivateKeyNss> private_key_handle(
       new PrivateKeyNss(scoped_sec_private_key.Pass(), CryptoData(pkcs8_data)));
 
   *public_key = blink::WebCryptoKey::create(public_key_handle.release(),
                                             blink::WebCryptoKeyTypePublic,
                                             true,
@@ skipping 60 matching lines @@
   const KeyType sec_key_type = SECKEY_GetPrivateKeyType(private_key.get());
   if (sec_key_type != rsaKey)
     return Status::DataError();
 
   blink::WebCryptoKeyAlgorithm key_algorithm;
   if (!CreateRsaHashedPrivateKeyAlgorithm(
           algorithm, private_key.get(), &key_algorithm))
     return Status::ErrorUnexpected();
 
   // TODO(eroman): This is probably going to be the same as the input.
-  std::vector<uint8> pkcs8_data;
+  std::vector<uint8_t> pkcs8_data;
   status = ExportKeyPkcs8Nss(private_key.get(), &pkcs8_data);
   if (status.IsError())
     return status;
 
   scoped_ptr<PrivateKeyNss> key_handle(
       new PrivateKeyNss(private_key.Pass(), CryptoData(pkcs8_data)));
 
   *key = blink::WebCryptoKey::create(key_handle.release(),
                                      blink::WebCryptoKeyTypePrivate,
                                      extractable,
@@ skipping 32 matching lines @@
   const KeyType sec_key_type = SECKEY_GetPublicKeyType(sec_public_key.get());
   if (sec_key_type != rsaKey)
     return Status::DataError();
 
   blink::WebCryptoKeyAlgorithm key_algorithm;
   if (!CreateRsaHashedPublicKeyAlgorithm(
           algorithm, sec_public_key.get(), &key_algorithm))
     return Status::ErrorUnexpected();
 
   // TODO(eroman): This is probably going to be the same as the input.
-  std::vector<uint8> spki_data;
+  std::vector<uint8_t> spki_data;
   status = ExportKeySpkiNss(sec_public_key.get(), &spki_data);
   if (status.IsError())
     return status;
 
   scoped_ptr<PublicKeyNss> key_handle(
       new PublicKeyNss(sec_public_key.Pass(), CryptoData(spki_data)));
 
   *key = blink::WebCryptoKey::create(key_handle.release(),
                                      blink::WebCryptoKeyTypePublic,
                                      extractable,
                                      key_algorithm,
                                      usage_mask);
 
   return Status::Success();
 }
 
 Status RsaHashedAlgorithm::ExportKeyPkcs8(const blink::WebCryptoKey& key,
-                                          std::vector<uint8>* buffer) const {
+                                          std::vector<uint8_t>* buffer) const {
   if (key.type() != blink::WebCryptoKeyTypePrivate)
     return Status::ErrorUnexpectedKeyType();
   *buffer = PrivateKeyNss::Cast(key)->pkcs8_data();
   return Status::Success();
 }
 
 Status RsaHashedAlgorithm::ExportKeySpki(const blink::WebCryptoKey& key,
-                                         std::vector<uint8>* buffer) const {
+                                         std::vector<uint8_t>* buffer) const {
   if (key.type() != blink::WebCryptoKeyTypePublic)
     return Status::ErrorUnexpectedKeyType();
   *buffer = PublicKeyNss::Cast(key)->spki_data();
   return Status::Success();
 }
 
 Status RsaHashedAlgorithm::ImportKeyJwk(
     const CryptoData& key_data,
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
@@ skipping 22 matching lines @@
              ? ImportRsaPrivateKey(algorithm, extractable, usage_mask, jwk, key)
              : ImportRsaPublicKey(algorithm,
                                   extractable,
                                   usage_mask,
                                   CryptoData(jwk.n),
                                   CryptoData(jwk.e),
                                   key);
 }
 
 Status RsaHashedAlgorithm::ExportKeyJwk(const blink::WebCryptoKey& key,
-                                        std::vector<uint8>* buffer) const {
+                                        std::vector<uint8_t>* buffer) const {
   const char* jwk_algorithm =
       GetJwkAlgorithm(key.algorithm().rsaHashedParams()->hash().id());
 
   if (!jwk_algorithm)
     return Status::ErrorUnexpected();
 
   switch (key.type()) {
     case blink::WebCryptoKeyTypePublic: {
       SECKEYPublicKey* nss_key = PublicKeyNss::Cast(key)->key();
       if (nss_key->keyType != rsaKey)
@@ skipping 33 matching lines @@
       return Status::Success();
     }
     default:
       return Status::ErrorUnexpected();
   }
 }
 
 }  // namespace webcrypto
 
 }  // namespace content