Switch to standard integer types in net/.

net/quic/test_tools/crypto_test_utils_openssl.cc

 // Copyright 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/quic/test_tools/crypto_test_utils.h"
 
 #include <openssl/bn.h>
 #include <openssl/ec.h>
 #include <openssl/ecdsa.h>
 #include <openssl/evp.h>
@@ skipping 31 matching lines @@
                      strlen(ChannelIDVerifier::kContextStr) + 1);
     EVP_DigestUpdate(md_ctx.get(), ChannelIDVerifier::kClientToServerStr,
                      strlen(ChannelIDVerifier::kClientToServerStr) + 1);
     EVP_DigestUpdate(md_ctx.get(), signed_data.data(), signed_data.size());
 
     size_t sig_len;
     if (!EVP_DigestSignFinal(md_ctx.get(), nullptr, &sig_len)) {
       return false;
     }
 
-    scoped_ptr<uint8[]> der_sig(new uint8[sig_len]);
+    scoped_ptr<uint8_t[]> der_sig(new uint8_t[sig_len]);
     if (!EVP_DigestSignFinal(md_ctx.get(), der_sig.get(), &sig_len)) {
       return false;
     }
 
-    uint8* derp = der_sig.get();
+    uint8_t* derp = der_sig.get();
     crypto::ScopedECDSA_SIG sig(
-        d2i_ECDSA_SIG(nullptr, const_cast<const uint8**>(&derp), sig_len));
+        d2i_ECDSA_SIG(nullptr, const_cast<const uint8_t**>(&derp), sig_len));
     if (sig.get() == nullptr) {
       return false;
     }
 
     // The signature consists of a pair of 32-byte numbers.
     static const size_t kSignatureLength = 32 * 2;
-    scoped_ptr<uint8[]> signature(new uint8[kSignatureLength]);
+    scoped_ptr<uint8_t[]> signature(new uint8_t[kSignatureLength]);
     if (!BN_bn2bin_padded(&signature[0], 32, sig->r) ||
         !BN_bn2bin_padded(&signature[32], 32, sig->s)) {
       return false;
     }
 
     *out_signature =
         string(reinterpret_cast<char*>(signature.get()), kSignatureLength);
 
     return true;
   }
 
   string SerializeKey() const override {
     // i2d_PublicKey will produce 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 int kExpectedKeyLength = 65;
 
     int len = i2d_PublicKey(ecdsa_key_.get(), nullptr);
     if (len != kExpectedKeyLength) {
       return "";
     }
 
-    uint8 buf[kExpectedKeyLength];
-    uint8* derp = buf;
+    uint8_t buf[kExpectedKeyLength];
+    uint8_t* derp = buf;
     i2d_PublicKey(ecdsa_key_.get(), &derp);
 
     return string(reinterpret_cast<char*>(buf + 1), kExpectedKeyLength - 1);
   }
 
  private:
   crypto::ScopedEVP_PKEY ecdsa_key_;
 };
 
 class TestChannelIDSource : public ChannelIDSource {
@@ skipping 55 matching lines @@
 };
 
 // static
 ChannelIDSource* CryptoTestUtils::ChannelIDSourceForTesting() {
   return new TestChannelIDSource();
 }
 
 }  // namespace test
 
 }  // namespace net