Switch to standard integer types in crypto/.

crypto/ec_private_key_nss.cc

 // Copyright (c) 2012 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 "crypto/ec_private_key.h"
 
 extern "C" {
 // Work around NSS missing SEC_BEGIN_PROTOS in secmodt.h.  This must come before
 // other NSS headers.
 #include <secmodt.h>
 }
 
 #include <cryptohi.h>
 #include <keyhi.h>
 #include <pk11pub.h>
 #include <secmod.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "crypto/nss_util.h"
 #include "crypto/nss_util_internal.h"
 #include "crypto/scoped_nss_types.h"
 #include "crypto/third_party/nss/chromium-nss.h"
 
 namespace {
 
 // Copied from rsa_private_key_nss.cc.
 static bool ReadAttribute(SECKEYPrivateKey* key,
                           CK_ATTRIBUTE_TYPE type,
-                          std::vector<uint8>* output) {
+                          std::vector<uint8_t>* output) {
   SECItem item;
   SECStatus rv;
   rv = PK11_ReadRawAttribute(PK11_TypePrivKey, key, type, &item);
   if (rv != SECSuccess) {
     DLOG(ERROR) << "PK11_ReadRawAttribute: " << PORT_GetError();
     return false;
   }
 
   output->assign(item.data, item.data + item.len);
   SECITEM_FreeItem(&item, PR_FALSE);
@@ skipping 54 matching lines @@
     return nullptr;
   }
   CHECK_EQ(ecKey, SECKEY_GetPublicKeyType(result->public_key_));
 
   return result.release();
 }
 
 // static
 ECPrivateKey* ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
     const std::string& password,
-    const std::vector<uint8>& encrypted_private_key_info,
-    const std::vector<uint8>& subject_public_key_info) {
+    const std::vector<uint8_t>& encrypted_private_key_info,
+    const std::vector<uint8_t>& subject_public_key_info) {
   EnsureNSSInit();
 
   ScopedPK11Slot slot(PK11_GetInternalSlot());
   if (!slot)
     return nullptr;
 
   scoped_ptr<ECPrivateKey> result(new ECPrivateKey);
 
   SECItem encoded_spki = {
     siBuffer,
@@ skipping 25 matching lines @@
     return result.release();
   }
 
   return nullptr;
 }
 
 // static
 bool ECPrivateKey::ImportFromEncryptedPrivateKeyInfo(
     PK11SlotInfo* slot,
     const std::string& password,
-    const uint8* encrypted_private_key_info,
+    const uint8_t* encrypted_private_key_info,
     size_t encrypted_private_key_info_len,
     CERTSubjectPublicKeyInfo* decoded_spki,
     bool permanent,
     bool sensitive,
     SECKEYPrivateKey** key,
     SECKEYPublicKey** public_key) {
   if (!slot)
     return false;
 
   *public_key = SECKEY_ExtractPublicKey(decoded_spki);
@@ skipping 67 matching lines @@
       return NULL;
   }
   if (public_key_) {
     copy->public_key_ = SECKEY_CopyPublicKey(public_key_);
     if (!copy->public_key_)
       return NULL;
   }
   return copy.release();
 }
 
-bool ECPrivateKey::ExportEncryptedPrivateKey(
-    const std::string& password,
-    int iterations,
-    std::vector<uint8>* output) {
+bool ECPrivateKey::ExportEncryptedPrivateKey(const std::string& password,
+                                             int iterations,
+                                             std::vector<uint8_t>* output) {
   // We export as an EncryptedPrivateKeyInfo bundle instead of a plain PKCS #8
   // PrivateKeyInfo because PK11_ImportDERPrivateKeyInfoAndReturnKey doesn't
   // support EC keys.
   // https://bugzilla.mozilla.org/show_bug.cgi?id=327773
   SECItem password_item = {
     siBuffer,
     reinterpret_cast<unsigned char*>(const_cast<char*>(password.data())),
     static_cast<unsigned>(password.size())
   };
 
@@ skipping 21 matching lines @@
   if (!encoded_item) {
     DLOG(ERROR) << "SEC_ASN1EncodeItem: " << PORT_GetError();
     return false;
   }
 
   output->assign(der_key.data, der_key.data + der_key.len);
 
   return true;
 }
 
-bool ECPrivateKey::ExportPublicKey(std::vector<uint8>* output) {
+bool ECPrivateKey::ExportPublicKey(std::vector<uint8_t>* output) {
   ScopedSECItem der_pubkey(
       SECKEY_EncodeDERSubjectPublicKeyInfo(public_key_));
   if (!der_pubkey.get()) {
     return false;
   }
 
   output->assign(der_pubkey->data, der_pubkey->data + der_pubkey->len);
   return true;
 }
 
 bool ECPrivateKey::ExportRawPublicKey(std::string* output) {
   // public_key_->u.ec.publicValue is an ANSI X9.62 public key which, for
   // a P-256 key, is 0x04 (meaning uncompressed) followed by the x and y field
   // elements as 32-byte, big-endian numbers.
   static const unsigned int kExpectedKeyLength = 65;
 
   CHECK_EQ(ecKey, SECKEY_GetPublicKeyType(public_key_));
   const unsigned char* const data = public_key_->u.ec.publicValue.data;
   const unsigned int len = public_key_->u.ec.publicValue.len;
   if (len != kExpectedKeyLength || data[0] != 0x04)
     return false;
 
   output->assign(reinterpret_cast<const char*>(data + 1),
                  kExpectedKeyLength - 1);
   return true;
 }
 
-bool ECPrivateKey::ExportValue(std::vector<uint8>* output) {
+bool ECPrivateKey::ExportValue(std::vector<uint8_t>* output) {
   return ReadAttribute(key_, CKA_VALUE, output);
 }
 
-bool ECPrivateKey::ExportECParams(std::vector<uint8>* output) {
+bool ECPrivateKey::ExportECParams(std::vector<uint8_t>* output) {
   return ReadAttribute(key_, CKA_EC_PARAMS, output);
 }
 
 ECPrivateKey::ECPrivateKey() : key_(NULL), public_key_(NULL) {}
 
 }  // namespace crypto