Implements incremental decode in HPACK.

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 19 matching lines @@
   void HandleHeaderRepresentation(StringPiece name, StringPiece value) {
     decoder_->HandleHeaderRepresentation(name, value);
   }
   bool DecodeNextName(HpackInputStream* in, StringPiece* out) {
     return decoder_->DecodeNextName(in, out);
   }
   HpackHeaderTable* header_table() { return &decoder_->header_table_; }
   const SpdyHeaderBlock& decoded_block() const {
     return decoder_->decoded_block_;
   }
+
+  bool DecodeNextStringLiteral(HpackInputStream* in,
+                               bool is_header_key,
+                               StringPiece* str) {
+    return decoder_->DecodeNextStringLiteral(in, is_header_key, str);
+  }
+
   const string& headers_block_buffer() const {
     return decoder_->headers_block_buffer_;
   }
 
  private:
   HpackDecoder* decoder_;
 };
 
 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 (GetParam()) {
+    if (handler_exists_) {
       decoder_.HandleControlFrameHeadersStart(&handler_);
     }
     return decoder_.HandleControlFrameHeadersData(str.data(), str.size()) &&
            decoder_.HandleControlFrameHeadersComplete(nullptr);
   }
 
+  bool HandleControlFrameHeadersData(StringPiece str) {
+    return decoder_.HandleControlFrameHeadersData(str.data(), str.size());
+  }
+
+  bool HandleControlFrameHeadersComplete(size_t* size) {
+    return decoder_.HandleControlFrameHeadersComplete(size);
+  }
+
   const SpdyHeaderBlock& decoded_block() const {
-    if (GetParam()) {
+    if (handler_exists_) {
       return handler_.decoded_block();
     } else {
       return decoder_peer_.decoded_block();
     }
   }
 
   const SpdyHeaderBlock& DecodeBlockExpectingSuccess(StringPiece str) {
     EXPECT_TRUE(DecodeHeaderBlock(str));
     return decoded_block();
   }
 
   void expectEntry(size_t index,
                    size_t size,
                    const string& name,
                    const string& value) {
     const HpackEntry* entry = decoder_peer_.header_table()->GetByIndex(index);
     EXPECT_EQ(name, entry->name()) << "index " << index;
     EXPECT_EQ(value, entry->value());
     EXPECT_EQ(size, entry->Size());
     EXPECT_EQ(index, decoder_peer_.header_table()->IndexOf(entry));
   }
 
   HpackDecoder decoder_;
   test::HpackDecoderPeer decoder_peer_;
   TestHeadersHandler handler_;
+  bool handler_exists_;
 };
 
 INSTANTIATE_TEST_CASE_P(WithAndWithoutHeadersHandler,
                         HpackDecoderTest,
                         ::testing::Bool());
 
-TEST_P(HpackDecoderTest, HandleControlFrameHeadersData) {
+TEST_P(HpackDecoderTest, AddHeaderDataWithHandleControlFrameHeadersData) {
   // Strings under threshold are concatenated in the buffer.
   EXPECT_TRUE(decoder_.HandleControlFrameHeadersData("small string one", 16));
   EXPECT_TRUE(decoder_.HandleControlFrameHeadersData("small string two", 16));
   // A string which would push the buffer over the threshold is refused.
   EXPECT_FALSE(decoder_.HandleControlFrameHeadersData(
       "fails", kMaxDecodeBufferSize - 32 + 1));
 
   EXPECT_EQ(decoder_peer_.headers_block_buffer(),
             "small string onesmall string two");
 }
 
+// Decode with incomplete data in buffer.
+TEST_P(HpackDecoderTest, DecodeWithIncompleteData) {
+  // No need to wait for more data.
+  EXPECT_TRUE(HandleControlFrameHeadersData("\x82\x85\x82"));
+  EXPECT_EQ("", decoder_peer_.headers_block_buffer());
+
+  // Need to wait for more data.
+  EXPECT_TRUE(
+      HandleControlFrameHeadersData("\x40\x03goo"
+                                    "\x03gar\xbe\x40\x04spam"));
+  EXPECT_EQ("\x40\x04spam", decoder_peer_.headers_block_buffer());
+
+  // Add the needed data.
+  EXPECT_TRUE(HandleControlFrameHeadersData("\x04gggs"));
+  EXPECT_EQ("", decoder_peer_.headers_block_buffer());
+
+  size_t size = 0;
+  EXPECT_TRUE(HandleControlFrameHeadersComplete(&size));
+  EXPECT_EQ(24u, size);
+}
+
 TEST_P(HpackDecoderTest, HandleHeaderRepresentation) {
-  if (GetParam()) {
+  if (handler_exists_) {
     decoder_.HandleControlFrameHeadersStart(&handler_);
   }
 
   // All cookie crumbs are joined.
   decoder_peer_.HandleHeaderRepresentation("cookie", " part 1");
   decoder_peer_.HandleHeaderRepresentation("cookie", "part 2 ");
   decoder_peer_.HandleHeaderRepresentation("cookie", "part3");
 
   // Already-delimited headers are passed through.
   decoder_peer_.HandleHeaderRepresentation("passed-through",
@@ skipping 30 matching lines @@
 }
 
 // Decoding an encoded name with a valid string literal should work.
 TEST_P(HpackDecoderTest, DecodeNextNameLiteral) {
   HpackInputStream input_stream(kLiteralBound, 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));
+
+  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);
 
   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);
+
+  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");
 
   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");
 
   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) {
   // Reference static table entries #2 and #5.
   SpdyHeaderBlock header_set1 = DecodeBlockExpectingSuccess("\x82\x85");
   SpdyHeaderBlock expected_header_set1;
   expected_header_set1[":method"] = "GET";
   expected_header_set1[":path"] = "/index.html";
   EXPECT_EQ(expected_header_set1, header_set1);
@@ skipping 139 matching lines @@
   EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\x0f\x2f\x03ooo")));
 }
 
 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);
+  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());
+  input_stream.MarkCurrentPosition();
+  EXPECT_EQ(20u, input_stream.ParsedBytes());
+
+  EXPECT_FALSE(
+      decoder_peer_.DecodeNextStringLiteral(&input_stream, false, &str));
+  EXPECT_TRUE(input_stream.NeedMoreData());
+  input_stream.MarkCurrentPosition();
+  EXPECT_EQ(21u, input_stream.ParsedBytes());
+}
+
 // Round-tripping the header set from E.2.1 should work.
 TEST_P(HpackDecoderTest, BasicE21) {
   HpackEncoder encoder(ObtainHpackHuffmanTable());
 
   SpdyHeaderBlock expected_header_set;
   expected_header_set[":method"] = "GET";
   expected_header_set[":scheme"] = "http";
   expected_header_set[":path"] = "/";
   expected_header_set[":authority"] = "www.example.com";
 
@@ skipping 291 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