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

net/android/keystore_unittest.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 <openssl/bn.h>
 #include <openssl/dsa.h>
 #include <openssl/ecdsa.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
 #include <openssl/pem.h>
 #include <openssl/rsa.h>
 #include <openssl/x509.h>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/scoped_java_ref.h"
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "crypto/openssl_util.h"
 #include "jni/AndroidKeyStoreTestUtil_jni.h"
@@ skipping 141 matching lines @@
   }
   return pkey;
 }
 
 // Retrieve a JNI local ref from encoded PKCS#8 data.
 ScopedJava GetPKCS8PrivateKeyJava(PrivateKeyType key_type,
                                   const std::string& pkcs8_key) {
   JNIEnv* env = InitEnv();
   base::android::ScopedJavaLocalRef<jbyteArray> bytes(
       base::android::ToJavaByteArray(
-          env,
-          reinterpret_cast<const uint8*>(pkcs8_key.data()),
+          env, reinterpret_cast<const uint8_t*>(pkcs8_key.data()),
           pkcs8_key.size()));
 
   ScopedJava key(
       Java_AndroidKeyStoreTestUtil_createPrivateKeyFromPKCS8(
           env, key_type, bytes.obj()));
 
   return key;
 }
 
 const char kTestRsaKeyFile[] = "android-test-key-rsa.pem";
@@ skipping 176 matching lines @@
 // |android_key| is a JNI reference to the platform PrivateKey object.
 // |openssl_key| is a pointer to an OpenSSL key object for the exact
 // same key content.
 // |message| is a message.
 // |result| will receive the result.
 void DoKeySigning(jobject android_key,
                   EVP_PKEY* openssl_key,
                   const base::StringPiece& message,
                   std::string* result) {
   // First, get the platform signature.
-  std::vector<uint8> android_signature;
+  std::vector<uint8_t> android_signature;
   ASSERT_TRUE(
       RawSignDigestWithPrivateKey(android_key,
                                   message,
                                   &android_signature));
 
   result->assign(
       reinterpret_cast<const char*>(&android_signature[0]),
       android_signature.size());
 }
 
@@ skipping 32 matching lines @@
   // Convert it to encoded PKCS#8 bytes.
   std::string pkcs8_data;
   ASSERT_TRUE(GetPrivateKeyPkcs8Bytes(pkey, &pkcs8_data));
 
   // Create platform PrivateKey object from it.
   ScopedJava key_java = GetPKCS8PrivateKeyJava(PRIVATE_KEY_TYPE_RSA,
                                                 pkcs8_data);
   ASSERT_FALSE(key_java.is_null());
 
   // Retrieve the corresponding modulus through JNI
-  std::vector<uint8> modulus_java;
+  std::vector<uint8_t> modulus_java;
   ASSERT_TRUE(GetRSAKeyModulus(key_java.obj(), &modulus_java));
 
   // Create an OpenSSL BIGNUM from it.
   crypto::ScopedBIGNUM bn(
       BN_bin2bn(reinterpret_cast<const unsigned char*>(&modulus_java[0]),
                 static_cast<int>(modulus_java.size()),
                 NULL));
   ASSERT_TRUE(bn.get());
 
   // Compare it to the one in the RSA key, they must be identical.
@@ skipping 108 matching lines @@
   std::string signature;
   DoKeySigningWithWrapper(wrapper_key.get(),
                           openssl_key.get(),
                           message,
                           &signature);
   ASSERT_TRUE(VerifyTestECDSASignature(message, signature));
 }
 
 }  // namespace android
 }  // namespace net