Switch to standard integer types in net/.

net/quic/crypto/quic_crypto_client_config.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/crypto/quic_crypto_client_config.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "net/quic/crypto/cert_compressor.h"
@@ skipping 65 matching lines @@
   }
 
   const CryptoHandshakeMessage* scfg = GetServerConfig();
   if (!scfg) {
     // Should be impossible short of cache corruption.
     DCHECK(false);
     RecordInchoateClientHelloReason(SERVER_CONFIG_CORRUPTED);
     return false;
   }
 
-  uint64 expiry_seconds;
+  uint64_t expiry_seconds;
   if (scfg->GetUint64(kEXPY, &expiry_seconds) != QUIC_NO_ERROR) {
     RecordInchoateClientHelloReason(SERVER_CONFIG_INVALID_EXPIRY);
     return false;
   }
   if (now.ToUNIXSeconds() >= expiry_seconds) {
     UMA_HISTOGRAM_CUSTOM_TIMES(
         "Net.QuicClientHelloServerConfig.InvalidDuration",
         base::TimeDelta::FromSeconds(now.ToUNIXSeconds() - expiry_seconds),
         base::TimeDelta::FromMinutes(1), base::TimeDelta::FromDays(20), 50);
     RecordInchoateClientHelloReason(SERVER_CONFIG_EXPIRED);
@@ skipping 55 matching lines @@
     new_scfg = new_scfg_storage.get();
   } else {
     new_scfg = GetServerConfig();
   }
 
   if (!new_scfg) {
     *error_details = "SCFG invalid";
     return SERVER_CONFIG_INVALID;
   }
 
-  uint64 expiry_seconds;
+  uint64_t expiry_seconds;
   if (new_scfg->GetUint64(kEXPY, &expiry_seconds) != QUIC_NO_ERROR) {
     *error_details = "SCFG missing EXPY";
     return SERVER_CONFIG_INVALID_EXPIRY;
   }
 
   if (now.ToUNIXSeconds() >= expiry_seconds) {
     *error_details = "SCFG has expired";
     return SERVER_CONFIG_EXPIRED;
   }
 
@@ skipping 116 matching lines @@
 }
 
 const string& QuicCryptoClientConfig::CachedState::signature() const {
   return server_config_sig_;
 }
 
 bool QuicCryptoClientConfig::CachedState::proof_valid() const {
   return server_config_valid_;
 }
 
-uint64 QuicCryptoClientConfig::CachedState::generation_counter() const {
+uint64_t QuicCryptoClientConfig::CachedState::generation_counter() const {
   return generation_counter_;
 }
 
 const ProofVerifyDetails*
 QuicCryptoClientConfig::CachedState::proof_verify_details() const {
   return proof_verify_details_.get();
 }
 
 void QuicCryptoClientConfig::CachedState::set_source_address_token(
     StringPiece token) {
@@ skipping 134 matching lines @@
     out->SetStringPiece(kCertificateSCTTag, "");
   }
 
   const vector<string>& certs = cached->certs();
   // We save |certs| in the QuicCryptoNegotiatedParameters so that, if the
   // client config is being used for multiple connections, another connection
   // doesn't update the cached certificates and cause us to be unable to
   // process the server's compressed certificate chain.
   out_params->cached_certs = certs;
   if (!certs.empty()) {
-    vector<uint64> hashes;
+    vector<uint64_t> hashes;
     hashes.reserve(certs.size());
     for (vector<string>::const_iterator i = certs.begin(); i != certs.end();
          ++i) {
       hashes.push_back(QuicUtils::FNV1a_64_Hash(i->data(), i->size()));
     }
     out->SetVector(kCCRT, hashes);
   }
 }
 
 QuicErrorCode QuicCryptoClientConfig::FillClientHello(
@@ skipping 489 matching lines @@
   }
 
   // Update canonical version to point at the "most recent" entry.
   canonical_server_map_[suffix_server_id] = server_id;
 
   server_state->InitializeFrom(*canonical_state);
   return true;
 }
 
 }  // namespace net