Remove limit on individual hpack string literals.

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>
 
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace test {
 
 using base::StringPiece;
 using std::string;
 using test::a2b_hex;
 
-const size_t kLiteralBound = 1024;
-
 // 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";
 
@@ skipping 10 matching lines @@
 
  private:
   HpackInputStream* input_stream_;
 };
 
 // Utility function to decode an assumed-valid uint32_t with an N-bit
 // prefix.
 uint32_t DecodeValidUint32(uint8_t N, StringPiece str) {
   EXPECT_GT(N, 0);
   EXPECT_LE(N, 8);
-  HpackInputStream input_stream(kLiteralBound, str);
+  HpackInputStream input_stream(str);
   HpackInputStreamPeer input_stream_peer(&input_stream);
   input_stream_peer.SetBitOffsetForTest(8 - N);
   uint32_t I;
   EXPECT_TRUE(input_stream.DecodeNextUint32(&I));
   EXPECT_EQ(str.size(), input_stream_peer.ParsedBytesCurrent());
   EXPECT_FALSE(input_stream.NeedMoreData());
   return I;
 }
 
 // Utility function to decode an assumed-invalid uint32_t with an N-bit
 // prefix.
 void ExpectDecodeUint32Invalid(uint8_t N, StringPiece str) {
   EXPECT_GT(N, 0);
   EXPECT_LE(N, 8);
-  HpackInputStream input_stream(kLiteralBound, str);
+  HpackInputStream input_stream(str);
   HpackInputStreamPeer input_stream_peer(&input_stream);
   input_stream_peer.SetBitOffsetForTest(8 - N);
   uint32_t I;
   EXPECT_FALSE(input_stream.DecodeNextUint32(&I));
 }
 
 uint32_t bits32(const string& bitstring) {
   return std::bitset<32>(bitstring).to_ulong();
 }
 
@@ skipping 405 matching lines @@
   ExpectDecodeUint32Invalid(2, "\x03\x80\x80\x80\x80\x80\x00");
   ExpectDecodeUint32Invalid(2, "\x03\x80\x80\x80\x80\x80\x01");
   ExpectDecodeUint32Invalid(2, "\xff\xff\xff\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(1, "\x01\x80\x80\x80\x80\x80\x00");
   ExpectDecodeUint32Invalid(1, "\x01\x80\x80\x80\x80\x80\x01");
   ExpectDecodeUint32Invalid(1, "\xff\xff\xff\xff\xff\xff\xff");
 }
 
 // Decoding a valid encoded string literal should work.
 TEST(HpackInputStreamTest, DecodeNextIdentityString) {
-  HpackInputStream input_stream(kLiteralBound, "\x0estring literal");
+  HpackInputStream input_stream("\x0estring literal");
   HpackInputStreamPeer input_stream_peer(&input_stream);
 
   EXPECT_TRUE(input_stream.HasMoreData());
   StringPiece string_piece;
   EXPECT_TRUE(input_stream.DecodeNextIdentityString(&string_piece));
   EXPECT_EQ("string literal", string_piece);
   EXPECT_FALSE(input_stream.HasMoreData());
   EXPECT_EQ(string_piece.size() + 1, input_stream_peer.ParsedBytesCurrent());
   EXPECT_FALSE(input_stream.NeedMoreData());
 }
 
-// Decoding an encoded string literal with size larger than
-// |max_string_literal_size_| should fail.
-TEST(HpackInputStreamTest, DecodeNextIdentityStringSizeLimit) {
-  HpackInputStream input_stream(13, "\x0estring literal");
-
-  EXPECT_TRUE(input_stream.HasMoreData());
-  StringPiece string_piece;
-  EXPECT_FALSE(input_stream.DecodeNextIdentityString(&string_piece));
-  EXPECT_FALSE(input_stream.NeedMoreData());
-}
-
 // Decoding an encoded string literal with size larger than the
 // remainder of the buffer should fail.
 TEST(HpackInputStreamTest, DecodeNextIdentityStringNotEnoughInput) {
   // Set the length to be one more than it should be.
-  HpackInputStream input_stream(kLiteralBound, "\x0fstring literal");
+  HpackInputStream input_stream("\x0fstring literal");
 
   EXPECT_TRUE(input_stream.HasMoreData());
   StringPiece string_piece;
   EXPECT_FALSE(input_stream.DecodeNextIdentityString(&string_piece));
   EXPECT_TRUE(input_stream.NeedMoreData());
 }
 
 TEST(HpackInputStreamTest, DecodeNextHuffmanString) {
   string output, input(a2b_hex(kEncodedHuffmanFixture));
-  HpackInputStream input_stream(arraysize(kDecodedHuffmanFixture) - 1, input);
+  HpackInputStream input_stream(input);
   HpackInputStreamPeer input_stream_peer(&input_stream);
 
   EXPECT_TRUE(input_stream.HasMoreData());
   EXPECT_TRUE(input_stream.DecodeNextHuffmanString(&output));
   EXPECT_EQ(kDecodedHuffmanFixture, output);
   EXPECT_FALSE(input_stream.HasMoreData());
   EXPECT_FALSE(input_stream.NeedMoreData());
   EXPECT_EQ(46u, input_stream_peer.ParsedBytesCurrent());
 }
 
-TEST(HpackInputStreamTest, DecodeNextHuffmanStringSizeLimit) {
-  string output, input(a2b_hex(kEncodedHuffmanFixture));
-  // Max string literal is one byte shorter than the decoded fixture.
-  HpackInputStream input_stream(arraysize(kDecodedHuffmanFixture) - 2, input);
-
-  // Decoded string overflows the max string literal.
-  EXPECT_TRUE(input_stream.HasMoreData());
-  EXPECT_FALSE(input_stream.DecodeNextHuffmanString(&output));
-  EXPECT_FALSE(input_stream.NeedMoreData());
-}
-
 TEST(HpackInputStreamTest, DecodeNextHuffmanStringNotEnoughInput) {
   string output, input(a2b_hex(kEncodedHuffmanFixture));
   input[0]++;  // Input prefix is one byte larger than available input.
-  HpackInputStream input_stream(arraysize(kDecodedHuffmanFixture) - 1, input);
+  HpackInputStream input_stream(input);
 
   // Not enough buffer for declared encoded length.
   EXPECT_TRUE(input_stream.HasMoreData());
   EXPECT_FALSE(input_stream.DecodeNextHuffmanString(&output));
   EXPECT_TRUE(input_stream.NeedMoreData());
 }
 
 TEST(HpackInputStreamTest, PeekBitsAndConsume) {
-  HpackInputStream input_stream(kLiteralBound, "\xad\xab\xad\xab\xad");
+  HpackInputStream input_stream("\xad\xab\xad\xab\xad");
 
   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.
@@ skipping 43 matching lines @@
   EXPECT_EQ(bits32("10101101000000000000000000000000"), bits);
   EXPECT_EQ(8u, peeked_count);
 
   input_stream.ConsumeBits(8);
   EXPECT_FALSE(input_stream.HasMoreData());
 }
 
 TEST(HpackInputStreamTest, InitializePeekBits) {
   {
     // Empty input, peeked_count == 0 and bits == 0.
-    HpackInputStream input_stream(kLiteralBound, "");
+    HpackInputStream input_stream("");
     auto peeked_count_and_bits = input_stream.InitializePeekBits();
     size_t peeked_count = peeked_count_and_bits.first;
     uint32_t bits = peeked_count_and_bits.second;
     EXPECT_EQ(0u, peeked_count);
     EXPECT_EQ(0u, bits);
   }
   {
     // One input byte, returns peeked_count == 8 and bits
     // has the input byte in its high order bits.
-    HpackInputStream input_stream(kLiteralBound, "\xfe");
+    HpackInputStream input_stream("\xfe");
     auto peeked_count_and_bits = input_stream.InitializePeekBits();
     size_t peeked_count = peeked_count_and_bits.first;
     uint32_t bits = peeked_count_and_bits.second;
     EXPECT_EQ(8u, peeked_count);
     EXPECT_EQ(0xfe000000, bits);
     input_stream.ConsumeBits(8);
     EXPECT_FALSE(input_stream.HasMoreData());
   }
   {
     // Two input bytes, returns peeked_count == 16 and bits
     // has the two input bytes in its high order bits.
-    HpackInputStream input_stream(kLiteralBound, "\xfe\xdc");
+    HpackInputStream input_stream("\xfe\xdc");
     auto peeked_count_and_bits = input_stream.InitializePeekBits();
     size_t peeked_count = peeked_count_and_bits.first;
     uint32_t bits = peeked_count_and_bits.second;
     EXPECT_EQ(16u, peeked_count);
     EXPECT_EQ(0xfedc0000, bits);
     input_stream.ConsumeBits(16);
     EXPECT_FALSE(input_stream.HasMoreData());
   }
   {
     // Three input bytes, returns peeked_count == 24 and bits
     // has the three input bytes in its high order bits.
-    HpackInputStream input_stream(kLiteralBound, "\xab\xcd\xef");
+    HpackInputStream input_stream("\xab\xcd\xef");
     auto peeked_count_and_bits = input_stream.InitializePeekBits();
     size_t peeked_count = peeked_count_and_bits.first;
     uint32_t bits = peeked_count_and_bits.second;
     EXPECT_EQ(24u, peeked_count);
     EXPECT_EQ(0xabcdef00, bits);
     input_stream.ConsumeBits(24);
     EXPECT_FALSE(input_stream.HasMoreData());
   }
   {
     // Four input bytes, returns peeked_count == 32 and bits
     // contains the four input bytes.
-    HpackInputStream input_stream(kLiteralBound, "\xfe\xed\xdc\xcb");
+    HpackInputStream input_stream("\xfe\xed\xdc\xcb");
     auto peeked_count_and_bits = input_stream.InitializePeekBits();
     size_t peeked_count = peeked_count_and_bits.first;
     uint32_t bits = peeked_count_and_bits.second;
     EXPECT_EQ(32u, peeked_count);
     EXPECT_EQ(0xfeeddccb, bits);
     input_stream.ConsumeBits(32);
     EXPECT_FALSE(input_stream.HasMoreData());
   }
   {
     // Five input bytes, returns peeked_count == 32 and bits
     // contains the first four input bytes.
-    HpackInputStream input_stream(kLiteralBound, "\xfe\xed\xdc\xcb\xba");
+    HpackInputStream input_stream("\xfe\xed\xdc\xcb\xba");
     auto peeked_count_and_bits = input_stream.InitializePeekBits();
     size_t peeked_count = peeked_count_and_bits.first;
     uint32_t bits = peeked_count_and_bits.second;
     EXPECT_EQ(32u, peeked_count);
     EXPECT_EQ(0xfeeddccb, bits);
     EXPECT_TRUE(input_stream.HasMoreData());
 
     // If we consume some bits, then InitializePeekBits will return no bits.
     input_stream.ConsumeBits(28);
     peeked_count -= 28;
     bits <<= 28;
     EXPECT_EQ(0xb0000000, bits);
 
     EXPECT_SPDY_BUG(peeked_count_and_bits = input_stream.InitializePeekBits(),
                     "bit_offset_");
     EXPECT_EQ(0u, peeked_count_and_bits.first);
     EXPECT_EQ(0u, peeked_count_and_bits.second);
     EXPECT_TRUE(input_stream.HasMoreData());
 
     // Can PeekBits, which will get us the last byte's bits.
     EXPECT_TRUE(input_stream.PeekBits(&peeked_count, &bits));
     EXPECT_EQ(12u, peeked_count);
     EXPECT_EQ(0xbba00000, bits);
     input_stream.ConsumeBits(12);
     EXPECT_FALSE(input_stream.HasMoreData());
   }
 }
 
 TEST(HpackInputStreamTest, ConsumeByteRemainder) {
-  HpackInputStream input_stream(kLiteralBound, "\xad\xab");
+  HpackInputStream input_stream("\xad\xab");
   // Does nothing.
   input_stream.ConsumeByteRemainder();
 
   // Consumes one byte.
   input_stream.ConsumeBits(3);
   input_stream.ConsumeByteRemainder();
   EXPECT_TRUE(input_stream.HasMoreData());
 
   input_stream.ConsumeBits(6);
   EXPECT_TRUE(input_stream.HasMoreData());
   input_stream.ConsumeByteRemainder();
   EXPECT_FALSE(input_stream.HasMoreData());
 }
 
 TEST(HpackInputStreamTest, IncompleteHeaderMatchPrefixAndConsume) {
-  HpackInputStream input_stream(kLiteralBound, "");
+  HpackInputStream input_stream("");
   HpackInputStreamPeer input_stream_peer(&input_stream);
   EXPECT_FALSE(input_stream.MatchPrefixAndConsume(kIndexedOpcode));
   EXPECT_EQ(0u, input_stream_peer.ParsedBytesCurrent());
   EXPECT_TRUE(input_stream.NeedMoreData());
 }
 
 TEST(HpackInputStreamTest, IncompleteHeaderDecodeNextUint32) {
   // First byte only
-  HpackInputStream input_stream1(kLiteralBound, "\xff");
+  HpackInputStream input_stream1("\xff");
   HpackInputStreamPeer input_stream1_peer(&input_stream1);
   EXPECT_TRUE(input_stream1.MatchPrefixAndConsume(kIndexedOpcode));
   uint32_t result;
   EXPECT_FALSE(input_stream1.DecodeNextUint32(&result));
   EXPECT_TRUE(input_stream1.NeedMoreData());
   EXPECT_EQ(1u, input_stream1_peer.ParsedBytesCurrent());
 
   // No last byte
-  HpackInputStream input_stream2(kLiteralBound, "\xff\x80\x80\x80");
+  HpackInputStream input_stream2("\xff\x80\x80\x80");
   HpackInputStreamPeer input_stream2_peer(&input_stream2);
   EXPECT_TRUE(input_stream2.MatchPrefixAndConsume(kIndexedOpcode));
   EXPECT_FALSE(input_stream2.DecodeNextUint32(&result));
   EXPECT_TRUE(input_stream2.NeedMoreData());
   EXPECT_EQ(4u, input_stream2_peer.ParsedBytesCurrent());
 
   // Error happens before finishing parsing.
-  HpackInputStream input_stream3(kLiteralBound, "\xff\xff\xff\xff\xff\xff\xff");
+  HpackInputStream input_stream3("\xff\xff\xff\xff\xff\xff\xff");
   HpackInputStreamPeer input_stream3_peer(&input_stream3);
   EXPECT_TRUE(input_stream3.MatchPrefixAndConsume(kIndexedOpcode));
   EXPECT_FALSE(input_stream3.DecodeNextUint32(&result));
   EXPECT_FALSE(input_stream3.NeedMoreData());
   EXPECT_EQ(6u, input_stream3_peer.ParsedBytesCurrent());
 }
 
 TEST(HpackInputStreamTest, IncompleteHeaderDecodeNextIdentityString) {
-  HpackInputStream input_stream1(kLiteralBound, "\x0estring litera");
+  HpackInputStream input_stream1("\x0estring litera");
   HpackInputStreamPeer input_stream1_peer(&input_stream1);
   StringPiece string_piece;
   EXPECT_FALSE(input_stream1.DecodeNextIdentityString(&string_piece));
   // Only parsed first byte.
   EXPECT_EQ(1u, input_stream1_peer.ParsedBytesCurrent());
   EXPECT_TRUE(input_stream1.NeedMoreData());
 
-  HpackInputStream input_stream2(kLiteralBound, "\x0e");
+  HpackInputStream input_stream2("\x0e");
   HpackInputStreamPeer input_stream2_peer(&input_stream2);
   EXPECT_FALSE(input_stream2.DecodeNextIdentityString(&string_piece));
   // Only parsed first byte.
   EXPECT_EQ(1u, input_stream2_peer.ParsedBytesCurrent());
   EXPECT_TRUE(input_stream2.NeedMoreData());
 }
 
 TEST(HpackInputStreamTest, IncompleteHeaderDecodeNextHuffmanString) {
   string output, input(a2b_hex(kEncodedHuffmanFixture));
   input.resize(input.size() - 1);  // Remove last byte.
-  HpackInputStream input_stream1(arraysize(kDecodedHuffmanFixture) - 1, input);
+  HpackInputStream input_stream1(input);
   HpackInputStreamPeer input_stream1_peer(&input_stream1);
   EXPECT_FALSE(input_stream1.DecodeNextHuffmanString(&output));
   EXPECT_EQ(1u, input_stream1_peer.ParsedBytesCurrent());
   EXPECT_TRUE(input_stream1.NeedMoreData());
 
   input.erase(1, input.size());  // Remove all bytes except the first one.
-  HpackInputStream input_stream2(arraysize(kDecodedHuffmanFixture) - 1, input);
+  HpackInputStream input_stream2(input);
   HpackInputStreamPeer input_stream2_peer(&input_stream2);
   EXPECT_FALSE(input_stream2.DecodeNextHuffmanString(&output));
   EXPECT_EQ(1u, input_stream2_peer.ParsedBytesCurrent());
   EXPECT_TRUE(input_stream2.NeedMoreData());
 }
 
 }  // namespace test
 
 }  // namespace net