Revert of Add new HTTP/2 and HPACK decoder in net/http2/.

net/http2/hpack/huffman/http2_hpack_huffman_decoder.cc

Index: net/http2/hpack/huffman/http2_hpack_huffman_decoder.cc
diff --git a/net/http2/hpack/huffman/http2_hpack_huffman_decoder.cc b/net/http2/hpack/huffman/http2_hpack_huffman_decoder.cc
deleted file mode 100644
index 45c32c08b229a526746e7a91a70a3277c460ebba..0000000000000000000000000000000000000000
--- a/net/http2/hpack/huffman/http2_hpack_huffman_decoder.cc
+++ /dev/null
@@ -1,542 +0,0 @@
-// 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/http2/hpack/huffman/http2_hpack_huffman_decoder.h"
-
-#include <bitset>
-#include <limits>
-
-#include "base/logging.h"
-
-using base::StringPiece;
-using std::string;
-
-// Terminology:
-//
-// Symbol - a plain text (unencoded) character (uint8), or the End-of-String
-//          (EOS) symbol, 256.
-//
-// Code - the sequence of bits used to encode a symbol, varying in length from
-//        5 bits for the most common symbols (e.g. '0', '1', and 'a'), to
-//        30 bits for the least common (e.g. the EOS symbol).
-//        For those symbols whose codes have the same length, their code values
-//        are sorted such that the lower symbol value has a lower code value.
-//
-// Canonical - a symbol's cardinal value when sorted first by code length, and
-//             then by symbol value. For example, canonical 0 is for ASCII '0'
-//             (uint8 value 0x30), which is the first of the symbols whose code
-//             is 5 bits long, and the last canonical is EOS, which is the last
-//             of the symbols whose code is 30 bits long.
-
-// TODO(jamessynge): Remove use of binary literals, that is a C++ 14 feature.
-
-namespace net {
-namespace {
-
-// HuffmanCode is used to store the codes associated with symbols (a pattern of
-// from 5 to 30 bits).
-typedef uint32_t HuffmanCode;
-
-// HuffmanCodeBitCount is used to store a count of bits in a code.
-typedef uint16_t HuffmanCodeBitCount;
-
-// HuffmanCodeBitSet is used for producing a string version of a code because
-// std::bitset logs nicely.
-typedef std::bitset<32> HuffmanCodeBitSet;
-typedef std::bitset<64> HuffmanAccumulatorBitSet;
-
-static constexpr HuffmanCodeBitCount kMinCodeBitCount = 5;
-static constexpr HuffmanCodeBitCount kMaxCodeBitCount = 30;
-static constexpr HuffmanCodeBitCount kHuffmanCodeBitCount =
-    std::numeric_limits<HuffmanCode>::digits;
-
-static_assert(std::numeric_limits<HuffmanCode>::digits >= kMaxCodeBitCount,
-              "HuffmanCode isn't big enough.");
-
-static_assert(std::numeric_limits<HuffmanAccumulator>::digits >=
-                  kMaxCodeBitCount,
-              "HuffmanAccumulator isn't big enough.");
-
-static constexpr HuffmanAccumulatorBitCount kHuffmanAccumulatorBitCount =
-    std::numeric_limits<HuffmanAccumulator>::digits;
-static constexpr HuffmanAccumulatorBitCount kExtraAccumulatorBitCount =
-    kHuffmanAccumulatorBitCount - kHuffmanCodeBitCount;
-
-// PrefixInfo holds info about a group of codes that are all of the same length.
-struct PrefixInfo {
-  // Given the leading bits (32 in this case) of the encoded string, and that
-  // they start with a code of length |code_length|, return the corresponding
-  // canonical for that leading code.
-  uint32_t DecodeToCanonical(HuffmanCode bits) const {
-    // What is the position of the canonical symbol being decoded within
-    // the canonical symbols of |length|?
-    HuffmanCode ordinal_in_length =
-        ((bits - first_code) >> (kHuffmanCodeBitCount - code_length));
-
-    // Combined with |canonical| to produce the position of the canonical symbol
-    // being decoded within all of the canonical symbols.
-    return first_canonical + ordinal_in_length;
-  }
-
-  const HuffmanCode first_code;  // First code of this length, left justified in
-                                 // the field (i.e. the first bit of the code is
-                                 // the high-order bit).
-  const uint16_t code_length;    // Length of the prefix code |base|.
-  const uint16_t first_canonical;  // First canonical symbol of this length.
-};
-
-inline std::ostream& operator<<(std::ostream& out, const PrefixInfo& v) {
-  return out << "{first_code: " << HuffmanCodeBitSet(v.first_code)
-             << ", code_length: " << v.code_length
-             << ", first_canonical: " << v.first_canonical << "}";
-}
-
-// Given |value|, a sequence of the leading bits remaining to be decoded,
-// figure out which group of canonicals (by code length) that value starts
-// with. This function was generated.
-PrefixInfo PrefixToInfo(HuffmanCode value) {
-  if (value < 0b10111000000000000000000000000000) {
-    if (value < 0b01010000000000000000000000000000) {
-      return {0b00000000000000000000000000000000, 5, 0};
-    } else {
-      return {0b01010000000000000000000000000000, 6, 10};
-    }
-  } else {
-    if (value < 0b11111110000000000000000000000000) {
-      if (value < 0b11111000000000000000000000000000) {
-        return {0b10111000000000000000000000000000, 7, 36};
-      } else {
-        return {0b11111000000000000000000000000000, 8, 68};
-      }
-    } else {
-      if (value < 0b11111111110000000000000000000000) {
-        if (value < 0b11111111101000000000000000000000) {
-          if (value < 0b11111111010000000000000000000000) {
-            return {0b11111110000000000000000000000000, 10, 74};
-          } else {
-            return {0b11111111010000000000000000000000, 11, 79};
-          }
-        } else {
-          return {0b11111111101000000000000000000000, 12, 82};
-        }
-      } else {
-        if (value < 0b11111111111111100000000000000000) {
-          if (value < 0b11111111111110000000000000000000) {
-            if (value < 0b11111111111100000000000000000000) {
-              return {0b11111111110000000000000000000000, 13, 84};
-            } else {
-              return {0b11111111111100000000000000000000, 14, 90};
-            }
-          } else {
-            return {0b11111111111110000000000000000000, 15, 92};
-          }
-        } else {
-          if (value < 0b11111111111111110100100000000000) {
-            if (value < 0b11111111111111101110000000000000) {
-              if (value < 0b11111111111111100110000000000000) {
-                return {0b11111111111111100000000000000000, 19, 95};
-              } else {
-                return {0b11111111111111100110000000000000, 20, 98};
-              }
-            } else {
-              return {0b11111111111111101110000000000000, 21, 106};
-            }
-          } else {
-            if (value < 0b11111111111111111110101000000000) {
-              if (value < 0b11111111111111111011000000000000) {
-                return {0b11111111111111110100100000000000, 22, 119};
-              } else {
-                return {0b11111111111111111011000000000000, 23, 145};
-              }
-            } else {
-              if (value < 0b11111111111111111111101111000000) {
-                if (value < 0b11111111111111111111100000000000) {
-                  if (value < 0b11111111111111111111011000000000) {
-                    return {0b11111111111111111110101000000000, 24, 174};
-                  } else {
-                    return {0b11111111111111111111011000000000, 25, 186};
-                  }
-                } else {
-                  return {0b11111111111111111111100000000000, 26, 190};
-                }
-              } else {
-                if (value < 0b11111111111111111111111111110000) {
-                  if (value < 0b11111111111111111111111000100000) {
-                    return {0b11111111111111111111101111000000, 27, 205};
-                  } else {
-                    return {0b11111111111111111111111000100000, 28, 224};
-                  }
-                } else {
-                  return {0b11111111111111111111111111110000, 30, 253};
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-// Mapping from canonical symbol (0 to 255) to actual symbol.
-// clang-format off
-constexpr unsigned char kCanonicalToSymbol[] = {
-    '0',  '1',  '2',  'a',  'c',  'e',  'i',  'o',
-    's',  't',  0x20, '%',  '-',  '.',  '/',  '3',
-    '4',  '5',  '6',  '7',  '8',  '9',  '=',  'A',
-    '_',  'b',  'd',  'f',  'g',  'h',  'l',  'm',
-    'n',  'p',  'r',  'u',  ':',  'B',  'C',  'D',
-    'E',  'F',  'G',  'H',  'I',  'J',  'K',  'L',
-    'M',  'N',  'O',  'P',  'Q',  'R',  'S',  'T',
-    'U',  'V',  'W',  'Y',  'j',  'k',  'q',  'v',
-    'w',  'x',  'y',  'z',  '&',  '*',  ',',  ';',
-    'X',  'Z',  '!',  '\"', '(',  ')',  '?',  '\'',
-    '+',  '|',  '#',  '>',  0x00, '$',  '@',  '[',
-    ']',  '~',  '^',  '}',  '<',  '`',  '{',  '\\',
-    0xc3, 0xd0, 0x80, 0x82, 0x83, 0xa2, 0xb8, 0xc2,
-    0xe0, 0xe2, 0x99, 0xa1, 0xa7, 0xac, 0xb0, 0xb1,
-    0xb3, 0xd1, 0xd8, 0xd9, 0xe3, 0xe5, 0xe6, 0x81,
-    0x84, 0x85, 0x86, 0x88, 0x92, 0x9a, 0x9c, 0xa0,
-    0xa3, 0xa4, 0xa9, 0xaa, 0xad, 0xb2, 0xb5, 0xb9,
-    0xba, 0xbb, 0xbd, 0xbe, 0xc4, 0xc6, 0xe4, 0xe8,
-    0xe9, 0x01, 0x87, 0x89, 0x8a, 0x8b, 0x8c, 0x8d,
-    0x8f, 0x93, 0x95, 0x96, 0x97, 0x98, 0x9b, 0x9d,
-    0x9e, 0xa5, 0xa6, 0xa8, 0xae, 0xaf, 0xb4, 0xb6,
-    0xb7, 0xbc, 0xbf, 0xc5, 0xe7, 0xef, 0x09, 0x8e,
-    0x90, 0x91, 0x94, 0x9f, 0xab, 0xce, 0xd7, 0xe1,
-    0xec, 0xed, 0xc7, 0xcf, 0xea, 0xeb, 0xc0, 0xc1,
-    0xc8, 0xc9, 0xca, 0xcd, 0xd2, 0xd5, 0xda, 0xdb,
-    0xee, 0xf0, 0xf2, 0xf3, 0xff, 0xcb, 0xcc, 0xd3,
-    0xd4, 0xd6, 0xdd, 0xde, 0xdf, 0xf1, 0xf4, 0xf5,
-    0xf6, 0xf7, 0xf8, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe,
-    0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0b,
-    0x0c, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
-    0x15, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
-    0x1e, 0x1f, 0x7f, 0xdc, 0xf9, 0x0a, 0x0d, 0x16,
-};
-// clang-format on
-
-constexpr size_t kShortCodeTableSize = 124;
-struct ShortCodeInfo {
-  uint8_t symbol;
-  uint8_t length;
-} kShortCodeTable[kShortCodeTableSize] = {
-    {0x30, 5},  // Match: 0b0000000, Symbol: 0
-    {0x30, 5},  // Match: 0b0000001, Symbol: 0
-    {0x30, 5},  // Match: 0b0000010, Symbol: 0
-    {0x30, 5},  // Match: 0b0000011, Symbol: 0
-    {0x31, 5},  // Match: 0b0000100, Symbol: 1
-    {0x31, 5},  // Match: 0b0000101, Symbol: 1
-    {0x31, 5},  // Match: 0b0000110, Symbol: 1
-    {0x31, 5},  // Match: 0b0000111, Symbol: 1
-    {0x32, 5},  // Match: 0b0001000, Symbol: 2
-    {0x32, 5},  // Match: 0b0001001, Symbol: 2
-    {0x32, 5},  // Match: 0b0001010, Symbol: 2
-    {0x32, 5},  // Match: 0b0001011, Symbol: 2
-    {0x61, 5},  // Match: 0b0001100, Symbol: a
-    {0x61, 5},  // Match: 0b0001101, Symbol: a
-    {0x61, 5},  // Match: 0b0001110, Symbol: a
-    {0x61, 5},  // Match: 0b0001111, Symbol: a
-    {0x63, 5},  // Match: 0b0010000, Symbol: c
-    {0x63, 5},  // Match: 0b0010001, Symbol: c
-    {0x63, 5},  // Match: 0b0010010, Symbol: c
-    {0x63, 5},  // Match: 0b0010011, Symbol: c
-    {0x65, 5},  // Match: 0b0010100, Symbol: e
-    {0x65, 5},  // Match: 0b0010101, Symbol: e
-    {0x65, 5},  // Match: 0b0010110, Symbol: e
-    {0x65, 5},  // Match: 0b0010111, Symbol: e
-    {0x69, 5},  // Match: 0b0011000, Symbol: i
-    {0x69, 5},  // Match: 0b0011001, Symbol: i
-    {0x69, 5},  // Match: 0b0011010, Symbol: i
-    {0x69, 5},  // Match: 0b0011011, Symbol: i
-    {0x6f, 5},  // Match: 0b0011100, Symbol: o
-    {0x6f, 5},  // Match: 0b0011101, Symbol: o
-    {0x6f, 5},  // Match: 0b0011110, Symbol: o
-    {0x6f, 5},  // Match: 0b0011111, Symbol: o
-    {0x73, 5},  // Match: 0b0100000, Symbol: s
-    {0x73, 5},  // Match: 0b0100001, Symbol: s
-    {0x73, 5},  // Match: 0b0100010, Symbol: s
-    {0x73, 5},  // Match: 0b0100011, Symbol: s
-    {0x74, 5},  // Match: 0b0100100, Symbol: t
-    {0x74, 5},  // Match: 0b0100101, Symbol: t
-    {0x74, 5},  // Match: 0b0100110, Symbol: t
-    {0x74, 5},  // Match: 0b0100111, Symbol: t
-    {0x20, 6},  // Match: 0b0101000, Symbol: (space)
-    {0x20, 6},  // Match: 0b0101001, Symbol: (space)
-    {0x25, 6},  // Match: 0b0101010, Symbol: %
-    {0x25, 6},  // Match: 0b0101011, Symbol: %
-    {0x2d, 6},  // Match: 0b0101100, Symbol: -
-    {0x2d, 6},  // Match: 0b0101101, Symbol: -
-    {0x2e, 6},  // Match: 0b0101110, Symbol: .
-    {0x2e, 6},  // Match: 0b0101111, Symbol: .
-    {0x2f, 6},  // Match: 0b0110000, Symbol: /
-    {0x2f, 6},  // Match: 0b0110001, Symbol: /
-    {0x33, 6},  // Match: 0b0110010, Symbol: 3
-    {0x33, 6},  // Match: 0b0110011, Symbol: 3
-    {0x34, 6},  // Match: 0b0110100, Symbol: 4
-    {0x34, 6},  // Match: 0b0110101, Symbol: 4
-    {0x35, 6},  // Match: 0b0110110, Symbol: 5
-    {0x35, 6},  // Match: 0b0110111, Symbol: 5
-    {0x36, 6},  // Match: 0b0111000, Symbol: 6
-    {0x36, 6},  // Match: 0b0111001, Symbol: 6
-    {0x37, 6},  // Match: 0b0111010, Symbol: 7
-    {0x37, 6},  // Match: 0b0111011, Symbol: 7
-    {0x38, 6},  // Match: 0b0111100, Symbol: 8
-    {0x38, 6},  // Match: 0b0111101, Symbol: 8
-    {0x39, 6},  // Match: 0b0111110, Symbol: 9
-    {0x39, 6},  // Match: 0b0111111, Symbol: 9
-    {0x3d, 6},  // Match: 0b1000000, Symbol: =
-    {0x3d, 6},  // Match: 0b1000001, Symbol: =
-    {0x41, 6},  // Match: 0b1000010, Symbol: A
-    {0x41, 6},  // Match: 0b1000011, Symbol: A
-    {0x5f, 6},  // Match: 0b1000100, Symbol: _
-    {0x5f, 6},  // Match: 0b1000101, Symbol: _
-    {0x62, 6},  // Match: 0b1000110, Symbol: b
-    {0x62, 6},  // Match: 0b1000111, Symbol: b
-    {0x64, 6},  // Match: 0b1001000, Symbol: d
-    {0x64, 6},  // Match: 0b1001001, Symbol: d
-    {0x66, 6},  // Match: 0b1001010, Symbol: f
-    {0x66, 6},  // Match: 0b1001011, Symbol: f
-    {0x67, 6},  // Match: 0b1001100, Symbol: g
-    {0x67, 6},  // Match: 0b1001101, Symbol: g
-    {0x68, 6},  // Match: 0b1001110, Symbol: h
-    {0x68, 6},  // Match: 0b1001111, Symbol: h
-    {0x6c, 6},  // Match: 0b1010000, Symbol: l
-    {0x6c, 6},  // Match: 0b1010001, Symbol: l
-    {0x6d, 6},  // Match: 0b1010010, Symbol: m
-    {0x6d, 6},  // Match: 0b1010011, Symbol: m
-    {0x6e, 6},  // Match: 0b1010100, Symbol: n
-    {0x6e, 6},  // Match: 0b1010101, Symbol: n
-    {0x70, 6},  // Match: 0b1010110, Symbol: p
-    {0x70, 6},  // Match: 0b1010111, Symbol: p
-    {0x72, 6},  // Match: 0b1011000, Symbol: r
-    {0x72, 6},  // Match: 0b1011001, Symbol: r
-    {0x75, 6},  // Match: 0b1011010, Symbol: u
-    {0x75, 6},  // Match: 0b1011011, Symbol: u
-    {0x3a, 7},  // Match: 0b1011100, Symbol: :
-    {0x42, 7},  // Match: 0b1011101, Symbol: B
-    {0x43, 7},  // Match: 0b1011110, Symbol: C
-    {0x44, 7},  // Match: 0b1011111, Symbol: D
-    {0x45, 7},  // Match: 0b1100000, Symbol: E
-    {0x46, 7},  // Match: 0b1100001, Symbol: F
-    {0x47, 7},  // Match: 0b1100010, Symbol: G
-    {0x48, 7},  // Match: 0b1100011, Symbol: H
-    {0x49, 7},  // Match: 0b1100100, Symbol: I
-    {0x4a, 7},  // Match: 0b1100101, Symbol: J
-    {0x4b, 7},  // Match: 0b1100110, Symbol: K
-    {0x4c, 7},  // Match: 0b1100111, Symbol: L
-    {0x4d, 7},  // Match: 0b1101000, Symbol: M
-    {0x4e, 7},  // Match: 0b1101001, Symbol: N
-    {0x4f, 7},  // Match: 0b1101010, Symbol: O
-    {0x50, 7},  // Match: 0b1101011, Symbol: P
-    {0x51, 7},  // Match: 0b1101100, Symbol: Q
-    {0x52, 7},  // Match: 0b1101101, Symbol: R
-    {0x53, 7},  // Match: 0b1101110, Symbol: S
-    {0x54, 7},  // Match: 0b1101111, Symbol: T
-    {0x55, 7},  // Match: 0b1110000, Symbol: U
-    {0x56, 7},  // Match: 0b1110001, Symbol: V
-    {0x57, 7},  // Match: 0b1110010, Symbol: W
-    {0x59, 7},  // Match: 0b1110011, Symbol: Y
-    {0x6a, 7},  // Match: 0b1110100, Symbol: j
-    {0x6b, 7},  // Match: 0b1110101, Symbol: k
-    {0x71, 7},  // Match: 0b1110110, Symbol: q
-    {0x76, 7},  // Match: 0b1110111, Symbol: v
-    {0x77, 7},  // Match: 0b1111000, Symbol: w
-    {0x78, 7},  // Match: 0b1111001, Symbol: x
-    {0x79, 7},  // Match: 0b1111010, Symbol: y
-    {0x7a, 7},  // Match: 0b1111011, Symbol: z
-};
-
-}  // namespace
-
-HuffmanBitBuffer::HuffmanBitBuffer() {
-  Reset();
-}
-
-void HuffmanBitBuffer::Reset() {
-  accumulator_ = 0;
-  count_ = 0;
-}
-
-size_t HuffmanBitBuffer::AppendBytes(StringPiece input) {
-  HuffmanAccumulatorBitCount free_cnt = free_count();
-  size_t bytes_available = input.size();
-  if (free_cnt < 8 || bytes_available == 0) {
-    return 0;
-  }
-
-  // Top up |accumulator_| until there isn't room for a whole byte.
-  size_t bytes_used = 0;
-  auto ptr = reinterpret_cast<const uint8_t*>(input.data());
-  do {
-    auto b = static_cast<HuffmanAccumulator>(*ptr++);
-    free_cnt -= 8;
-    accumulator_ |= (b << free_cnt);
-    ++bytes_used;
-  } while (free_cnt >= 8 && bytes_used < bytes_available);
-  count_ += (bytes_used * 8);
-  return bytes_used;
-}
-
-HuffmanAccumulatorBitCount HuffmanBitBuffer::free_count() const {
-  return kHuffmanAccumulatorBitCount - count_;
-}
-
-void HuffmanBitBuffer::ConsumeBits(HuffmanAccumulatorBitCount code_length) {
-  DCHECK_LE(code_length, count_);
-  accumulator_ <<= code_length;
-  count_ -= code_length;
-}
-
-bool HuffmanBitBuffer::InputProperlyTerminated() const {
-  auto cnt = count();
-  if (cnt < 8) {
-    if (cnt == 0) {
-      return true;
-    }
-    HuffmanAccumulator expected = ~(~HuffmanAccumulator() >> cnt);
-    // We expect all the bits below the high order |cnt| bits of accumulator_
-    // to be cleared as we perform left shift operations while decoding.
-    DCHECK_EQ(accumulator_ & ~expected, 0u)
-        << "\n  expected: " << HuffmanAccumulatorBitSet(expected) << "\n  "
-        << *this;
-    return accumulator_ == expected;
-  }
-  return false;
-}
-
-string HuffmanBitBuffer::DebugString() const {
-  std::stringstream ss;
-  ss << "{accumulator: " << HuffmanAccumulatorBitSet(accumulator_)
-     << "; count: " << count_ << "}";
-  return ss.str();
-}
-
-HpackHuffmanDecoder::HpackHuffmanDecoder() {}
-
-HpackHuffmanDecoder::~HpackHuffmanDecoder() {}
-
-bool HpackHuffmanDecoder::Decode(StringPiece input, string* output) {
-  return DecodeShortCodesFirst(input, output);
-}
-
-// "Legacy" decoder, used until cl/129771019 submitted, which added
-// DecodeShortCodesFirst() as primary decoder method.
-// TODO(jamessynge): Remove this once satisfied that there is no going back.
-bool HpackHuffmanDecoder::DecodeWithIfTreeAndStruct(StringPiece input,
-                                                    string* output) {
-  DVLOG(1) << "HpackHuffmanDecoder::DecodeWithIfTreeAndStruct";
-
-  // Fill bit_buffer_ from input.
-  input.remove_prefix(bit_buffer_.AppendBytes(input));
-
-  while (true) {
-    DVLOG(3) << "Enter Decode Loop, bit_buffer_: " << bit_buffer_;
-
-    HuffmanCode code_prefix = bit_buffer_.value() >> kExtraAccumulatorBitCount;
-    DVLOG(3) << "code_prefix: " << HuffmanCodeBitSet(code_prefix);
-
-    PrefixInfo prefix_info = PrefixToInfo(code_prefix);
-    DVLOG(3) << "prefix_info: " << prefix_info;
-    DCHECK_LE(kMinCodeBitCount, prefix_info.code_length);
-    DCHECK_LE(prefix_info.code_length, kMaxCodeBitCount);
-
-    if (prefix_info.code_length <= bit_buffer_.count()) {
-      // We have enough bits for one code.
-      uint32_t canonical = prefix_info.DecodeToCanonical(code_prefix);
-      if (canonical < 256) {
-        // Valid code.
-        char c = kCanonicalToSymbol[canonical];
-        output->push_back(c);
-        bit_buffer_.ConsumeBits(prefix_info.code_length);
-        continue;
-      }
-      // Encoder is not supposed to explicity encode the EOS symbol.
-      DLOG(ERROR) << "EOS explicitly encoded!\n " << bit_buffer_ << "\n "
-                  << prefix_info;
-      return false;
-    }
-    // bit_buffer_ doesn't have enough bits in it to decode the next symbol.
-    // Append to it as many bytes as are available AND fit.
-    size_t byte_count = bit_buffer_.AppendBytes(input);
-    if (byte_count == 0) {
-      DCHECK_EQ(input.size(), 0u);
-      return true;
-    }
-    input.remove_prefix(byte_count);
-  }
-}
-
-bool HpackHuffmanDecoder::DecodeShortCodesFirst(StringPiece input,
-                                                string* output) {
-  DVLOG(1) << "HpackHuffmanDecoder::DecodeShortCodesFirst";
-
-  // Fill bit_buffer_ from input.
-  input.remove_prefix(bit_buffer_.AppendBytes(input));
-
-  while (true) {
-    DVLOG(3) << "Enter Decode Loop, bit_buffer_: " << bit_buffer_;
-    if (bit_buffer_.count() >= 7) {
-      // Get high 7 bits of the bit buffer, see if that contains a complete
-      // code of 5, 6 or 7 bits.
-      uint8_t short_code =
-          bit_buffer_.value() >> (kHuffmanAccumulatorBitCount - 7);
-      DCHECK_LT(short_code, 128);
-      if (short_code < kShortCodeTableSize) {
-        ShortCodeInfo info = kShortCodeTable[short_code];
-        bit_buffer_.ConsumeBits(info.length);
-        output->push_back(static_cast<char>(info.symbol));
-        continue;
-      }
-      // The code is more than 7 bits long. Use PrefixToInfo, etc. to decode
-      // longer codes.
-    } else {
-      // We may have (mostly) drained bit_buffer_. If we can top it up, try
-      // using the table decoder above.
-      size_t byte_count = bit_buffer_.AppendBytes(input);
-      if (byte_count > 0) {
-        input.remove_prefix(byte_count);
-        continue;
-      }
-    }
-
-    HuffmanCode code_prefix = bit_buffer_.value() >> kExtraAccumulatorBitCount;
-    DVLOG(3) << "code_prefix: " << HuffmanCodeBitSet(code_prefix);
-
-    PrefixInfo prefix_info = PrefixToInfo(code_prefix);
-    DVLOG(3) << "prefix_info: " << prefix_info;
-    DCHECK_LE(kMinCodeBitCount, prefix_info.code_length);
-    DCHECK_LE(prefix_info.code_length, kMaxCodeBitCount);
-
-    if (prefix_info.code_length <= bit_buffer_.count()) {
-      // We have enough bits for one code.
-      uint32_t canonical = prefix_info.DecodeToCanonical(code_prefix);
-      if (canonical < 256) {
-        // Valid code.
-        char c = kCanonicalToSymbol[canonical];
-        output->push_back(c);
-        bit_buffer_.ConsumeBits(prefix_info.code_length);
-        continue;
-      }
-      // Encoder is not supposed to explicity encode the EOS symbol.
-      DLOG(ERROR) << "EOS explicitly encoded!\n " << bit_buffer_ << "\n "
-                  << prefix_info;
-      return false;
-    }
-    // bit_buffer_ doesn't have enough bits in it to decode the next symbol.
-    // Append to it as many bytes as are available AND fit.
-    size_t byte_count = bit_buffer_.AppendBytes(input);
-    if (byte_count == 0) {
-      DCHECK_EQ(input.size(), 0u);
-      return true;
-    }
-    input.remove_prefix(byte_count);
-  }
-}
-
-string HpackHuffmanDecoder::DebugString() const {
-  return bit_buffer_.DebugString();
-}
-
-}  // namespace net