Switch to standard integer types in net/.

net/quic/crypto/crypto_utils.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/quic/crypto/crypto_utils.h"
 
 #include "crypto/hkdf.h"
 #include "net/base/net_util.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/crypto_protocol.h"
@@ skipping 12 matching lines @@
 
 // static
 void CryptoUtils::GenerateNonce(QuicWallTime now,
                                 QuicRandom* random_generator,
                                 StringPiece orbit,
                                 string* nonce) {
   // a 4-byte timestamp + 28 random bytes.
   nonce->reserve(kNonceSize);
   nonce->resize(kNonceSize);
 
-  uint32 gmt_unix_time = static_cast<uint32>(now.ToUNIXSeconds());
+  uint32_t gmt_unix_time = static_cast<uint32_t>(now.ToUNIXSeconds());
   // The time in the nonce must be encoded in big-endian because the
   // strike-register depends on the nonces being ordered by time.
   (*nonce)[0] = static_cast<char>(gmt_unix_time >> 24);
   (*nonce)[1] = static_cast<char>(gmt_unix_time >> 16);
   (*nonce)[2] = static_cast<char>(gmt_unix_time >> 8);
   (*nonce)[3] = static_cast<char>(gmt_unix_time);
   size_t bytes_written = 4;
 
   if (orbit.size() == 8) {
     memcpy(&(*nonce)[bytes_written], orbit.data(), orbit.size());
@@ skipping 89 matching lines @@
                                        StringPiece context,
                                        size_t result_len,
                                        string* result) {
   for (size_t i = 0; i < label.length(); i++) {
     if (label[i] == '\0') {
       LOG(ERROR) << "ExportKeyingMaterial label may not contain NULs";
       return false;
     }
   }
   // Create HKDF info input: null-terminated label + length-prefixed context
-  if (context.length() >= numeric_limits<uint32>::max()) {
+  if (context.length() >= numeric_limits<uint32_t>::max()) {
     LOG(ERROR) << "Context value longer than 2^32";
     return false;
   }
-  uint32 context_length = static_cast<uint32>(context.length());
+  uint32_t context_length = static_cast<uint32_t>(context.length());
   string info = label.as_string();
   info.push_back('\0');
   info.append(reinterpret_cast<char*>(&context_length), sizeof(context_length));
   info.append(context.data(), context.length());
 
   crypto::HKDF hkdf(subkey_secret, StringPiece() /* no salt */, info,
                     result_len, 0 /* no fixed IV */, 0 /* no subkey secret */);
   hkdf.client_write_key().CopyToString(result);
   return true;
 }
 
 // static
-uint64 CryptoUtils::ComputeLeafCertHash(const std::string& cert) {
+uint64_t CryptoUtils::ComputeLeafCertHash(const std::string& cert) {
   return QuicUtils::FNV1a_64_Hash(cert.data(), cert.size());
 }
 
 QuicErrorCode CryptoUtils::ValidateServerHello(
     const CryptoHandshakeMessage& server_hello,
     const QuicVersionVector& negotiated_versions,
     string* error_details) {
   DCHECK(error_details != nullptr);
 
   if (server_hello.tag() != kSHLO) {
@@ skipping 97 matching lines @@
     RETURN_STRING_LITERAL(INVALID_EXPECTED_LEAF_CERTIFICATE);
     RETURN_STRING_LITERAL(MAX_FAILURE_REASON);
   }
   // Return a default value so that we return this when |reason| doesn't match
   // any HandshakeFailureReason.. This can happen when the message by the peer
   // (attacker) has invalid reason.
   return "INVALID_HANDSHAKE_FAILURE_REASON";
 }
 
 }  // namespace net