Remove limit on individual hpack string literals.

net/spdy/hpack/hpack_huffman_decoder_test.cc

 // Copyright 2016 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_decoder.h"
 
 #include <bitset>
 #include <limits>
 
 #include "base/logging.h"
@@ skipping 161 matching lines @@
       "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 std::string& encodedFixture(test_table[i]);
     const std::string& decodedFixture(test_table[i + 1]);
-    HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(),
-                                  encodedFixture);
-    EXPECT_TRUE(HpackHuffmanDecoder::DecodeString(
-        &input_stream, decodedFixture.size(), &buffer));
+    HpackInputStream input_stream(encodedFixture);
+    EXPECT_TRUE(HpackHuffmanDecoder::DecodeString(&input_stream, &buffer));
     EXPECT_EQ(decodedFixture, buffer);
     buffer = EncodeString(decodedFixture);
     EXPECT_EQ(encodedFixture, buffer);
   }
 }
 
-TEST_F(HpackHuffmanDecoderTest, TooLong) {
-  std::string buffer;
-  std::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, but with too small an output buffer.
-  for (size_t i = 0; i != arraysize(test_table); i += 2) {
-    const std::string& encodedFixture(test_table[i]);
-    const std::string& decodedFixture(test_table[i + 1]);
-    uint32_t limit = base::RandInt(0, decodedFixture.size() - 1);
-    HpackInputStream strm(std::numeric_limits<uint32_t>::max(), encodedFixture);
-    EXPECT_FALSE(HpackHuffmanDecoder::DecodeString(&strm, limit, &buffer));
-
-    // This is NOT a required test as it really tests an implementation detail,
-    // i.e. the fact that it writes the first |limit| values into |buffer|,
-    // then returns false leaving those chars in the buffer.
-    EXPECT_EQ(decodedFixture.substr(0, limit), buffer);
-  }
-}
-
 TEST_F(HpackHuffmanDecoderTest, SpecResponseExamples) {
   std::string buffer;
   // clang-format off
   std::string test_table[] = {
     a2b_hex("6402"),
     "302",
     a2b_hex("aec3771a4b"),
     "private",
     a2b_hex("d07abe941054d444a8200595040b8166"
             "e082a62d1bff"),
     "Mon, 21 Oct 2013 20:13:21 GMT",
     a2b_hex("9d29ad171863c78f0b97c8e9ae82ae43"
             "d3"),
     "https://www.example.com",
     a2b_hex("94e7821dd7f2e6c7b335dfdfcd5b3960"
             "d5af27087f3672c1ab270fb5291f9587"
             "316065c003ed4ee5b1063d5007"),
     "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1",
   };
   // clang-format on
   // Round-trip each test example.
   for (size_t i = 0; i != arraysize(test_table); i += 2) {
     const std::string& encodedFixture(test_table[i]);
     const std::string& decodedFixture(test_table[i + 1]);
-    HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(),
-                                  encodedFixture);
-    EXPECT_TRUE(HpackHuffmanDecoder::DecodeString(
-        &input_stream, decodedFixture.size(), &buffer));
+    HpackInputStream input_stream(encodedFixture);
+    EXPECT_TRUE(HpackHuffmanDecoder::DecodeString(&input_stream, &buffer));
     EXPECT_EQ(decodedFixture, buffer);
     buffer = EncodeString(decodedFixture);
     EXPECT_EQ(encodedFixture, buffer);
   }
 }
 
 TEST_F(HpackHuffmanDecoderTest, RoundTripIndividualSymbols) {
   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));
     std::string buffer_in = EncodeString(input);
     std::string buffer_out;
-    HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(),
-                                  buffer_in);
-    EXPECT_TRUE(HpackHuffmanDecoder::DecodeString(&input_stream, input.size(),
-                                                  &buffer_out));
+    HpackInputStream input_stream(buffer_in);
+    EXPECT_TRUE(HpackHuffmanDecoder::DecodeString(&input_stream, &buffer_out));
     EXPECT_EQ(input, buffer_out);
   }
 }
 
 // Creates 256 input strings, each with a unique byte value i used to sandwich
 // all the other higher byte values.
 TEST_F(HpackHuffmanDecoderTest, RoundTripSymbolSequences) {
   std::string input;
   std::string encoded;
   std::string decoded;
   for (size_t i = 0; i != 256; i++) {
     input.clear();
     auto ic = static_cast<char>(i);
     input.push_back(ic);
     for (size_t j = i; j != 256; j++) {
       input.push_back(static_cast<char>(j));
       input.push_back(ic);
     }
     EncodeString(input, &encoded);
-    HpackInputStream input_stream(std::numeric_limits<uint32_t>::max(),
-                                  encoded);
-    EXPECT_TRUE(HpackHuffmanDecoder::DecodeString(&input_stream, input.size(),
-                                                  &decoded));
+    HpackInputStream input_stream(encoded);
+    EXPECT_TRUE(HpackHuffmanDecoder::DecodeString(&input_stream, &decoded));
     EXPECT_EQ(input, decoded);
   }
 }
 
 }  // namespace test
 }  // namespace net