Switch to standard integer types in net/.

net/quic/quic_connection_test.cc

 // Copyright (c) 2012 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/quic_connection.h"
 
 #include <ostream>
 
-#include "base/basictypes.h"
 #include "base/bind.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "net/base/net_errors.h"
 #include "net/quic/congestion_control/loss_detection_interface.h"
 #include "net/quic/congestion_control/send_algorithm_interface.h"
 #include "net/quic/crypto/null_encrypter.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_protocol.h"
@@ skipping 44 matching lines @@
 const QuicPacketEntropyHash kTestEntropyHash = 76;
 
 const int kDefaultRetransmissionTimeMs = 500;
 
 const IPEndPoint kPeerAddress = IPEndPoint(Loopback6(), /*port=*/12345);
 const IPEndPoint kSelfAddress = IPEndPoint(Loopback6(), /*port=*/443);
 
 // TaggingEncrypter appends kTagSize bytes of |tag| to the end of each message.
 class TaggingEncrypter : public QuicEncrypter {
  public:
-  explicit TaggingEncrypter(uint8 tag) : tag_(tag) {}
+  explicit TaggingEncrypter(uint8_t tag) : tag_(tag) {}
 
   ~TaggingEncrypter() override {}
 
   // QuicEncrypter interface.
   bool SetKey(StringPiece key) override { return true; }
 
   bool SetNoncePrefix(StringPiece nonce_prefix) override { return true; }
 
   bool EncryptPacket(QuicPacketNumber packet_number,
                      StringPiece associated_data,
@@ skipping 25 matching lines @@
 
   StringPiece GetKey() const override { return StringPiece(); }
 
   StringPiece GetNoncePrefix() const override { return StringPiece(); }
 
  private:
   enum {
     kTagSize = 12,
   };
 
-  const uint8 tag_;
+  const uint8_t tag_;
 
   DISALLOW_COPY_AND_ASSIGN(TaggingEncrypter);
 };
 
 // TaggingDecrypter ensures that the final kTagSize bytes of the message all
 // have the same value and then removes them.
 class TaggingDecrypter : public QuicDecrypter {
  public:
   ~TaggingDecrypter() override {}
 
@@ skipping 16 matching lines @@
     }
     *output_length = ciphertext.size() - kTagSize;
     memcpy(output, ciphertext.data(), *output_length);
     return true;
   }
 
   StringPiece GetKey() const override { return StringPiece(); }
   StringPiece GetNoncePrefix() const override { return StringPiece(); }
   const char* cipher_name() const override { return "Tagging"; }
   // Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
-  uint32 cipher_id() const override { return 0xFFFFFFF0; }
+  uint32_t cipher_id() const override { return 0xFFFFFFF0; }
 
  protected:
-  virtual uint8 GetTag(StringPiece ciphertext) {
+  virtual uint8_t GetTag(StringPiece ciphertext) {
     return ciphertext.data()[ciphertext.size() - 1];
   }
 
  private:
   enum {
     kTagSize = 12,
   };
 
-  bool CheckTag(StringPiece ciphertext, uint8 tag) {
+  bool CheckTag(StringPiece ciphertext, uint8_t tag) {
     for (size_t i = ciphertext.size() - kTagSize; i < ciphertext.size(); i++) {
       if (ciphertext.data()[i] != tag) {
         return false;
       }
     }
 
     return true;
   }
 };
 
 // StringTaggingDecrypter ensures that the final kTagSize bytes of the message
 // match the expected value.
 class StrictTaggingDecrypter : public TaggingDecrypter {
  public:
-  explicit StrictTaggingDecrypter(uint8 tag) : tag_(tag) {}
+  explicit StrictTaggingDecrypter(uint8_t tag) : tag_(tag) {}
   ~StrictTaggingDecrypter() override {}
 
   // TaggingQuicDecrypter
-  uint8 GetTag(StringPiece ciphertext) override { return tag_; }
+  uint8_t GetTag(StringPiece ciphertext) override { return tag_; }
 
   const char* cipher_name() const override { return "StrictTagging"; }
   // Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
-  uint32 cipher_id() const override { return 0xFFFFFFF1; }
+  uint32_t cipher_id() const override { return 0xFFFFFFF1; }
 
  private:
-  const uint8 tag_;
+  const uint8_t tag_;
 };
 
 class TestConnectionHelper : public QuicConnectionHelperInterface {
  public:
   class TestAlarm : public QuicAlarm {
    public:
     explicit TestAlarm(QuicAlarm::Delegate* delegate) : QuicAlarm(delegate) {}
 
     void SetImpl() override {}
     void CancelImpl() override {}
@@ skipping 142 matching lines @@
   void set_perspective(Perspective perspective) {
     // We invert perspective here, because the framer needs to parse packets
     // we send.
     perspective = perspective == Perspective::IS_CLIENT
                       ? Perspective::IS_SERVER
                       : Perspective::IS_CLIENT;
     QuicFramerPeer::SetPerspective(framer_.framer(), perspective);
   }
 
   // final_bytes_of_last_packet_ returns the last four bytes of the previous
-  // packet as a little-endian, uint32. This is intended to be used with a
+  // packet as a little-endian, uint32_t. This is intended to be used with a
   // TaggingEncrypter so that tests can determine which encrypter was used for
   // a given packet.
-  uint32 final_bytes_of_last_packet() { return final_bytes_of_last_packet_; }
+  uint32_t final_bytes_of_last_packet() { return final_bytes_of_last_packet_; }
 
   // Returns the final bytes of the second to last packet.
-  uint32 final_bytes_of_previous_packet() {
+  uint32_t final_bytes_of_previous_packet() {
     return final_bytes_of_previous_packet_;
   }
 
   void use_tagging_decrypter() { use_tagging_decrypter_ = true; }
 
-  uint32 packets_write_attempts() { return packets_write_attempts_; }
+  uint32_t packets_write_attempts() { return packets_write_attempts_; }
 
   void Reset() { framer_.Reset(); }
 
   void SetSupportedVersions(const QuicVersionVector& versions) {
     framer_.SetSupportedVersions(versions);
   }
 
   void set_max_packet_size(QuicByteCount max_packet_size) {
     max_packet_size_ = max_packet_size;
   }
 
  private:
   QuicVersion version_;
   SimpleQuicFramer framer_;
   size_t last_packet_size_;
   bool write_blocked_;
   bool write_should_fail_;
   bool block_on_next_write_;
   bool is_write_blocked_data_buffered_;
-  uint32 final_bytes_of_last_packet_;
-  uint32 final_bytes_of_previous_packet_;
+  uint32_t final_bytes_of_last_packet_;
+  uint32_t final_bytes_of_previous_packet_;
   bool use_tagging_decrypter_;
-  uint32 packets_write_attempts_;
+  uint32_t packets_write_attempts_;
   MockClock* clock_;
   // If non-zero, the clock will pause during WritePacket for this amount of
   // time.
   QuicTime::Delta write_pause_time_delta_;
   QuicByteCount max_packet_size_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPacketWriter);
 };
 
 class TestConnection : public QuicConnection {
@@ skipping 2880 matching lines @@
 
   // Set a forward-secure encrypter but do not make it the default, and
   // verify that it is not yet used.
   connection_.SetEncrypter(ENCRYPTION_FORWARD_SECURE,
                            new TaggingEncrypter(0x03));
   SendAckPacketToPeer();
   EXPECT_EQ(0x02020202u, writer_->final_bytes_of_last_packet());
 
   // Now send a packet "Far enough" after the encrypter was set and verify that
   // the forward-secure encrypter is now used.
-  for (uint64 i = 0; i < 3 * congestion_window - 1; ++i) {
+  for (uint64_t i = 0; i < 3 * congestion_window - 1; ++i) {
     EXPECT_EQ(0x02020202u, writer_->final_bytes_of_last_packet());
     SendAckPacketToPeer();
   }
   EXPECT_EQ(0x03030303u, writer_->final_bytes_of_last_packet());
 }
 
 TEST_P(QuicConnectionTest, BufferNonDecryptablePackets) {
   // SetFromConfig is always called after construction from InitializeSession.
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
   QuicConfig config;
   connection_.SetFromConfig(config);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   use_tagging_decrypter();
 
-  const uint8 tag = 0x07;
+  const uint8_t tag = 0x07;
   framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
 
   // Process an encrypted packet which can not yet be decrypted which should
   // result in the packet being buffered.
   ProcessDataPacketAtLevel(1, 0, kEntropyFlag, ENCRYPTION_INITIAL);
 
   // Transition to the new encryption state and process another encrypted packet
   // which should result in the original packet being processed.
   connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
   connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
   connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(2);
   ProcessDataPacketAtLevel(2, 0, kEntropyFlag, ENCRYPTION_INITIAL);
 
   // Finally, process a third packet and note that we do not reprocess the
   // buffered packet.
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
   ProcessDataPacketAtLevel(3, 0, kEntropyFlag, ENCRYPTION_INITIAL);
 }
 
 TEST_P(QuicConnectionTest, ProcessBufferedFECGroup) {
   // SetFromConfig is always called after construction from InitializeSession.
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
   QuicConfig config;
   config.set_max_undecryptable_packets(100);
   connection_.SetFromConfig(config);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   use_tagging_decrypter();
 
-  const uint8 tag = 0x07;
+  const uint8_t tag = 0x07;
   framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
 
   // Don't send packet 1 and buffer initially encrypted packets.
   ProcessFecProtectedPacketAtLevel(2, 1, false, !kEntropyFlag,
                                    ENCRYPTION_INITIAL);
   ProcessFecPacketAtLevel(3, 1, false, kEntropyFlag, nullptr,
                           ENCRYPTION_INITIAL);
   // Since the packets were buffered, no FEC group should be open.
   ASSERT_EQ(0u, connection_.NumFecGroups());
 
@@ skipping 16 matching lines @@
 
 TEST_P(QuicConnectionTest, Buffer100NonDecryptablePackets) {
   // SetFromConfig is always called after construction from InitializeSession.
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
   QuicConfig config;
   config.set_max_undecryptable_packets(100);
   connection_.SetFromConfig(config);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   use_tagging_decrypter();
 
-  const uint8 tag = 0x07;
+  const uint8_t tag = 0x07;
   framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
 
   // Process an encrypted packet which can not yet be decrypted which should
   // result in the packet being buffered.
   for (QuicPacketNumber i = 1; i <= 100; ++i) {
     ProcessDataPacketAtLevel(i, 0, kEntropyFlag, ENCRYPTION_INITIAL);
   }
 
   // Transition to the new encryption state and process another encrypted packet
   // which should result in the original packets being processed.
@@ skipping 893 matching lines @@
             connection_.SendStreamDataWithString(3, payload, 0, !kFin, nullptr)
                 .bytes_consumed);
   // Just like above, we save 8 bytes on payload, and 8 on truncation.
   EXPECT_EQ(non_truncated_packet_size, writer_->last_packet_size() + 8 * 2);
 }
 
 TEST_P(QuicConnectionTest, SendDelayedAck) {
   QuicTime ack_time = clock_.ApproximateNow().Add(DefaultDelayedAckTime());
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-  const uint8 tag = 0x07;
+  const uint8_t tag = 0x07;
   connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
   framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
   // Process a packet from the non-crypto stream.
   frame1_.stream_id = 3;
 
   // The same as ProcessPacket(1) except that ENCRYPTION_INITIAL is used
   // instead of ENCRYPTION_NONE.
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
   ProcessDataPacketAtLevel(1, 0, !kEntropyFlag, ENCRYPTION_INITIAL);
 
@@ skipping 15 matching lines @@
   const size_t kMinRttMs = 40;
   RttStats* rtt_stats = QuicSentPacketManagerPeer::GetRttStats(manager_);
   rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(kMinRttMs),
                        QuicTime::Delta::Zero(), QuicTime::Zero());
   // The ack time should be based on min_rtt/4, since it's less than the
   // default delayed ack time.
   QuicTime ack_time = clock_.ApproximateNow().Add(
       QuicTime::Delta::FromMilliseconds(kMinRttMs / 4));
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-  const uint8 tag = 0x07;
+  const uint8_t tag = 0x07;
   connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
   framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
   // Process a packet from the non-crypto stream.
   frame1_.stream_id = 3;
 
   // Process all the initial packets in order so there aren't missing packets.
   QuicPacketNumber kFirstDecimatedPacket = 101;
   for (unsigned int i = 0; i < kFirstDecimatedPacket - 1; ++i) {
     EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
     ProcessDataPacketAtLevel(1 + i, 0, !kEntropyFlag, ENCRYPTION_INITIAL);
@@ skipping 1152 matching lines @@
   EXPECT_CALL(visitor_,
               OnConnectionClosed(QUIC_UNENCRYPTED_STREAM_DATA, false));
   EXPECT_DFATAL(connection_.SendStreamDataWithString(3, "", 0, kFin, nullptr),
                 "Cannot send stream data without encryption.");
   EXPECT_FALSE(connection_.connected());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net