Remove kuint32max.

net/spdy/hpack/hpack_huffman_table_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_huffman_table.h"
 
+#include <stdint.h>
+
 #include <bitset>
+#include <limits>
 #include <string>
 
 #include "base/logging.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/hpack/hpack_input_stream.h"
 #include "net/spdy/hpack/hpack_output_stream.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using std::string;
 using testing::ElementsAreArray;
 using testing::Pointwise;
 
 namespace net {
 
 namespace test {
 
 typedef HpackHuffmanTable::DecodeEntry DecodeEntry;
 typedef HpackHuffmanTable::DecodeTable DecodeTable;
 
 class HpackHuffmanTablePeer {
  public:
   explicit HpackHuffmanTablePeer(const HpackHuffmanTable& table)
       : table_(table) {}
 
-  const std::vector<uint32>& code_by_id() const { return table_.code_by_id_; }
-  const std::vector<uint8>& length_by_id() const {
+  const std::vector<uint32_t>& code_by_id() const { return table_.code_by_id_; }
+  const std::vector<uint8_t>& length_by_id() const {
     return table_.length_by_id_;
   }
   const std::vector<DecodeTable>& decode_tables() const {
     return table_.decode_tables_;
   }
   char pad_bits() const {
     // Cast to match signed-ness of bits8().
     return static_cast<char>(table_.pad_bits_);
   }
-  uint16 failed_symbol_id() const { return table_.failed_symbol_id_; }
+  uint16_t failed_symbol_id() const { return table_.failed_symbol_id_; }
   std::vector<DecodeEntry> decode_entries(const DecodeTable& decode_table) {
     std::vector<DecodeEntry>::const_iterator begin =
         table_.decode_entries_.begin() + decode_table.entries_offset;
     return std::vector<DecodeEntry>(begin, begin + decode_table.size());
   }
 
  private:
   const HpackHuffmanTable& table_;
 };
 
@@ skipping 18 matching lines @@
   HpackHuffmanTablePeer peer_;
 };
 
 MATCHER(DecodeEntryEq, "") {
   const DecodeEntry& lhs = std::tr1::get<0>(arg);
   const DecodeEntry& rhs = std::tr1::get<1>(arg);
   return lhs.next_table_index == rhs.next_table_index &&
          lhs.length == rhs.length && lhs.symbol_id == rhs.symbol_id;
 }
 
-uint32 bits32(const string& bitstring) {
+uint32_t bits32(const string& bitstring) {
   return std::bitset<32>(bitstring).to_ulong();
 }
 char bits8(const string& bitstring) {
   return static_cast<char>(std::bitset<8>(bitstring).to_ulong());
 }
 
 TEST_F(HpackHuffmanTableTest, InitializeHpackCode) {
   std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
   EXPECT_TRUE(table_.Initialize(&code[0], code.size()));
   EXPECT_TRUE(table_.IsInitialized());
@@ skipping 136 matching lines @@
   StringPiece input(input_storage, arraysize(input_storage));
   // By symbol: (2) 00 (3) 010 (2) 00 (7) 10010 (4) 10000 (6 as pad) 1001100.
   char expect_storage[] = {bits8("00010001"), bits8("00101000"),
                            bits8("01001100")};
   StringPiece expect(expect_storage, arraysize(expect_storage));
 
   string buffer_in = EncodeString(input);
   EXPECT_EQ(expect, buffer_in);
 
   string buffer_out;
-  HpackInputStream input_stream(kuint32max, buffer_in);
+  HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(),
+                                buffer_in);
   EXPECT_TRUE(table_.DecodeString(&input_stream, input.size(), &buffer_out));
   EXPECT_EQ(buffer_out, input);
 }
 
 TEST_F(HpackHuffmanTableTest, ValidateMultiLevelDecodeTables) {
   HpackHuffmanSymbol code[] = {
       {bits32("00000000000000000000000000000000"), 6, 0},
       {bits32("00000100000000000000000000000000"), 6, 1},
       {bits32("00001000000000000000000000000000"), 11, 2},
       {bits32("00001000001000000000000000000000"), 11, 3},
@@ skipping 44 matching lines @@
       {bits32("10011100000000000000000000000000"), 16, 8}};
   EXPECT_TRUE(table_.Initialize(code, arraysize(code)));
 
   string buffer;
   const size_t capacity = 4;
   {
     // This example works: (2) 00 (3) 010 (2) 00 (6) 100110 (pad) 100.
     char input_storage[] = {bits8("00010001"), bits8("00110100")};
     StringPiece input(input_storage, arraysize(input_storage));
 
-    HpackInputStream input_stream(kuint32max, input);
+    HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(), input);
     EXPECT_TRUE(table_.DecodeString(&input_stream, capacity, &buffer));
     EXPECT_EQ(buffer, "\x02\x03\x02\x06");
   }
   {
     // Expect to fail on an invalid code prefix.
     // (2) 00 (3) 010 (2) 00 (too-large) 101000 (pad) 100.
     char input_storage[] = {bits8("00010001"), bits8("01000111")};
     StringPiece input(input_storage, arraysize(input_storage));
 
-    HpackInputStream input_stream(kuint32max, input);
+    HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(), input);
     EXPECT_FALSE(table_.DecodeString(&input_stream, capacity, &buffer));
     EXPECT_EQ(buffer, "\x02\x03\x02");
   }
   {
     // Repeat the shortest 0b00 code to overflow |buffer|. Expect to fail.
     std::vector<char> input_storage(1 + capacity / 4, '\0');
     StringPiece input(&input_storage[0], input_storage.size());
 
-    HpackInputStream input_stream(kuint32max, input);
+    HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(), input);
     EXPECT_FALSE(table_.DecodeString(&input_stream, capacity, &buffer));
 
     std::vector<char> expected(capacity, '\x02');
     EXPECT_THAT(buffer, ElementsAreArray(expected));
     EXPECT_EQ(capacity, buffer.size());
   }
   {
     // Expect to fail if more than a byte of unconsumed input remains.
     // (6) 100110 (8 truncated) 1001110000
     char input_storage[] = {bits8("10011010"), bits8("01110000")};
     StringPiece input(input_storage, arraysize(input_storage));
 
-    HpackInputStream input_stream(kuint32max, input);
+    HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(), input);
     EXPECT_FALSE(table_.DecodeString(&input_stream, capacity, &buffer));
     EXPECT_EQ(buffer, "\x06");
   }
 }
 
 TEST_F(HpackHuffmanTableTest, SpecRequestExamples) {
   std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
   EXPECT_TRUE(table_.Initialize(&code[0], code.size()));
 
   string buffer;
   string test_table[] = {
       a2b_hex("f1e3c2e5f23a6ba0ab90f4ff"),
       "www.example.com",
       a2b_hex("a8eb10649cbf"),
       "no-cache",
       a2b_hex("25a849e95ba97d7f"),
       "custom-key",
       a2b_hex("25a849e95bb8e8b4bf"),
       "custom-value",
   };
   // Round-trip each test example.
   for (size_t i = 0; i != arraysize(test_table); i += 2) {
     const string& encodedFixture(test_table[i]);
     const string& decodedFixture(test_table[i + 1]);
-    HpackInputStream input_stream(kuint32max, encodedFixture);
+    HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(),
+                                  encodedFixture);
 
     EXPECT_TRUE(
         table_.DecodeString(&input_stream, decodedFixture.size(), &buffer));
     EXPECT_EQ(decodedFixture, buffer);
     buffer = EncodeString(decodedFixture);
     EXPECT_EQ(encodedFixture, buffer);
   }
 }
 
 TEST_F(HpackHuffmanTableTest, SpecResponseExamples) {
@@ skipping 10 matching lines @@
               "d3"),
       "https://www.example.com", a2b_hex("94e7821dd7f2e6c7b335dfdfcd5b3960"
                                          "d5af27087f3672c1ab270fb5291f9587"
                                          "316065c003ed4ee5b1063d5007"),
       "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1",
   };
   // Round-trip each test example.
   for (size_t i = 0; i != arraysize(test_table); i += 2) {
     const string& encodedFixture(test_table[i]);
     const string& decodedFixture(test_table[i + 1]);
-    HpackInputStream input_stream(kuint32max, encodedFixture);
+    HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(),
+                                  encodedFixture);
 
     EXPECT_TRUE(
         table_.DecodeString(&input_stream, decodedFixture.size(), &buffer));
     EXPECT_EQ(decodedFixture, buffer);
     buffer = EncodeString(decodedFixture);
     EXPECT_EQ(encodedFixture, buffer);
   }
 }
 
 TEST_F(HpackHuffmanTableTest, RoundTripIndvidualSymbols) {
   std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
   EXPECT_TRUE(table_.Initialize(&code[0], code.size()));
 
   for (size_t i = 0; i != 256; i++) {
     char c = static_cast<char>(i);
     char storage[3] = {c, c, c};
     StringPiece input(storage, arraysize(storage));
 
     string buffer_in = EncodeString(input);
     string buffer_out;
 
-    HpackInputStream input_stream(kuint32max, buffer_in);
+    HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(),
+                                  buffer_in);
     EXPECT_TRUE(table_.DecodeString(&input_stream, input.size(), &buffer_out));
     EXPECT_EQ(input, buffer_out);
   }
 }
 
 TEST_F(HpackHuffmanTableTest, RoundTripSymbolSequence) {
   std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
   EXPECT_TRUE(table_.Initialize(&code[0], code.size()));
 
   char storage[512];
   for (size_t i = 0; i != 256; i++) {
     storage[i] = static_cast<char>(i);
     storage[511 - i] = static_cast<char>(i);
   }
   StringPiece input(storage, arraysize(storage));
 
   string buffer_in = EncodeString(input);
   string buffer_out;
 
-  HpackInputStream input_stream(kuint32max, buffer_in);
+  HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(),
+                                buffer_in);
   EXPECT_TRUE(table_.DecodeString(&input_stream, input.size(), &buffer_out));
   EXPECT_EQ(input, buffer_out);
 }
 
 TEST_F(HpackHuffmanTableTest, EncodedSizeAgreesWithEncodeString) {
   std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
   EXPECT_TRUE(table_.Initialize(&code[0], code.size()));
 
   string test_table[] = {
       "",
@@ skipping 16 matching lines @@
     output_stream.TakeString(&encoding);
     EXPECT_EQ(encoding.size(), table_.EncodedSize(test_table[i]));
   }
 }
 
 }  // namespace
 
 }  // namespace test
 
 }  // namespace net