Remove limit on individual hpack string literals.

net/spdy/hpack/hpack_decoder_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_decoder.h"
 
 #include <map>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 43 matching lines @@
 
 namespace {
 
 using base::StringPiece;
 using std::string;
 using test::a2b_hex;
 
 using testing::ElementsAre;
 using testing::Pair;
 
-const size_t kLiteralBound = 1024;
-
 class HpackDecoderTest : public ::testing::TestWithParam<bool> {
  protected:
   HpackDecoderTest() : decoder_(), decoder_peer_(&decoder_) {}
 
   void SetUp() override { handler_exists_ = GetParam(); }
 
   bool DecodeHeaderBlock(StringPiece str) {
     if (handler_exists_) {
       decoder_.HandleControlFrameHeadersStart(&handler_);
     }
@@ skipping 115 matching lines @@
               ElementsAre(Pair("cookie", " part 1; part 2 ; part3;  fin!"),
                           Pair("passed-through", StringPiece("foo\0baz", 7)),
                           Pair("joined", "not joined"),
                           Pair("joineD", StringPiece("value 1\0value 2", 15)),
                           Pair("empty", ""),
                           Pair("empty-joined", StringPiece("\0foo\0\0", 6))));
 }
 
 // Decoding an encoded name with a valid string literal should work.
 TEST_P(HpackDecoderTest, DecodeNextNameLiteral) {
-  HpackInputStream input_stream(kLiteralBound, StringPiece("\x00\x04name", 6));
+  HpackInputStream input_stream(StringPiece("\x00\x04name", 6));
 
   StringPiece string_piece;
   EXPECT_TRUE(decoder_peer_.DecodeNextName(&input_stream, &string_piece));
   EXPECT_EQ("name", string_piece);
   EXPECT_FALSE(input_stream.HasMoreData());
   EXPECT_FALSE(input_stream.NeedMoreData());
   input_stream.MarkCurrentPosition();
   EXPECT_EQ(6u, input_stream.ParsedBytes());
 }
 
 // Decoding an encoded name with an incomplete string literal.
 TEST_P(HpackDecoderTest, DecodeNextNameLiteralWithIncompleteHeader) {
-  HpackInputStream input_stream(kLiteralBound,
-                                StringPiece("\x00\x04name\x00\x02g", 9));
+  HpackInputStream input_stream(StringPiece("\x00\x04name\x00\x02g", 9));
 
   StringPiece string_piece;
   EXPECT_TRUE(decoder_peer_.DecodeNextName(&input_stream, &string_piece));
   EXPECT_FALSE(input_stream.NeedMoreData());
   input_stream.MarkCurrentPosition();
   EXPECT_EQ(6u, input_stream.ParsedBytes());
 
   EXPECT_FALSE(decoder_peer_.DecodeNextName(&input_stream, &string_piece));
   EXPECT_TRUE(input_stream.NeedMoreData());
   input_stream.MarkCurrentPosition();
   EXPECT_EQ(8u, input_stream.ParsedBytes());
 }
 
 TEST_P(HpackDecoderTest, DecodeNextNameLiteralWithHuffmanEncoding) {
   string input = a2b_hex("008825a849e95ba97d7f");
-  HpackInputStream input_stream(kLiteralBound, input);
+  HpackInputStream input_stream(input);
 
   StringPiece string_piece;
   EXPECT_TRUE(decoder_peer_.DecodeNextName(&input_stream, &string_piece));
   EXPECT_EQ("custom-key", string_piece);
   EXPECT_FALSE(input_stream.HasMoreData());
   EXPECT_FALSE(input_stream.NeedMoreData());
   input_stream.MarkCurrentPosition();
   EXPECT_EQ(input.size(), input_stream.ParsedBytes());
 }
 
 // Decode with incomplete huffman encoding.
 TEST_P(HpackDecoderTest, DecodeNextNameLiteralWithIncompleteHuffmanEncoding) {
   // CHECK(huffman_table_.Initialize(kHpackHuffmanCode,
   //                                 arraysize(kHpackHuffmanCode)));
   // Put two copies of the same huffman encoding into input.
   string input = a2b_hex("008825a849e95ba97d7f008825a849e95ba97d7f");
   input.resize(input.size() - 1);  // Remove the last byte.
-  HpackInputStream input_stream(kLiteralBound, input);
+  HpackInputStream input_stream(input);
 
   StringPiece string_piece;
   EXPECT_TRUE(decoder_peer_.DecodeNextName(&input_stream, &string_piece));
   EXPECT_FALSE(input_stream.NeedMoreData());
   input_stream.MarkCurrentPosition();
   EXPECT_EQ(10u, input_stream.ParsedBytes());
 
   EXPECT_FALSE(decoder_peer_.DecodeNextName(&input_stream, &string_piece));
   EXPECT_TRUE(input_stream.NeedMoreData());
   input_stream.MarkCurrentPosition();
   EXPECT_EQ(12u, input_stream.ParsedBytes());
 }
 
 // Decoding an encoded name with a valid index should work.
 TEST_P(HpackDecoderTest, DecodeNextNameIndexed) {
-  HpackInputStream input_stream(kLiteralBound, "\x01");
+  HpackInputStream input_stream("\x01");
 
   StringPiece string_piece;
   EXPECT_TRUE(decoder_peer_.DecodeNextName(&input_stream, &string_piece));
   EXPECT_EQ(":authority", string_piece);
   EXPECT_FALSE(input_stream.HasMoreData());
   EXPECT_FALSE(input_stream.NeedMoreData());
   input_stream.MarkCurrentPosition();
   EXPECT_EQ(1u, input_stream.ParsedBytes());
 }
 
 // Decoding an encoded name with an invalid index should fail.
 TEST_P(HpackDecoderTest, DecodeNextNameInvalidIndex) {
   // One more than the number of static table entries.
-  HpackInputStream input_stream(kLiteralBound, "\x3e");
+  HpackInputStream input_stream("\x3e");
 
   StringPiece string_piece;
   EXPECT_FALSE(decoder_peer_.DecodeNextName(&input_stream, &string_piece));
   EXPECT_FALSE(input_stream.NeedMoreData());
   input_stream.MarkCurrentPosition();
   EXPECT_EQ(1u, input_stream.ParsedBytes());
 }
 
 // Decoding indexed static table field should work.
 TEST_P(HpackDecoderTest, IndexedHeaderStatic) {
@@ skipping 227 matching lines @@
 TEST_P(HpackDecoderTest, LiteralHeaderNeverIndexedInvalidNameIndex) {
   // Name is the last static index. Works.
   EXPECT_TRUE(DecodeHeaderBlock(StringPiece("\x1f\x2e\x03ooo")));
   // Name is one beyond the last static index. Fails.
   EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\x1f\x2f\x03ooo")));
 }
 
 // Decode with incomplete string literal.
 TEST_P(HpackDecoderTest, StringLiteralIncomplete) {
   const char input[] = "\x0c/sample/path\x06:path2\x0e/sample/path/";
-  HpackInputStream input_stream(kLiteralBound, input);
+  HpackInputStream input_stream(input);
   StringPiece str;
   EXPECT_TRUE(
       decoder_peer_.DecodeNextStringLiteral(&input_stream, false, &str));
   EXPECT_FALSE(input_stream.NeedMoreData());
   input_stream.MarkCurrentPosition();
   EXPECT_EQ(13u, input_stream.ParsedBytes());
 
   EXPECT_TRUE(
       decoder_peer_.DecodeNextStringLiteral(&input_stream, false, &str));
   EXPECT_FALSE(input_stream.NeedMoreData());
@@ skipping 311 matching lines @@
               "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU;"
               " max-age=3600; version=1");
   expectEntry(63, 52, "content-encoding", "gzip");
   expectEntry(64, 65, "date", "Mon, 21 Oct 2013 20:13:22 GMT");
   EXPECT_EQ(215u, decoder_peer_.header_table()->size());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net