Switch to standard integer types in net/.

net/spdy/hpack/hpack_input_stream_test.cc

 // Copyright 2014 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/spdy/hpack/hpack_input_stream.h"
 
 #include <bitset>
 #include <string>
 #include <vector>
 
@@ skipping 27 matching lines @@
 // Hex representation of encoded length and Huffman string.
 const char kEncodedHuffmanFixture[] =
     "2d"  // Length prefix.
     "94e7821dd7f2e6c7b335dfdfcd5b3960"
     "d5af27087f3672c1ab270fb5291f9587"
     "316065c003ed4ee5b1063d5007";
 
 const char kDecodedHuffmanFixture[] =
     "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1";
 
-// Utility function to decode an assumed-valid uint32 with an N-bit
+// Utility function to decode an assumed-valid uint32_t with an N-bit
 // prefix.
-uint32 DecodeValidUint32(uint8 N, StringPiece str) {
+uint32_t DecodeValidUint32(uint8_t N, StringPiece str) {
   EXPECT_GT(N, 0);
   EXPECT_LE(N, 8);
   HpackInputStream input_stream(kLiteralBound, str);
   input_stream.SetBitOffsetForTest(8 - N);
-  uint32 I;
+  uint32_t I;
   EXPECT_TRUE(input_stream.DecodeNextUint32(&I));
   return I;
 }
 
-// Utility function to decode an assumed-invalid uint32 with an N-bit
+// Utility function to decode an assumed-invalid uint32_t with an N-bit
 // prefix.
-void ExpectDecodeUint32Invalid(uint8 N, StringPiece str) {
+void ExpectDecodeUint32Invalid(uint8_t N, StringPiece str) {
   EXPECT_GT(N, 0);
   EXPECT_LE(N, 8);
   HpackInputStream input_stream(kLiteralBound, str);
   input_stream.SetBitOffsetForTest(8 - N);
-  uint32 I;
+  uint32_t I;
   EXPECT_FALSE(input_stream.DecodeNextUint32(&I));
 }
 
-uint32 bits32(const string& bitstring) {
+uint32_t bits32(const string& bitstring) {
   return std::bitset<32>(bitstring).to_ulong();
 }
 
 // The {Number}ByteIntegersEightBitPrefix tests below test that
 // certain integers are decoded correctly with an 8-bit prefix in
 // exactly {Number} bytes.
 
 TEST_F(HpackInputStreamTest, OneByteIntegersEightBitPrefix) {
   // Minimum.
   EXPECT_EQ(0x00u, DecodeValidUint32(8, string("\x00", 1)));
@@ skipping 58 matching lines @@
   // Minimum.
   EXPECT_EQ(0x100000ffu, DecodeValidUint32(8, "\xff\x80\x80\x80\x80\x01"));
   // Maximum.
   EXPECT_EQ(0xffffffffu, DecodeValidUint32(8, "\xff\x80\xfe\xff\xff\x0f"));
   // Invalid.
   ExpectDecodeUint32Invalid(8, "\xff\x80\x80\x80\x80\x00");
   ExpectDecodeUint32Invalid(8, "\xff\x80\xfe\xff\xff\x10");
   ExpectDecodeUint32Invalid(8, "\xff\xff\xff\xff\xff\xff");
 }
 
-// There are no valid uint32 encodings that are greater than six
+// There are no valid uint32_t encodings that are greater than six
 // bytes.
 TEST_F(HpackInputStreamTest, SevenByteIntegersEightBitPrefix) {
   ExpectDecodeUint32Invalid(8, "\xff\x80\x80\x80\x80\x80\x00");
   ExpectDecodeUint32Invalid(8, "\xff\x80\x80\x80\x80\x80\x01");
   ExpectDecodeUint32Invalid(8, "\xff\xff\xff\xff\xff\xff\xff");
 }
 
 // The {Number}ByteIntegersOneToSevenBitPrefix tests below test that
 // certain integers are encoded correctly with an N-bit prefix in
 // exactly {Number} bytes for N in {1, 2, ..., 7}.
@@ skipping 291 matching lines @@
   ExpectDecodeUint32Invalid(4, "\x0f\xf0\xff\xff\xff\x10");
   ExpectDecodeUint32Invalid(4, "\xff\xf0\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(3, "\x07\xf8\xff\xff\xff\x10");
   ExpectDecodeUint32Invalid(3, "\xff\xf8\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(2, "\x03\xfc\xff\xff\xff\x10");
   ExpectDecodeUint32Invalid(2, "\xff\xfc\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(1, "\x01\xfe\xff\xff\xff\x10");
   ExpectDecodeUint32Invalid(1, "\xff\xfe\xff\xff\xff\xff");
 }
 
-// There are no valid uint32 encodings that are greater than six
+// There are no valid uint32_t encodings that are greater than six
 // bytes.
 TEST_F(HpackInputStreamTest, SevenByteIntegersOneToSevenBitPrefixes) {
   ExpectDecodeUint32Invalid(7, "\x7f\x80\x80\x80\x80\x80\x00");
   ExpectDecodeUint32Invalid(7, "\x7f\x80\x80\x80\x80\x80\x01");
   ExpectDecodeUint32Invalid(7, "\xff\xff\xff\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(6, "\x3f\x80\x80\x80\x80\x80\x00");
   ExpectDecodeUint32Invalid(6, "\x3f\x80\x80\x80\x80\x80\x01");
   ExpectDecodeUint32Invalid(6, "\xff\xff\xff\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(5, "\x1f\x80\x80\x80\x80\x80\x00");
   ExpectDecodeUint32Invalid(5, "\x1f\x80\x80\x80\x80\x80\x01");
@@ skipping 70 matching lines @@
   HpackInputStream input_stream(arraysize(kDecodedHuffmanFixture) - 1, input);
 
   // Not enough buffer for declared encoded length.
   EXPECT_TRUE(input_stream.HasMoreData());
   EXPECT_FALSE(input_stream.DecodeNextHuffmanString(huffman_table_, &output));
 }
 
 TEST_F(HpackInputStreamTest, PeekBitsAndConsume) {
   HpackInputStream input_stream(kLiteralBound, "\xad\xab\xad\xab\xad");
 
-  uint32 bits = 0;
+  uint32_t bits = 0;
   size_t peeked_count = 0;
 
   // Read 0xad.
   EXPECT_TRUE(input_stream.PeekBits(&peeked_count, &bits));
   EXPECT_EQ(bits32("10101101000000000000000000000000"), bits);
   EXPECT_EQ(8u, peeked_count);
 
   // Read 0xab.
   EXPECT_TRUE(input_stream.PeekBits(&peeked_count, &bits));
   EXPECT_EQ(bits32("10101101101010110000000000000000"), bits);
@@ skipping 57 matching lines @@
 
   input_stream.ConsumeBits(6);
   EXPECT_TRUE(input_stream.HasMoreData());
   input_stream.ConsumeByteRemainder();
   EXPECT_FALSE(input_stream.HasMoreData());
 }
 
 }  // namespace
 
 }  // namespace net