Use the exact-width integer types defined in <stdint.h> rather than

net/android/keystore_openssl.cc

 // Copyright (c) 2013 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 "net/android/keystore_openssl.h"
 
 #include <jni.h>
 #include <openssl/bn.h>
 #include <openssl/dsa.h>
 #include <openssl/ec.h>
 #include <openssl/engine.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
 #include <openssl/rsa.h>
 #include <openssl/x509.h>
+#include <stdint.h>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
-#include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "crypto/openssl_util.h"
 #include "net/android/keystore.h"
 #include "net/android/legacy_openssl.h"
 #include "net/ssl/scoped_openssl_types.h"
 #include "net/ssl/ssl_client_cert_type.h"
 
 // IMPORTANT NOTE: The following code will currently only work when used
 // to implement client certificate support with OpenSSL. That's because
@@ skipping 114 matching lines @@
   const int ec_key_index_;
   ENGINE* const engine_;
 };
 
 base::LazyInstance<BoringSSLEngine>::Leaky global_boringssl_engine =
     LAZY_INSTANCE_INITIALIZER;
 
 
 // VectorBignumSize returns the number of bytes needed to represent the bignum
 // given in |v|, i.e. the length of |v| less any leading zero bytes.
-size_t VectorBignumSize(const std::vector<uint8>& v) {
+size_t VectorBignumSize(const std::vector<uint8_t>& v) {
   size_t size = v.size();
   // Ignore any leading zero bytes.
   for (size_t i = 0; i < v.size() && v[i] == 0; i++) {
     size--;
   }
   return size;
 }
 
 KeyExData* RsaGetExData(const RSA* rsa) {
   return reinterpret_cast<KeyExData*>(
@@ skipping 59 matching lines @@
       // through Java, it's difficult to get a handle on a system OpenSSL
       // function; dlopen loads a second copy.)
       OPENSSL_PUT_ERROR(RSA, sign_raw, ERR_R_INTERNAL_ERROR);
       return 0;
     }
     *out_len = ret;
     return 1;
   }
 
   base::StringPiece from_piece(reinterpret_cast<const char*>(in), in_len);
-  std::vector<uint8> result;
+  std::vector<uint8_t> result;
   // For RSA keys, this function behaves as RSA_private_encrypt with
   // PKCS#1 padding.
   if (!RawSignDigestWithPrivateKey(ex_data->private_key, from_piece, &result)) {
     LOG(WARNING) << "Could not sign message in RsaMethodSignRaw!";
     OPENSSL_PUT_ERROR(RSA, sign_raw, ERR_R_INTERNAL_ERROR);
     return 0;
   }
 
   size_t expected_size = static_cast<size_t>(RSA_size(rsa));
   if (result.size() > expected_size) {
@@ skipping 81 matching lines @@
   crypto::ScopedRSA rsa(
       RSA_new_method(global_boringssl_engine.Get().engine()));
 
   ScopedJavaGlobalRef<jobject> global_key;
   global_key.Reset(NULL, private_key);
   if (global_key.is_null()) {
     LOG(ERROR) << "Could not create global JNI reference";
     return crypto::ScopedEVP_PKEY();
   }
 
-  std::vector<uint8> modulus;
+  std::vector<uint8_t> modulus;
   if (!GetRSAKeyModulus(private_key, &modulus)) {
     LOG(ERROR) << "Failed to get private key modulus";
     return crypto::ScopedEVP_PKEY();
   }
 
   KeyExData* ex_data = new KeyExData;
   ex_data->private_key = global_key.Release();
   ex_data->legacy_rsa = legacy_rsa;
   ex_data->cached_size = VectorBignumSize(modulus);
   RSA_set_ex_data(
@@ skipping 124 matching lines @@
                     uint8_t* sig,
                     unsigned int* sig_len,
                     EC_KEY* ec_key) {
   // Retrieve private key JNI reference.
   jobject private_key = EcKeyGetKey(ec_key);
   if (!private_key) {
     LOG(WARNING) << "Null JNI reference passed to EcdsaMethodSign!";
     return 0;
   }
   // Sign message with it through JNI.
-  std::vector<uint8> signature;
+  std::vector<uint8_t> signature;
   base::StringPiece digest_sp(reinterpret_cast<const char*>(digest),
                               digest_len);
   if (!RawSignDigestWithPrivateKey(private_key, digest_sp, &signature)) {
     LOG(WARNING) << "Could not sign message in EcdsaMethodSign!";
     return 0;
   }
 
   // Note: With ECDSA, the actual signature may be smaller than
   // ECDSA_size().
   size_t max_expected_size = ECDSA_size(ec_key);
@@ skipping 30 matching lines @@
   crypto::ScopedEC_KEY ec_key(
       EC_KEY_new_method(global_boringssl_engine.Get().engine()));
 
   ScopedJavaGlobalRef<jobject> global_key;
   global_key.Reset(NULL, private_key);
   if (global_key.is_null()) {
     LOG(ERROR) << "Can't create global JNI reference";
     return crypto::ScopedEVP_PKEY();
   }
 
-  std::vector<uint8> order;
+  std::vector<uint8_t> order;
   if (!GetECKeyOrder(private_key, &order)) {
     LOG(ERROR) << "Can't extract order parameter from EC private key";
     return crypto::ScopedEVP_PKEY();
   }
 
   KeyExData* ex_data = new KeyExData;
   ex_data->private_key = global_key.Release();
   ex_data->legacy_rsa = NULL;
   ex_data->cached_size = VectorBignumSize(order);
 
@@ skipping 35 matching lines @@
       return GetEcdsaPkeyWrapper(private_key);
     default:
       LOG(WARNING)
           << "GetOpenSSLPrivateKeyWrapper() called with invalid key type";
       return nullptr;
   }
 }
 
 }  // namespace android
 }  // namespace net