Switch to standard integer types in net/.

net/quic/crypto/crypto_server_test.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 <ostream>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/strings/string_number_conversions.h"
 #include "crypto/secure_hash.h"
 #include "net/quic/crypto/cert_compressor.h"
 #include "net/quic/crypto/common_cert_set.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/crypto_server_config_protobuf.h"
 #include "net/quic/crypto/crypto_utils.h"
 #include "net/quic/crypto/proof_source.h"
 #include "net/quic/crypto/quic_crypto_server_config.h"
 #include "net/quic/crypto/quic_random.h"
@@ skipping 298 matching lines @@
     CryptoUtils::GenerateNonce(
         clock_.WallNow(), rand_,
         StringPiece(reinterpret_cast<const char*>(orbit_), sizeof(orbit_)),
         &nonce);
     return nonce;
   }
 
   void CheckRejectReasons(
       const HandshakeFailureReason* expected_handshake_failures,
       size_t expected_count) {
-    const uint32* reject_reasons;
+    const uint32_t* reject_reasons;
     size_t num_reject_reasons;
-    static_assert(sizeof(QuicTag) == sizeof(uint32), "header_out_of_sync");
+    static_assert(sizeof(QuicTag) == sizeof(uint32_t), "header_out_of_sync");
     QuicErrorCode error_code =
         out_.GetTaglist(kRREJ, &reject_reasons, &num_reject_reasons);
     ASSERT_EQ(QUIC_NO_ERROR, error_code);
 
     if (FLAGS_use_early_return_when_verifying_chlo) {
       EXPECT_EQ(1u, num_reject_reasons);
     } else {
       EXPECT_EQ(expected_count, num_reject_reasons);
     }
     for (size_t i = 0; i < num_reject_reasons; ++i) {
@@ skipping 38 matching lines @@
     string cert_sct;
     scoped_ptr<ProofSource> proof_source(
         CryptoTestUtils::ProofSourceForTesting());
     if (!proof_source->GetProof(server_ip, "", "", false, &certs, &sig,
                                 &cert_sct) ||
         certs->empty()) {
       return "#0100000000000000";
     }
 
     std::ostringstream xlct_stream;
-    uint64 xlct =
+    uint64_t xlct =
         QuicUtils::FNV1a_64_Hash(certs->at(0).c_str(), certs->at(0).length());
     return "#" + base::HexEncode(reinterpret_cast<char*>(&xlct), sizeof(xlct));
   }
 
  protected:
   QuicRandom* const rand_;
   MockRandom rand_for_id_generation_;
   MockClock clock_;
   IPEndPoint client_address_;
   QuicVersionVector supported_versions_;
   QuicVersion client_version_;
   string client_version_string_;
   QuicCryptoServerConfig config_;
   QuicCryptoServerConfig::ConfigOptions config_options_;
   QuicCryptoNegotiatedParameters params_;
   QuicCryptoProof crypto_proof_;
   CryptoHandshakeMessage out_;
-  uint8 orbit_[kOrbitSize];
+  uint8_t orbit_[kOrbitSize];
   bool use_stateless_rejects_;
 
   // These strings contain hex escaped values from the server suitable for using
   // when constructing client hello messages.
   string nonce_hex_, pub_hex_, srct_hex_, scid_hex_;
   scoped_ptr<CryptoHandshakeMessage> server_config_;
 };
 
 // Run all CryptoServerTest with both values of
 // FLAGS_use_early_return_when_verifying_chlo.
@@ skipping 588 matching lines @@
   // Need to take a copy of |scid| has we're about to call |Erase|.
   const string scid_str(scid.as_string());
 
   scfg->Erase(kSCID);
   scfg->MarkDirty();
   const QuicData& serialized(scfg->GetSerialized());
 
   scoped_ptr<crypto::SecureHash> hash(
       crypto::SecureHash::Create(crypto::SecureHash::SHA256));
   hash->Update(serialized.data(), serialized.length());
-  uint8 digest[16];
+  uint8_t digest[16];
   hash->Finish(digest, sizeof(digest));
 
   ASSERT_EQ(scid.size(), sizeof(digest));
   EXPECT_EQ(0, memcmp(digest, scid_str.c_str(), sizeof(digest)));
 }
 
 class CryptoServerTestNoConfig : public CryptoServerTest {
  public:
   void SetUp() override {
     // Deliberately don't add a config so that we can test this situation.
@@ skipping 74 matching lines @@
 
 class AsyncStrikeServerVerificationTest : public CryptoServerTest {
  protected:
   AsyncStrikeServerVerificationTest() {}
 
   void SetUp() override {
     const string kOrbit = "12345678";
     config_options_.orbit = kOrbit;
     strike_register_client_ = new DelayedVerifyStrikeRegisterClient(
         10000,  // strike_register_max_entries
-        static_cast<uint32>(clock_.WallNow().ToUNIXSeconds()),
+        static_cast<uint32_t>(clock_.WallNow().ToUNIXSeconds()),
         60,  // strike_register_window_secs
-        reinterpret_cast<const uint8*>(kOrbit.c_str()),
+        reinterpret_cast<const uint8_t*>(kOrbit.c_str()),
         StrikeRegister::NO_STARTUP_PERIOD_NEEDED);
     config_.SetStrikeRegisterClient(strike_register_client_);
     CryptoServerTest::SetUp();
     strike_register_client_->StartDelayingVerification();
   }
 
   DelayedVerifyStrikeRegisterClient* strike_register_client_;
 };
 
 TEST_P(AsyncStrikeServerVerificationTest, AsyncReplayProtection) {
@@ skipping 42 matching lines @@
 
   strike_register_client_->RunPendingVerifications();
   ASSERT_TRUE(called);
   EXPECT_EQ(0, strike_register_client_->PendingVerifications());
   // The message should be rejected now.
   CheckRejectTag();
 }
 
 }  // namespace test
 }  // namespace net