Remove limit on individual hpack string literals.

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 <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/hpack/hpack_huffman_decoder.h"
 #include "net/spdy/hpack/hpack_input_stream.h"
 #include "net/spdy/hpack/hpack_output_stream.h"
 #include "net/spdy/spdy_test_utils.h"
@@ skipping 212 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(std::numeric_limits<uint32_t>::max(),
-                                buffer_in);
+  HpackInputStream input_stream(buffer_in);
   EXPECT_TRUE(
       table_.GenericDecodeString(&input_stream, input.size(), &buffer_out));
   EXPECT_EQ(buffer_out, input);
 }
 
 TEST_F(GenericHuffmanTableTest, ValidateMultiLevelDecodeTables) {
   HpackHuffmanSymbol code[] = {
       {bits32("00000000000000000000000000000000"), 6, 0},
       {bits32("00000100000000000000000000000000"), 6, 1},
       {bits32("00001000000000000000000000000000"), 11, 2},
@@ skipping 45 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(std::numeric_limits<uint32_t>::max(), input);
+    HpackInputStream input_stream(input);
     EXPECT_TRUE(table_.GenericDecodeString(&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(std::numeric_limits<uint32_t>::max(), input);
+    HpackInputStream input_stream(input);
     EXPECT_FALSE(table_.GenericDecodeString(&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(std::numeric_limits<uint32_t>::max(), input);
+    HpackInputStream input_stream(input);
     EXPECT_FALSE(table_.GenericDecodeString(&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(std::numeric_limits<uint32_t>::max(), input);
+    HpackInputStream input_stream(input);
     EXPECT_FALSE(table_.GenericDecodeString(&input_stream, capacity, &buffer));
     EXPECT_EQ(buffer, "\x06");
   }
 }
 
 // Tests of the ability to decode the HPACK Huffman Code, defined in:
 //     https://httpwg.github.io/specs/rfc7541.html#huffman.code
 class HpackHuffmanTableTest : public GenericHuffmanTableTest {
  protected:
   void SetUp() override {
     std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
     EXPECT_TRUE(table_.Initialize(&code[0], code.size()));
     EXPECT_TRUE(table_.IsInitialized());
   }
 
   void DecodeStringTwice(const string& encoded,
                          size_t out_capacity,
                          string* out) {
     // First decode with HpackHuffmanTable.
     {
-      HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(),
-                                    encoded);
+      HpackInputStream input_stream(encoded);
       EXPECT_TRUE(table_.GenericDecodeString(&input_stream, out_capacity, out));
     }
     // And decode again with the fixed decoder, confirming that the result is
     // the same.
     {
-      HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(),
-                                    encoded);
+      HpackInputStream input_stream(encoded);
       string buf;
-      EXPECT_TRUE(
-          HpackHuffmanDecoder::DecodeString(&input_stream, out_capacity, &buf));
+      EXPECT_TRUE(HpackHuffmanDecoder::DecodeString(&input_stream, &buf));
       EXPECT_EQ(*out, buf);
     }
   }
 };
 
 TEST_F(HpackHuffmanTableTest, InitializeHpackCode) {
   EXPECT_EQ(peer_.pad_bits(), '\xFF');  // First 8 bits of EOS.
 }
 
 TEST_F(HpackHuffmanTableTest, SpecRequestExamples) {
@@ skipping 93 matching lines @@
     output_stream.TakeString(&encoding);
     EXPECT_EQ(encoding.size(), table_.EncodedSize(test_table[i]));
   }
 }
 
 }  // namespace
 
 }  // namespace test
 
 }  // namespace net