Implement better HPACK Huffman code decoder.

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 {
 
 using base::StringPiece;
 using std::string;
 using test::a2b_hex;
 
 const size_t kLiteralBound = 1024;
 
-class HpackInputStreamTest : public ::testing::Test {
- public:
-  void SetUp() override {
-    std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
-    EXPECT_TRUE(huffman_table_.Initialize(&code[0], code.size()));
-  }
-
- protected:
-  HpackHuffmanTable huffman_table_;
-};
-
 // 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 21 matching lines @@
 }
 
 uint32_t bits32(const string& bitstring) {
   return std::bitset<32>(bitstring).to_ulong();
 }
 
 // The {Number}ByteIntegersEightBitPrefix tests below test that
 // certain integers are decoded correctly with an 8-bit prefix in
 // exactly {Number} bytes.
 
-TEST_F(HpackInputStreamTest, OneByteIntegersEightBitPrefix) {
+TEST(HpackInputStreamTest, OneByteIntegersEightBitPrefix) {
   // Minimum.
   EXPECT_EQ(0x00u, DecodeValidUint32(8, string("\x00", 1)));
   EXPECT_EQ(0x7fu, DecodeValidUint32(8, "\x7f"));
   // Maximum.
   EXPECT_EQ(0xfeu, DecodeValidUint32(8, "\xfe"));
   // Invalid.
   ExpectDecodeUint32Invalid(8, "\xff");
 }
 
-TEST_F(HpackInputStreamTest, TwoByteIntegersEightBitPrefix) {
+TEST(HpackInputStreamTest, TwoByteIntegersEightBitPrefix) {
   // Minimum.
   EXPECT_EQ(0xffu, DecodeValidUint32(8, string("\xff\x00", 2)));
   EXPECT_EQ(0x0100u, DecodeValidUint32(8, "\xff\x01"));
   // Maximum.
   EXPECT_EQ(0x017eu, DecodeValidUint32(8, "\xff\x7f"));
   // Invalid.
   ExpectDecodeUint32Invalid(8, "\xff\x80");
   ExpectDecodeUint32Invalid(8, "\xff\xff");
 }
 
-TEST_F(HpackInputStreamTest, ThreeByteIntegersEightBitPrefix) {
+TEST(HpackInputStreamTest, ThreeByteIntegersEightBitPrefix) {
   // Minimum.
   EXPECT_EQ(0x017fu, DecodeValidUint32(8, "\xff\x80\x01"));
   EXPECT_EQ(0x0fffu, DecodeValidUint32(8, "\xff\x80\x1e"));
   // Maximum.
   EXPECT_EQ(0x40feu, DecodeValidUint32(8, "\xff\xff\x7f"));
   // Invalid.
   ExpectDecodeUint32Invalid(8, "\xff\x80\x00");
   ExpectDecodeUint32Invalid(8, "\xff\xff\x00");
   ExpectDecodeUint32Invalid(8, "\xff\xff\x80");
   ExpectDecodeUint32Invalid(8, "\xff\xff\xff");
 }
 
-TEST_F(HpackInputStreamTest, FourByteIntegersEightBitPrefix) {
+TEST(HpackInputStreamTest, FourByteIntegersEightBitPrefix) {
   // Minimum.
   EXPECT_EQ(0x40ffu, DecodeValidUint32(8, "\xff\x80\x80\x01"));
   EXPECT_EQ(0xffffu, DecodeValidUint32(8, "\xff\x80\xfe\x03"));
   // Maximum.
   EXPECT_EQ(0x002000feu, DecodeValidUint32(8, "\xff\xff\xff\x7f"));
   // Invalid.
   ExpectDecodeUint32Invalid(8, "\xff\xff\x80\x00");
   ExpectDecodeUint32Invalid(8, "\xff\xff\xff\x00");
   ExpectDecodeUint32Invalid(8, "\xff\xff\xff\x80");
   ExpectDecodeUint32Invalid(8, "\xff\xff\xff\xff");
 }
 
-TEST_F(HpackInputStreamTest, FiveByteIntegersEightBitPrefix) {
+TEST(HpackInputStreamTest, FiveByteIntegersEightBitPrefix) {
   // Minimum.
   EXPECT_EQ(0x002000ffu, DecodeValidUint32(8, "\xff\x80\x80\x80\x01"));
   EXPECT_EQ(0x00ffffffu, DecodeValidUint32(8, "\xff\x80\xfe\xff\x07"));
   // Maximum.
   EXPECT_EQ(0x100000feu, DecodeValidUint32(8, "\xff\xff\xff\xff\x7f"));
   // Invalid.
   ExpectDecodeUint32Invalid(8, "\xff\xff\xff\x80\x00");
   ExpectDecodeUint32Invalid(8, "\xff\xff\xff\xff\x00");
   ExpectDecodeUint32Invalid(8, "\xff\xff\xff\xff\x80");
   ExpectDecodeUint32Invalid(8, "\xff\xff\xff\xff\xff");
 }
 
-TEST_F(HpackInputStreamTest, SixByteIntegersEightBitPrefix) {
+TEST(HpackInputStreamTest, SixByteIntegersEightBitPrefix) {
   // Minimum.
   EXPECT_EQ(0x100000ffu, DecodeValidUint32(8, "\xff\x80\x80\x80\x80\x01"));
   // Maximum.
   EXPECT_EQ(0xffffffffu, DecodeValidUint32(8, "\xff\x80\xfe\xff\xff\x0f"));
   // Invalid.
   ExpectDecodeUint32Invalid(8, "\xff\x80\x80\x80\x80\x00");
   ExpectDecodeUint32Invalid(8, "\xff\x80\xfe\xff\xff\x10");
   ExpectDecodeUint32Invalid(8, "\xff\xff\xff\xff\xff\xff");
 }
 
 // There are no valid uint32_t encodings that are greater than six
 // bytes.
-TEST_F(HpackInputStreamTest, SevenByteIntegersEightBitPrefix) {
+TEST(HpackInputStreamTest, SevenByteIntegersEightBitPrefix) {
   ExpectDecodeUint32Invalid(8, "\xff\x80\x80\x80\x80\x80\x00");
   ExpectDecodeUint32Invalid(8, "\xff\x80\x80\x80\x80\x80\x01");
   ExpectDecodeUint32Invalid(8, "\xff\xff\xff\xff\xff\xff\xff");
 }
 
 // The {Number}ByteIntegersOneToSevenBitPrefix tests below test that
 // certain integers are encoded correctly with an N-bit prefix in
 // exactly {Number} bytes for N in {1, 2, ..., 7}.
 
-TEST_F(HpackInputStreamTest, OneByteIntegersOneToSevenBitPrefixes) {
+TEST(HpackInputStreamTest, OneByteIntegersOneToSevenBitPrefixes) {
   // Minimums.
   EXPECT_EQ(0x00u, DecodeValidUint32(7, string("\x00", 1)));
   EXPECT_EQ(0x00u, DecodeValidUint32(7, "\x80"));
   EXPECT_EQ(0x00u, DecodeValidUint32(6, string("\x00", 1)));
   EXPECT_EQ(0x00u, DecodeValidUint32(6, "\xc0"));
   EXPECT_EQ(0x00u, DecodeValidUint32(5, string("\x00", 1)));
   EXPECT_EQ(0x00u, DecodeValidUint32(5, "\xe0"));
   EXPECT_EQ(0x00u, DecodeValidUint32(4, string("\x00", 1)));
   EXPECT_EQ(0x00u, DecodeValidUint32(4, "\xf0"));
   EXPECT_EQ(0x00u, DecodeValidUint32(3, string("\x00", 1)));
@@ skipping 29 matching lines @@
   ExpectDecodeUint32Invalid(4, "\x0f");
   ExpectDecodeUint32Invalid(4, "\xff");
   ExpectDecodeUint32Invalid(3, "\x07");
   ExpectDecodeUint32Invalid(3, "\xff");
   ExpectDecodeUint32Invalid(2, "\x03");
   ExpectDecodeUint32Invalid(2, "\xff");
   ExpectDecodeUint32Invalid(1, "\x01");
   ExpectDecodeUint32Invalid(1, "\xff");
 }
 
-TEST_F(HpackInputStreamTest, TwoByteIntegersOneToSevenBitPrefixes) {
+TEST(HpackInputStreamTest, TwoByteIntegersOneToSevenBitPrefixes) {
   // Minimums.
   EXPECT_EQ(0x7fu, DecodeValidUint32(7, string("\x7f\x00", 2)));
   EXPECT_EQ(0x7fu, DecodeValidUint32(7, string("\xff\x00", 2)));
   EXPECT_EQ(0x3fu, DecodeValidUint32(6, string("\x3f\x00", 2)));
   EXPECT_EQ(0x3fu, DecodeValidUint32(6, string("\xff\x00", 2)));
   EXPECT_EQ(0x1fu, DecodeValidUint32(5, string("\x1f\x00", 2)));
   EXPECT_EQ(0x1fu, DecodeValidUint32(5, string("\xff\x00", 2)));
   EXPECT_EQ(0x0fu, DecodeValidUint32(4, string("\x0f\x00", 2)));
   EXPECT_EQ(0x0fu, DecodeValidUint32(4, string("\xff\x00", 2)));
   EXPECT_EQ(0x07u, DecodeValidUint32(3, string("\x07\x00", 2)));
@@ skipping 29 matching lines @@
   ExpectDecodeUint32Invalid(4, "\x0f\x80");
   ExpectDecodeUint32Invalid(4, "\xff\xff");
   ExpectDecodeUint32Invalid(3, "\x07\x80");
   ExpectDecodeUint32Invalid(3, "\xff\xff");
   ExpectDecodeUint32Invalid(2, "\x03\x80");
   ExpectDecodeUint32Invalid(2, "\xff\xff");
   ExpectDecodeUint32Invalid(1, "\x01\x80");
   ExpectDecodeUint32Invalid(1, "\xff\xff");
 }
 
-TEST_F(HpackInputStreamTest, ThreeByteIntegersOneToSevenBitPrefixes) {
+TEST(HpackInputStreamTest, ThreeByteIntegersOneToSevenBitPrefixes) {
   // Minimums.
   EXPECT_EQ(0xffu, DecodeValidUint32(7, "\x7f\x80\x01"));
   EXPECT_EQ(0xffu, DecodeValidUint32(7, "\xff\x80\x01"));
   EXPECT_EQ(0xbfu, DecodeValidUint32(6, "\x3f\x80\x01"));
   EXPECT_EQ(0xbfu, DecodeValidUint32(6, "\xff\x80\x01"));
   EXPECT_EQ(0x9fu, DecodeValidUint32(5, "\x1f\x80\x01"));
   EXPECT_EQ(0x9fu, DecodeValidUint32(5, "\xff\x80\x01"));
   EXPECT_EQ(0x8fu, DecodeValidUint32(4, "\x0f\x80\x01"));
   EXPECT_EQ(0x8fu, DecodeValidUint32(4, "\xff\x80\x01"));
   EXPECT_EQ(0x87u, DecodeValidUint32(3, "\x07\x80\x01"));
@@ skipping 29 matching lines @@
   ExpectDecodeUint32Invalid(4, "\x0f\xff\x80");
   ExpectDecodeUint32Invalid(4, "\xff\xff\xff");
   ExpectDecodeUint32Invalid(3, "\x07\xff\x80");
   ExpectDecodeUint32Invalid(3, "\xff\xff\xff");
   ExpectDecodeUint32Invalid(2, "\x03\xff\x80");
   ExpectDecodeUint32Invalid(2, "\xff\xff\xff");
   ExpectDecodeUint32Invalid(1, "\x01\xff\x80");
   ExpectDecodeUint32Invalid(1, "\xff\xff\xff");
 }
 
-TEST_F(HpackInputStreamTest, FourByteIntegersOneToSevenBitPrefixes) {
+TEST(HpackInputStreamTest, FourByteIntegersOneToSevenBitPrefixes) {
   // Minimums.
   EXPECT_EQ(0x407fu, DecodeValidUint32(7, "\x7f\x80\x80\x01"));
   EXPECT_EQ(0x407fu, DecodeValidUint32(7, "\xff\x80\x80\x01"));
   EXPECT_EQ(0x403fu, DecodeValidUint32(6, "\x3f\x80\x80\x01"));
   EXPECT_EQ(0x403fu, DecodeValidUint32(6, "\xff\x80\x80\x01"));
   EXPECT_EQ(0x401fu, DecodeValidUint32(5, "\x1f\x80\x80\x01"));
   EXPECT_EQ(0x401fu, DecodeValidUint32(5, "\xff\x80\x80\x01"));
   EXPECT_EQ(0x400fu, DecodeValidUint32(4, "\x0f\x80\x80\x01"));
   EXPECT_EQ(0x400fu, DecodeValidUint32(4, "\xff\x80\x80\x01"));
   EXPECT_EQ(0x4007u, DecodeValidUint32(3, "\x07\x80\x80\x01"));
@@ skipping 29 matching lines @@
   ExpectDecodeUint32Invalid(4, "\x0f\xff\xff\x80");
   ExpectDecodeUint32Invalid(4, "\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(3, "\x07\xff\xff\x80");
   ExpectDecodeUint32Invalid(3, "\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(2, "\x03\xff\xff\x80");
   ExpectDecodeUint32Invalid(2, "\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(1, "\x01\xff\xff\x80");
   ExpectDecodeUint32Invalid(1, "\xff\xff\xff\xff");
 }
 
-TEST_F(HpackInputStreamTest, FiveByteIntegersOneToSevenBitPrefixes) {
+TEST(HpackInputStreamTest, FiveByteIntegersOneToSevenBitPrefixes) {
   // Minimums.
   EXPECT_EQ(0x20007fu, DecodeValidUint32(7, "\x7f\x80\x80\x80\x01"));
   EXPECT_EQ(0x20007fu, DecodeValidUint32(7, "\xff\x80\x80\x80\x01"));
   EXPECT_EQ(0x20003fu, DecodeValidUint32(6, "\x3f\x80\x80\x80\x01"));
   EXPECT_EQ(0x20003fu, DecodeValidUint32(6, "\xff\x80\x80\x80\x01"));
   EXPECT_EQ(0x20001fu, DecodeValidUint32(5, "\x1f\x80\x80\x80\x01"));
   EXPECT_EQ(0x20001fu, DecodeValidUint32(5, "\xff\x80\x80\x80\x01"));
   EXPECT_EQ(0x20000fu, DecodeValidUint32(4, "\x0f\x80\x80\x80\x01"));
   EXPECT_EQ(0x20000fu, DecodeValidUint32(4, "\xff\x80\x80\x80\x01"));
   EXPECT_EQ(0x200007u, DecodeValidUint32(3, "\x07\x80\x80\x80\x01"));
@@ skipping 29 matching lines @@
   ExpectDecodeUint32Invalid(4, "\x0f\xff\xff\xff\x80");
   ExpectDecodeUint32Invalid(4, "\xff\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(3, "\x07\xff\xff\xff\x80");
   ExpectDecodeUint32Invalid(3, "\xff\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(2, "\x03\xff\xff\xff\x80");
   ExpectDecodeUint32Invalid(2, "\xff\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(1, "\x01\xff\xff\xff\x80");
   ExpectDecodeUint32Invalid(1, "\xff\xff\xff\xff\xff");
 }
 
-TEST_F(HpackInputStreamTest, SixByteIntegersOneToSevenBitPrefixes) {
+TEST(HpackInputStreamTest, SixByteIntegersOneToSevenBitPrefixes) {
   // Minimums.
   EXPECT_EQ(0x1000007fu, DecodeValidUint32(7, "\x7f\x80\x80\x80\x80\x01"));
   EXPECT_EQ(0x1000007fu, DecodeValidUint32(7, "\xff\x80\x80\x80\x80\x01"));
   EXPECT_EQ(0x1000003fu, DecodeValidUint32(6, "\x3f\x80\x80\x80\x80\x01"));
   EXPECT_EQ(0x1000003fu, DecodeValidUint32(6, "\xff\x80\x80\x80\x80\x01"));
   EXPECT_EQ(0x1000001fu, DecodeValidUint32(5, "\x1f\x80\x80\x80\x80\x01"));
   EXPECT_EQ(0x1000001fu, DecodeValidUint32(5, "\xff\x80\x80\x80\x80\x01"));
   EXPECT_EQ(0x1000000fu, DecodeValidUint32(4, "\x0f\x80\x80\x80\x80\x01"));
   EXPECT_EQ(0x1000000fu, DecodeValidUint32(4, "\xff\x80\x80\x80\x80\x01"));
   EXPECT_EQ(0x10000007u, DecodeValidUint32(3, "\x07\x80\x80\x80\x80\x01"));
@@ skipping 31 matching lines @@
   ExpectDecodeUint32Invalid(3, "\x07\xf8\xff\xff\xff\x10");
   ExpectDecodeUint32Invalid(3, "\xff\xf8\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(2, "\x03\xfc\xff\xff\xff\x10");
   ExpectDecodeUint32Invalid(2, "\xff\xfc\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(1, "\x01\xfe\xff\xff\xff\x10");
   ExpectDecodeUint32Invalid(1, "\xff\xfe\xff\xff\xff\xff");
 }
 
 // There are no valid uint32_t encodings that are greater than six
 // bytes.
-TEST_F(HpackInputStreamTest, SevenByteIntegersOneToSevenBitPrefixes) {
+TEST(HpackInputStreamTest, SevenByteIntegersOneToSevenBitPrefixes) {
   ExpectDecodeUint32Invalid(7, "\x7f\x80\x80\x80\x80\x80\x00");
   ExpectDecodeUint32Invalid(7, "\x7f\x80\x80\x80\x80\x80\x01");
   ExpectDecodeUint32Invalid(7, "\xff\xff\xff\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(6, "\x3f\x80\x80\x80\x80\x80\x00");
   ExpectDecodeUint32Invalid(6, "\x3f\x80\x80\x80\x80\x80\x01");
   ExpectDecodeUint32Invalid(6, "\xff\xff\xff\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(5, "\x1f\x80\x80\x80\x80\x80\x00");
   ExpectDecodeUint32Invalid(5, "\x1f\x80\x80\x80\x80\x80\x01");
   ExpectDecodeUint32Invalid(5, "\xff\xff\xff\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(4, "\x0f\x80\x80\x80\x80\x80\x00");
   ExpectDecodeUint32Invalid(4, "\x0f\x80\x80\x80\x80\x80\x01");
   ExpectDecodeUint32Invalid(4, "\xff\xff\xff\xff\xff\xff\xff");
   ExpectDecodeUint32Invalid(3, "\x07\x80\x80\x80\x80\x80\x00");
   ExpectDecodeUint32Invalid(3, "\x07\x80\x80\x80\x80\x80\x01");
   ExpectDecodeUint32Invalid(3, "\xff\xff\xff\xff\xff\xff\xff");
   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_F(HpackInputStreamTest, DecodeNextIdentityString) {
+TEST(HpackInputStreamTest, DecodeNextIdentityString) {
   HpackInputStream input_stream(kLiteralBound, "\x0estring literal");
 
   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());
 }
 
 // Decoding an encoded string literal with size larger than
 // |max_string_literal_size_| should fail.
-TEST_F(HpackInputStreamTest, DecodeNextIdentityStringSizeLimit) {
+TEST(HpackInputStreamTest, DecodeNextIdentityStringSizeLimit) {
   HpackInputStream input_stream(13, "\x0estring literal");
 
   EXPECT_TRUE(input_stream.HasMoreData());
   StringPiece string_piece;
   EXPECT_FALSE(input_stream.DecodeNextIdentityString(&string_piece));
 }
 
 // Decoding an encoded string literal with size larger than the
 // remainder of the buffer should fail.
-TEST_F(HpackInputStreamTest, DecodeNextIdentityStringNotEnoughInput) {
+TEST(HpackInputStreamTest, DecodeNextIdentityStringNotEnoughInput) {
   // Set the length to be one more than it should be.
   HpackInputStream input_stream(kLiteralBound, "\x0fstring literal");
 
   EXPECT_TRUE(input_stream.HasMoreData());
   StringPiece string_piece;
   EXPECT_FALSE(input_stream.DecodeNextIdentityString(&string_piece));
 }
 
-TEST_F(HpackInputStreamTest, DecodeNextHuffmanString) {
+TEST(HpackInputStreamTest, DecodeNextHuffmanString) {
   string output, input(a2b_hex(kEncodedHuffmanFixture));
   HpackInputStream input_stream(arraysize(kDecodedHuffmanFixture) - 1, input);
 
   EXPECT_TRUE(input_stream.HasMoreData());
-  EXPECT_TRUE(input_stream.DecodeNextHuffmanString(huffman_table_, &output));
+  EXPECT_TRUE(input_stream.DecodeNextHuffmanString(&output));
   EXPECT_EQ(kDecodedHuffmanFixture, output);
   EXPECT_FALSE(input_stream.HasMoreData());
 }
 
-TEST_F(HpackInputStreamTest, DecodeNextHuffmanStringSizeLimit) {
+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(huffman_table_, &output));
+  EXPECT_FALSE(input_stream.DecodeNextHuffmanString(&output));
 }
 
-TEST_F(HpackInputStreamTest, DecodeNextHuffmanStringNotEnoughInput) {
+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);
 
   // Not enough buffer for declared encoded length.
   EXPECT_TRUE(input_stream.HasMoreData());
-  EXPECT_FALSE(input_stream.DecodeNextHuffmanString(huffman_table_, &output));
+  EXPECT_FALSE(input_stream.DecodeNextHuffmanString(&output));
 }
 
-TEST_F(HpackInputStreamTest, PeekBitsAndConsume) {
+TEST(HpackInputStreamTest, PeekBitsAndConsume) {
   HpackInputStream input_stream(kLiteralBound, "\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);
 
@@ skipping 41 matching lines @@
 
   // EOF.
   EXPECT_FALSE(input_stream.PeekBits(&peeked_count, &bits));
   EXPECT_EQ(bits32("10101101000000000000000000000000"), bits);
   EXPECT_EQ(8u, peeked_count);
 
   input_stream.ConsumeBits(8);
   EXPECT_FALSE(input_stream.HasMoreData());
 }
 
-TEST_F(HpackInputStreamTest, ConsumeByteRemainder) {
+TEST(HpackInputStreamTest, InitializePeekBits) {
+  {
+    // Empty input, peeked_count == 0 and bits == 0.
+    HpackInputStream input_stream(kLiteralBound, "");
+    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");
+    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");
+    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");
+    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");
+    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");
+    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_DFATAL(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");
   // 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());
 }
 
 }  // namespace
 
 }  // namespace net