Update HPACK Huffman code for '06 draft release

This effectively just drops the separate response code. Tests have been
updated to use the new request-code spec fixtures.

This lands server change 61954666 by jgraettinger.

BUG=339578

Review URL: https://codereview.chromium.org/182283003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@254829 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 68 insertions, 354 deletions

diff --git a/net/spdy/hpack_constants.cc b/net/spdy/hpack_constants.cc
index 1bed8fe..5e93292 100644
--- a/net/spdy/hpack_constants.cc
+++ b/net/spdy/hpack_constants.cc
@@ -21,21 +21,21 @@ uint32 bits32(const std::string& bitstring) {
 // import re, sys
 // count = 0
 // for l in sys.stdin:
-//   m = re.match(r"^ +('.'|EOS)? \( *(\d+)\) \|([10\|]+) \[(\d+)\]", l)
+//   m = re.match(r"^ +('.+'|EOS)? \( *(\d+)\) \|([10\|]+) \[(\d+)\]", l)
 //   if m:
 //     g = m.groups()
 //     print('  {bits32("%s"), %s, %s},%s' % (
 //       g[2].replace('|','').ljust(32,'0'), g[3], g[1],
 //       ('  // %s' % g[0]) if g[0] else ''))
 //     count += 1
-// print("Total: %s", count)
+// print("Total: %s" % count)
 //
-// [2] http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-05
+// [2] http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-06
 
 // HpackHuffmanSymbol entries are initialized as {code, length, id}.
 // Codes are specified in the |length| most-significant bits of |code|.
-std::vector<HpackHuffmanSymbol> HpackRequestHuffmanCode() {
-  const HpackHuffmanSymbol kHpackRequestHuffmanCode[] = {
+std::vector<HpackHuffmanSymbol> HpackHuffmanCode() {
+  const HpackHuffmanSymbol kHpackHuffmanCode[] = {
     {bits32("11111111111111111111011101000000"), 27, 0},
     {bits32("11111111111111111111011101100000"), 27, 1},
     {bits32("11111111111111111111011110000000"), 27, 2},
@@ -295,273 +295,8 @@ std::vector<HpackHuffmanSymbol> HpackRequestHuffmanCode() {
     {bits32("11111111111111111111011100000000"), 26, 256},  // EOS
   };
   return std::vector<HpackHuffmanSymbol>(
-      kHpackRequestHuffmanCode,
-      kHpackRequestHuffmanCode + arraysize(kHpackRequestHuffmanCode));
-}
-
-std::vector<HpackHuffmanSymbol> HpackResponseHuffmanCode() {
-  const HpackHuffmanSymbol kHpackResponseHuffmanCode[] = {
-    {bits32("11111111111111111101111000000000"), 25, 0},
-    {bits32("11111111111111111101111010000000"), 25, 1},
-    {bits32("11111111111111111101111100000000"), 25, 2},
-    {bits32("11111111111111111101111110000000"), 25, 3},
-    {bits32("11111111111111111110000000000000"), 25, 4},
-    {bits32("11111111111111111110000010000000"), 25, 5},
-    {bits32("11111111111111111110000100000000"), 25, 6},
-    {bits32("11111111111111111110000110000000"), 25, 7},
-    {bits32("11111111111111111110001000000000"), 25, 8},
-    {bits32("11111111111111111110001010000000"), 25, 9},
-    {bits32("11111111111111111110001100000000"), 25, 10},
-    {bits32("11111111111111111110001110000000"), 25, 11},
-    {bits32("11111111111111111110010000000000"), 25, 12},
-    {bits32("11111111111111111110010010000000"), 25, 13},
-    {bits32("11111111111111111110010100000000"), 25, 14},
-    {bits32("11111111111111111110010110000000"), 25, 15},
-    {bits32("11111111111111111110011000000000"), 25, 16},
-    {bits32("11111111111111111110011010000000"), 25, 17},
-    {bits32("11111111111111111110011100000000"), 25, 18},
-    {bits32("11111111111111111110011110000000"), 25, 19},
-    {bits32("11111111111111111110100000000000"), 25, 20},
-    {bits32("11111111111111111110100010000000"), 25, 21},
-    {bits32("11111111111111111110100100000000"), 25, 22},
-    {bits32("11111111111111111110100110000000"), 25, 23},
-    {bits32("11111111111111111110101000000000"), 25, 24},
-    {bits32("11111111111111111110101010000000"), 25, 25},
-    {bits32("11111111111111111110101100000000"), 25, 26},
-    {bits32("11111111111111111110101110000000"), 25, 27},
-    {bits32("11111111111111111110110000000000"), 25, 28},
-    {bits32("11111111111111111110110010000000"), 25, 29},
-    {bits32("11111111111111111110110100000000"), 25, 30},
-    {bits32("11111111111111111110110110000000"), 25, 31},
-    {bits32("00000000000000000000000000000000"), 4, 32},  // ' '
-    {bits32("11111111101000000000000000000000"), 12, 33},  // '!'
-    {bits32("11010100000000000000000000000000"), 7, 34},  // '"'
-    {bits32("11111111110100000000000000000000"), 13, 35},  // '#'
-    {bits32("11111111111100000000000000000000"), 14, 36},  // '$'
-    {bits32("11110110000000000000000000000000"), 9, 37},  // '%'
-    {bits32("11111110000000000000000000000000"), 10, 38},  // '&'
-    {bits32("11111111110110000000000000000000"), 13, 39},  // '''
-    {bits32("11110110100000000000000000000000"), 9, 40},  // '('
-    {bits32("11110111000000000000000000000000"), 9, 41},  // ')'
-    {bits32("11111111101100000000000000000000"), 12, 42},  // '*'
-    {bits32("11111111010000000000000000000000"), 11, 43},  // '+'
-    {bits32("10001000000000000000000000000000"), 6, 44},  // ','
-    {bits32("10001100000000000000000000000000"), 6, 45},  // '-'
-    {bits32("10010000000000000000000000000000"), 6, 46},  // '.'
-    {bits32("11010110000000000000000000000000"), 7, 47},  // '/'
-    {bits32("00010000000000000000000000000000"), 4, 48},  // '0'
-    {bits32("00100000000000000000000000000000"), 4, 49},  // '1'
-    {bits32("00110000000000000000000000000000"), 4, 50},  // '2'
-    {bits32("01000000000000000000000000000000"), 5, 51},  // '3'
-    {bits32("01001000000000000000000000000000"), 5, 52},  // '4'
-    {bits32("01010000000000000000000000000000"), 5, 53},  // '5'
-    {bits32("10010100000000000000000000000000"), 6, 54},  // '6'
-    {bits32("10011000000000000000000000000000"), 6, 55},  // '7'
-    {bits32("01011000000000000000000000000000"), 5, 56},  // '8'
-    {bits32("01100000000000000000000000000000"), 5, 57},  // '9'
-    {bits32("01101000000000000000000000000000"), 5, 58},  // ':'
-    {bits32("11110111100000000000000000000000"), 9, 59},  // ';'
-    {bits32("11111111111110100000000000000000"), 16, 60},  // '<'
-    {bits32("11011000000000000000000000000000"), 7, 61},  // '='
-    {bits32("11111111111000000000000000000000"), 13, 62},  // '>'
-    {bits32("11111111110000000000000000000000"), 12, 63},  // '?'
-    {bits32("11111111111110110000000000000000"), 16, 64},  // '@'
-    {bits32("11011010000000000000000000000000"), 7, 65},  // 'A'
-    {bits32("11101010000000000000000000000000"), 8, 66},  // 'B'
-    {bits32("11101011000000000000000000000000"), 8, 67},  // 'C'
-    {bits32("11101100000000000000000000000000"), 8, 68},  // 'D'
-    {bits32("11101101000000000000000000000000"), 8, 69},  // 'E'
-    {bits32("11101110000000000000000000000000"), 8, 70},  // 'F'
-    {bits32("10011100000000000000000000000000"), 6, 71},  // 'G'
-    {bits32("11111000000000000000000000000000"), 9, 72},  // 'H'
-    {bits32("11101111000000000000000000000000"), 8, 73},  // 'I'
-    {bits32("11110000000000000000000000000000"), 8, 74},  // 'J'
-    {bits32("11111110010000000000000000000000"), 10, 75},  // 'K'
-    {bits32("11111000100000000000000000000000"), 9, 76},  // 'L'
-    {bits32("10100000000000000000000000000000"), 6, 77},  // 'M'
-    {bits32("11110001000000000000000000000000"), 8, 78},  // 'N'
-    {bits32("11110010000000000000000000000000"), 8, 79},  // 'O'
-    {bits32("11111001000000000000000000000000"), 9, 80},  // 'P'
-    {bits32("11111110100000000000000000000000"), 10, 81},  // 'Q'
-    {bits32("11111001100000000000000000000000"), 9, 82},  // 'R'
-    {bits32("10100100000000000000000000000000"), 6, 83},  // 'S'
-    {bits32("01110000000000000000000000000000"), 5, 84},  // 'T'
-    {bits32("11111010000000000000000000000000"), 9, 85},  // 'U'
-    {bits32("11111010100000000000000000000000"), 9, 86},  // 'V'
-    {bits32("11110011000000000000000000000000"), 8, 87},  // 'W'
-    {bits32("11111110110000000000000000000000"), 10, 88},  // 'X'
-    {bits32("11111011000000000000000000000000"), 9, 89},  // 'Y'
-    {bits32("11111111000000000000000000000000"), 10, 90},  // 'Z'
-    {bits32("11111111011000000000000000000000"), 11, 91},  // '['
-    {bits32("11111111111010000000000000000000"), 13, 92},  // '\'
-    {bits32("11111111100000000000000000000000"), 11, 93},  // ']'
-    {bits32("11111111111110000000000000000000"), 15, 94},  // '^'
-    {bits32("11111011100000000000000000000000"), 9, 95},  // '_'
-    {bits32("11111111111111110000000000000000"), 17, 96},  // '`'
-    {bits32("01111000000000000000000000000000"), 5, 97},  // 'a'
-    {bits32("11011100000000000000000000000000"), 7, 98},  // 'b'
-    {bits32("10101000000000000000000000000000"), 6, 99},  // 'c'
-    {bits32("10101100000000000000000000000000"), 6, 100},  // 'd'
-    {bits32("10000000000000000000000000000000"), 5, 101},  // 'e'
-    {bits32("11011110000000000000000000000000"), 7, 102},  // 'f'
-    {bits32("11100000000000000000000000000000"), 7, 103},  // 'g'
-    {bits32("11100010000000000000000000000000"), 7, 104},  // 'h'
-    {bits32("10110000000000000000000000000000"), 6, 105},  // 'i'
-    {bits32("11111100000000000000000000000000"), 9, 106},  // 'j'
-    {bits32("11111100100000000000000000000000"), 9, 107},  // 'k'
-    {bits32("11100100000000000000000000000000"), 7, 108},  // 'l'
-    {bits32("10110100000000000000000000000000"), 6, 109},  // 'm'
-    {bits32("10111000000000000000000000000000"), 6, 110},  // 'n'
-    {bits32("10111100000000000000000000000000"), 6, 111},  // 'o'
-    {bits32("11000000000000000000000000000000"), 6, 112},  // 'p'
-    {bits32("11111101000000000000000000000000"), 9, 113},  // 'q'
-    {bits32("11000100000000000000000000000000"), 6, 114},  // 'r'
-    {bits32("11001000000000000000000000000000"), 6, 115},  // 's'
-    {bits32("11001100000000000000000000000000"), 6, 116},  // 't'
-    {bits32("11010000000000000000000000000000"), 6, 117},  // 'u'
-    {bits32("11100110000000000000000000000000"), 7, 118},  // 'v'
-    {bits32("11110100000000000000000000000000"), 8, 119},  // 'w'
-    {bits32("11101000000000000000000000000000"), 7, 120},  // 'x'
-    {bits32("11110101000000000000000000000000"), 8, 121},  // 'y'
-    {bits32("11111101100000000000000000000000"), 9, 122},  // 'z'
-    {bits32("11111111111111000000000000000000"), 16, 123},  // '{'
-    {bits32("11111111111101000000000000000000"), 14, 124},  // '|'
-    {bits32("11111111111111010000000000000000"), 16, 125},  // '}'
-    {bits32("11111111111111100000000000000000"), 16, 126},  // '~'
-    {bits32("11111111111111111110111000000000"), 25, 127},
-    {bits32("11111111111111111110111010000000"), 25, 128},
-    {bits32("11111111111111111110111100000000"), 25, 129},
-    {bits32("11111111111111111110111110000000"), 25, 130},
-    {bits32("11111111111111111111000000000000"), 25, 131},
-    {bits32("11111111111111111111000010000000"), 25, 132},
-    {bits32("11111111111111111111000100000000"), 25, 133},
-    {bits32("11111111111111111111000110000000"), 25, 134},
-    {bits32("11111111111111111111001000000000"), 25, 135},
-    {bits32("11111111111111111111001010000000"), 25, 136},
-    {bits32("11111111111111111111001100000000"), 25, 137},
-    {bits32("11111111111111111111001110000000"), 25, 138},
-    {bits32("11111111111111111111010000000000"), 25, 139},
-    {bits32("11111111111111111111010010000000"), 25, 140},
-    {bits32("11111111111111111111010100000000"), 25, 141},
-    {bits32("11111111111111111111010110000000"), 25, 142},
-    {bits32("11111111111111111111011000000000"), 25, 143},
-    {bits32("11111111111111111111011010000000"), 25, 144},
-    {bits32("11111111111111111111011100000000"), 25, 145},
-    {bits32("11111111111111111111011110000000"), 25, 146},
-    {bits32("11111111111111111111100000000000"), 25, 147},
-    {bits32("11111111111111111111100010000000"), 25, 148},
-    {bits32("11111111111111111111100100000000"), 25, 149},
-    {bits32("11111111111111111111100110000000"), 25, 150},
-    {bits32("11111111111111111111101000000000"), 25, 151},
-    {bits32("11111111111111111111101010000000"), 25, 152},
-    {bits32("11111111111111111111101100000000"), 25, 153},
-    {bits32("11111111111111111111101110000000"), 25, 154},
-    {bits32("11111111111111111111110000000000"), 25, 155},
-    {bits32("11111111111111111111110010000000"), 25, 156},
-    {bits32("11111111111111111111110100000000"), 25, 157},
-    {bits32("11111111111111111111110110000000"), 25, 158},
-    {bits32("11111111111111111111111000000000"), 25, 159},
-    {bits32("11111111111111111111111010000000"), 25, 160},
-    {bits32("11111111111111111111111100000000"), 25, 161},
-    {bits32("11111111111111111111111110000000"), 25, 162},
-    {bits32("11111111111111111000000000000000"), 24, 163},
-    {bits32("11111111111111111000000100000000"), 24, 164},
-    {bits32("11111111111111111000001000000000"), 24, 165},
-    {bits32("11111111111111111000001100000000"), 24, 166},
-    {bits32("11111111111111111000010000000000"), 24, 167},
-    {bits32("11111111111111111000010100000000"), 24, 168},
-    {bits32("11111111111111111000011000000000"), 24, 169},
-    {bits32("11111111111111111000011100000000"), 24, 170},
-    {bits32("11111111111111111000100000000000"), 24, 171},
-    {bits32("11111111111111111000100100000000"), 24, 172},
-    {bits32("11111111111111111000101000000000"), 24, 173},
-    {bits32("11111111111111111000101100000000"), 24, 174},
-    {bits32("11111111111111111000110000000000"), 24, 175},
-    {bits32("11111111111111111000110100000000"), 24, 176},
-    {bits32("11111111111111111000111000000000"), 24, 177},
-    {bits32("11111111111111111000111100000000"), 24, 178},
-    {bits32("11111111111111111001000000000000"), 24, 179},
-    {bits32("11111111111111111001000100000000"), 24, 180},
-    {bits32("11111111111111111001001000000000"), 24, 181},
-    {bits32("11111111111111111001001100000000"), 24, 182},
-    {bits32("11111111111111111001010000000000"), 24, 183},
-    {bits32("11111111111111111001010100000000"), 24, 184},
-    {bits32("11111111111111111001011000000000"), 24, 185},
-    {bits32("11111111111111111001011100000000"), 24, 186},
-    {bits32("11111111111111111001100000000000"), 24, 187},
-    {bits32("11111111111111111001100100000000"), 24, 188},
-    {bits32("11111111111111111001101000000000"), 24, 189},
-    {bits32("11111111111111111001101100000000"), 24, 190},
-    {bits32("11111111111111111001110000000000"), 24, 191},
-    {bits32("11111111111111111001110100000000"), 24, 192},
-    {bits32("11111111111111111001111000000000"), 24, 193},
-    {bits32("11111111111111111001111100000000"), 24, 194},
-    {bits32("11111111111111111010000000000000"), 24, 195},
-    {bits32("11111111111111111010000100000000"), 24, 196},
-    {bits32("11111111111111111010001000000000"), 24, 197},
-    {bits32("11111111111111111010001100000000"), 24, 198},
-    {bits32("11111111111111111010010000000000"), 24, 199},
-    {bits32("11111111111111111010010100000000"), 24, 200},
-    {bits32("11111111111111111010011000000000"), 24, 201},
-    {bits32("11111111111111111010011100000000"), 24, 202},
-    {bits32("11111111111111111010100000000000"), 24, 203},
-    {bits32("11111111111111111010100100000000"), 24, 204},
-    {bits32("11111111111111111010101000000000"), 24, 205},
-    {bits32("11111111111111111010101100000000"), 24, 206},
-    {bits32("11111111111111111010110000000000"), 24, 207},
-    {bits32("11111111111111111010110100000000"), 24, 208},
-    {bits32("11111111111111111010111000000000"), 24, 209},
-    {bits32("11111111111111111010111100000000"), 24, 210},
-    {bits32("11111111111111111011000000000000"), 24, 211},
-    {bits32("11111111111111111011000100000000"), 24, 212},
-    {bits32("11111111111111111011001000000000"), 24, 213},
-    {bits32("11111111111111111011001100000000"), 24, 214},
-    {bits32("11111111111111111011010000000000"), 24, 215},
-    {bits32("11111111111111111011010100000000"), 24, 216},
-    {bits32("11111111111111111011011000000000"), 24, 217},
-    {bits32("11111111111111111011011100000000"), 24, 218},
-    {bits32("11111111111111111011100000000000"), 24, 219},
-    {bits32("11111111111111111011100100000000"), 24, 220},
-    {bits32("11111111111111111011101000000000"), 24, 221},
-    {bits32("11111111111111111011101100000000"), 24, 222},
-    {bits32("11111111111111111011110000000000"), 24, 223},
-    {bits32("11111111111111111011110100000000"), 24, 224},
-    {bits32("11111111111111111011111000000000"), 24, 225},
-    {bits32("11111111111111111011111100000000"), 24, 226},
-    {bits32("11111111111111111100000000000000"), 24, 227},
-    {bits32("11111111111111111100000100000000"), 24, 228},
-    {bits32("11111111111111111100001000000000"), 24, 229},
-    {bits32("11111111111111111100001100000000"), 24, 230},
-    {bits32("11111111111111111100010000000000"), 24, 231},
-    {bits32("11111111111111111100010100000000"), 24, 232},
-    {bits32("11111111111111111100011000000000"), 24, 233},
-    {bits32("11111111111111111100011100000000"), 24, 234},
-    {bits32("11111111111111111100100000000000"), 24, 235},
-    {bits32("11111111111111111100100100000000"), 24, 236},
-    {bits32("11111111111111111100101000000000"), 24, 237},
-    {bits32("11111111111111111100101100000000"), 24, 238},
-    {bits32("11111111111111111100110000000000"), 24, 239},
-    {bits32("11111111111111111100110100000000"), 24, 240},
-    {bits32("11111111111111111100111000000000"), 24, 241},
-    {bits32("11111111111111111100111100000000"), 24, 242},
-    {bits32("11111111111111111101000000000000"), 24, 243},
-    {bits32("11111111111111111101000100000000"), 24, 244},
-    {bits32("11111111111111111101001000000000"), 24, 245},
-    {bits32("11111111111111111101001100000000"), 24, 246},
-    {bits32("11111111111111111101010000000000"), 24, 247},
-    {bits32("11111111111111111101010100000000"), 24, 248},
-    {bits32("11111111111111111101011000000000"), 24, 249},
-    {bits32("11111111111111111101011100000000"), 24, 250},
-    {bits32("11111111111111111101100000000000"), 24, 251},
-    {bits32("11111111111111111101100100000000"), 24, 252},
-    {bits32("11111111111111111101101000000000"), 24, 253},
-    {bits32("11111111111111111101101100000000"), 24, 254},
-    {bits32("11111111111111111101110000000000"), 24, 255},
-    {bits32("11111111111111111101110100000000"), 24, 256},  // EOS
-  };
-  return std::vector<HpackHuffmanSymbol>(
-      kHpackResponseHuffmanCode,
-      kHpackResponseHuffmanCode + arraysize(kHpackResponseHuffmanCode));
+      kHpackHuffmanCode,
+      kHpackHuffmanCode + arraysize(kHpackHuffmanCode));
 }
 
 }  // namespace net
diff --git a/net/spdy/hpack_constants.h b/net/spdy/hpack_constants.h
index 9d97ee3..ecae49e 100644
--- a/net/spdy/hpack_constants.h
+++ b/net/spdy/hpack_constants.h
@@ -11,7 +11,7 @@
 #include "net/base/net_export.h"
 
 // All section references below are to
-// http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-05
+// http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-06
 
 namespace net {
 
@@ -48,11 +48,8 @@ const HpackPrefix kLiteralNoIndexOpcode = { 0x01, 2 };
 // (from 4.3.2).
 const HpackPrefix kLiteralIncrementalIndexOpcode = { 0x00, 2 };
 
-// Returns symbol code table from "Appendix C. Huffman Codes For Requests".
-NET_EXPORT_PRIVATE std::vector<HpackHuffmanSymbol> HpackRequestHuffmanCode();
-
-// Returns symbol code table from "Appendix D. Huffman Codes For Responses".
-NET_EXPORT_PRIVATE std::vector<HpackHuffmanSymbol> HpackResponseHuffmanCode();
+// Returns symbol code table from "Appendix C. Huffman Codes".
+NET_EXPORT_PRIVATE std::vector<HpackHuffmanSymbol> HpackHuffmanCode();
 
 }  // namespace net
 
diff --git a/net/spdy/hpack_decoder_test.cc b/net/spdy/hpack_decoder_test.cc
index 399cdc2..c7b1961 100644
--- a/net/spdy/hpack_decoder_test.cc
+++ b/net/spdy/hpack_decoder_test.cc
@@ -63,7 +63,7 @@ TEST_F(HpackDecoderTest, DecodeNextNameLiteral) {
 
 TEST_F(HpackDecoderTest, DecodeNextNameLiteralWithHuffmanEncoding) {
   {
-    std::vector<HpackHuffmanSymbol> code = HpackRequestHuffmanCode();
+    std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
     EXPECT_TRUE(huffman_table_.Initialize(&code[0], code.size()));
   }
   char input[] = "\x00\x88\x4e\xb0\x8b\x74\x97\x90\xfa\x7f";
@@ -209,7 +209,7 @@ TEST_F(HpackDecoderTest, BasicE21) {
 
 TEST_F(HpackDecoderTest, SectionD3RequestHuffmanExamples) {
   {
-    std::vector<HpackHuffmanSymbol> code = HpackRequestHuffmanCode();
+    std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
     EXPECT_TRUE(huffman_table_.Initialize(&code[0], code.size()));
   }
   std::map<string, string> header_set;
@@ -305,7 +305,7 @@ TEST_F(HpackDecoderTest, SectionD3RequestHuffmanExamples) {
 
 TEST_F(HpackDecoderTest, SectionD5ResponseHuffmanExamples) {
   {
-    std::vector<HpackHuffmanSymbol> code = HpackResponseHuffmanCode();
+    std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
     EXPECT_TRUE(huffman_table_.Initialize(&code[0], code.size()));
   }
   std::map<string, string> header_set;
@@ -316,26 +316,26 @@ TEST_F(HpackDecoderTest, SectionD5ResponseHuffmanExamples) {
   //                                         |     :status
   // 82                                      |   Literal value (len = 3)
   //                                         |     Huffman encoded:
-  // 409f                                    | @.
+  // 98a7                                    | ..
   //                                         |     Decoded:
   //                                         | 302
   //                                         | -> :status: 302
   // 18                                      | == Literal indexed ==
   //                                         |   Indexed name (idx = 24)
   //                                         |     cache-control
-  // 86                                      |   Literal value (len = 7)
+  // 85                                      |   Literal value (len = 7)
   //                                         |     Huffman encoded:
-  // c31b 39bf 387f                          | ..9.8.
+  // 73d5 cd11 1f                            | s....
   //                                         |     Decoded:
   //                                         | private
   //                                         | -> cache-control: private
   // 22                                      | == Literal indexed ==
   //                                         |   Indexed name (idx = 34)
   //                                         |     date
-  // 92                                      |   Literal value (len = 29)
+  // 98                                      |   Literal value (len = 29)
   //                                         |     Huffman encoded:
-  // a2fb a203 20f2 ab30 3124 018b 490d 3209 | .... ..01$..I.2.
-  // e877                                    | .w
+  // ef6b 3a7a 0e6e 8fa2 63d0 729a 6e83 97d8 | .k:z.n..c.r.n...
+  // 69bd 8737 47bb bfc7                     | i..7G...
   //                                         |     Decoded:
   //                                         | Mon, 21 Oct 2013 20:13:21
   //                                         | GMT
@@ -344,19 +344,18 @@ TEST_F(HpackDecoderTest, SectionD5ResponseHuffmanExamples) {
   // 30                                      | == Literal indexed ==
   //                                         |   Indexed name (idx = 48)
   //                                         |     location
-  // 93                                      |   Literal value (len = 23)
+  // 90                                      |   Literal value (len = 23)
   //                                         |     Huffman encoded:
-  // e39e 7864 dd7a fd3d 3d24 8747 db87 2849 | ..xd.z.==$.G..(I
-  // 55f6 ff                                 | U..
+  // ce31 743d 801b 6db1 07cd 1a39 6244 b74f | .1t=..m....9bD.O
   //                                         |     Decoded:
   //                                         | https://www.example.com
   //                                         | -> location: https://www.e
   //                                         |    xample.com
   char first[] =
-      "\x08\x82\x40\x9f\x18\x86\xc3\x1b\x39\xbf\x38\x7f\x22\x92\xa2\xfb"
-      "\xa2\x03\x20\xf2\xab\x30\x31\x24\x01\x8b\x49\x0d\x32\x09\xe8\x77"
-      "\x30\x93\xe3\x9e\x78\x64\xdd\x7a\xfd\x3d\x3d\x24\x87\x47\xdb\x87"
-      "\x28\x49\x55\xf6\xff";
+      "\x08\x82\x98\xa7\x18\x85\x73\xd5\xcd\x11\x1f\x22\x98\xef\x6b"
+      "\x3a\x7a\x0e\x6e\x8f\xa2\x63\xd0\x72\x9a\x6e\x83\x97\xd8\x69\xbd\x87"
+      "\x37\x47\xbb\xbf\xc7\x30\x90\xce\x31\x74\x3d\x80\x1b\x6d\xb1\x07\xcd"
+      "\x1a\x39\x62\x44\xb7\x4f";
   header_set = DecodeUniqueHeaderSet(StringPiece(first, arraysize(first)-1));
 
   EXPECT_THAT(header_set, ElementsAre(
@@ -365,14 +364,11 @@ TEST_F(HpackDecoderTest, SectionD5ResponseHuffmanExamples) {
       Pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
       Pair("location", "https://www.example.com")));
 
-  // 84                                      | == Indexed - Remove ==
-  //                                         |   idx = 4
-  //                                         | -> :status: 302
   // 8c                                      | == Indexed - Add ==
   //                                         |   idx = 12
   //                                         | - evict: :status: 302
   //                                         | -> :status: 200
-  char second[] = "\x84\x8c";
+  char second[] = "\x8c";
   header_set = DecodeUniqueHeaderSet(StringPiece(second, arraysize(second)-1));
 
   EXPECT_THAT(header_set, ElementsAre(
@@ -381,10 +377,6 @@ TEST_F(HpackDecoderTest, SectionD5ResponseHuffmanExamples) {
       Pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
       Pair("location", "https://www.example.com")));
 
-  // 83                                      | == Indexed - Remove ==
-  //                                         |   idx = 3
-  //                                         | -> date: Mon, 21 Oct 2013
-  //                                         |   20:13:21 GMT
   // 84                                      | == Indexed - Remove ==
   //                                         |   idx = 4
   //                                         | -> cache-control: private
@@ -394,21 +386,23 @@ TEST_F(HpackDecoderTest, SectionD5ResponseHuffmanExamples) {
   // 03                                      | == Literal indexed ==
   //                                         |   Indexed name (idx = 3)
   //                                         |     date
-  // 92                                      |   Literal value (len = 29)
+  // 98                                      |   Literal value (len = 29)
   //                                         |     Huffman encoded:
-  // a2fb a203 20f2 ab30 3124 018b 490d 3309 | .... ..01$..I.3.
-  // e877                                    | .w
+  // ef6b 3a7a 0e6e 8fa2 63d0 729a 6e83 97d8 | .k:z.n..c.r.n...
+  // 69bd 873f 47bb bfc7                     | i..?G...
   //                                         |     Decoded:
-  //                                         | Mon, 21 Oct 2013 20:13:22 GMT
-  //                                         | - evict: cache-control: private
+  //                                         | Mon, 21 Oct 2013 20:13:22
+  //                                         | GMT
+  //                                         | - evict: cache-control: pr
+  //                                         |   ivate
   //                                         | -> date: Mon, 21 Oct 2013
   //                                         |   20:13:22 GMT
   // 1d                                      | == Literal indexed ==
   //                                         |   Indexed name (idx = 29)
   //                                         |     content-encoding
-  // 84                                      |   Literal value (len = 4)
+  // 83                                      |   Literal value (len = 4)
   //                                         |     Huffman encoded:
-  // e1fb b30f                               | ....
+  // cbd5 4e                                 | ..N
   //                                         |     Decoded:
   //                                         | gzip
   //                                         | - evict: date: Mon, 21 Oct
@@ -417,11 +411,11 @@ TEST_F(HpackDecoderTest, SectionD5ResponseHuffmanExamples) {
   // 84                                      | == Indexed - Remove ==
   //                                         |   idx = 4
   //                                         | -> location: https://www.e
-  //                                         |    xample.com
+  //                                         |   xample.com
   // 84                                      | == Indexed - Add ==
   //                                         |   idx = 4
   //                                         | -> location: https://www.e
-  //                                         |    xample.com
+  //                                         |   xample.com
   // 83                                      | == Indexed - Remove ==
   //                                         |   idx = 3
   //                                         | -> :status: 200
@@ -433,27 +427,27 @@ TEST_F(HpackDecoderTest, SectionD5ResponseHuffmanExamples) {
   //                                         |     set-cookie
   // b3                                      |   Literal value (len = 56)
   //                                         |     Huffman encoded:
-  // df7d fb36 d3d9 e1fc fc3f afe7 abfc fefc | .}.6.....?......
-  // bfaf 3edf 2f97 7fd3 6ff7 fd79 f6f9 77fd | ..../...o..y..w.
-  // 3de1 6bfa 46fe 10d8 8944 7de1 ce18 e565 | =.k.F....D}....e
-  // f76c 2f                                 | .l/
+  // c5ad b77f 876f c7fb f7fd bfbe bff3 f7f4 | .....o..........
+  // fb7e bbbe 9f5f 87e3 7fef edfa eefa 7c3f | ....._........|?
+  // 1d5d 1a23 ce54 6436 cd49 4bd5 d1cc 5f05 | .].#.Td6.IK..._.
+  // 3596 9b                                 | 5..
   //                                         |     Decoded:
   //                                         | foo=ASDJKHQKBZXOQWEOPIUAXQ
   //                                         | WEOIU; max-age=3600; versi
   //                                         | on=1
   //                                         | - evict: location: https:/
-  //                                         |    /www.example.com
+  //                                         |   /www.example.com
   //                                         | - evict: :status: 200
   //                                         | -> set-cookie: foo=ASDJKHQ
   //                                         |   KBZXOQWEOPIUAXQWEOIU; ma
   //                                         |   x-age=3600; version=1
   char third[] =
-      "\x83\x84\x84\x03\x92\xa2\xfb\xa2\x03\x20\xf2\xab\x30\x31\x24\x01"
-      "\x8b\x49\x0d\x33\x09\xe8\x77\x1d\x84\xe1\xfb\xb3\x0f\x84\x84\x83"
-      "\x83\x3a\xb3\xdf\x7d\xfb\x36\xd3\xd9\xe1\xfc\xfc\x3f\xaf\xe7\xab"
-      "\xfc\xfe\xfc\xbf\xaf\x3e\xdf\x2f\x97\x7f\xd3\x6f\xf7\xfd\x79\xf6"
-      "\xf9\x77\xfd\x3d\xe1\x6b\xfa\x46\xfe\x10\xd8\x89\x44\x7d\xe1\xce"
-      "\x18\xe5\x65\xf7\x6c\x2f";
+      "\x84\x84\x03\x98\xef\x6b\x3a\x7a\x0e\x6e\x8f\xa2\x63\xd0\x72"
+      "\x9a\x6e\x83\x97\xd8\x69\xbd\x87\x3f\x47\xbb\xbf\xc7\x1d\x83\xcb\xd5"
+      "\x4e\x84\x84\x83\x83\x3a\xb3\xc5\xad\xb7\x7f\x87\x6f\xc7\xfb\xf7\xfd"
+      "\xbf\xbe\xbf\xf3\xf7\xf4\xfb\x7e\xbb\xbe\x9f\x5f\x87\xe3\x7f\xef\xed"
+      "\xfa\xee\xfa\x7c\x3f\x1d\x5d\x1a\x23\xce\x54\x64\x36\xcd\x49\x4b\xd5"
+      "\xd1\xcc\x5f\x05\x35\x96\x9b";
   header_set = DecodeUniqueHeaderSet(StringPiece(third, arraysize(third)-1));
 
   EXPECT_THAT(header_set, ElementsAre(
diff --git a/net/spdy/hpack_huffman_table_test.cc b/net/spdy/hpack_huffman_table_test.cc
index 8369f90..3e669e6 100644
--- a/net/spdy/hpack_huffman_table_test.cc
+++ b/net/spdy/hpack_huffman_table_test.cc
@@ -101,18 +101,9 @@ char bits8(const string& bitstring) {
   return static_cast<char>(std::bitset<8>(bitstring).to_ulong());
 }
 
-TEST(HpackHuffmanTableTest, InitializeRequestCode) {
+TEST(HpackHuffmanTableTest, InitializeHpackCode) {
   HpackHuffmanTable table;
-  std::vector<HpackHuffmanSymbol> code = HpackRequestHuffmanCode();
-  EXPECT_TRUE(table.Initialize(&code[0], code.size()));
-  EXPECT_TRUE(table.IsInitialized());
-  EXPECT_EQ(HpackHuffmanTablePeer(table).pad_bits(),
-            bits8("11111111"));  // First 8 bits of EOS.
-}
-
-TEST(HpackHuffmanTableTest, InitializeResponseCode) {
-  HpackHuffmanTable table;
-  std::vector<HpackHuffmanSymbol> code = HpackResponseHuffmanCode();
+  std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
   EXPECT_TRUE(table.Initialize(&code[0], code.size()));
   EXPECT_TRUE(table.IsInitialized());
   EXPECT_EQ(HpackHuffmanTablePeer(table).pad_bits(),
@@ -383,7 +374,7 @@ TEST(HpackHuffmanTableTest, DecodeWithBadInput) {
 TEST(HpackHuffmanTableTest, SpecRequestExamples) {
   HpackHuffmanTable table;
   {
-    std::vector<HpackHuffmanSymbol> code = HpackRequestHuffmanCode();
+    std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
     EXPECT_TRUE(table.Initialize(&code[0], code.size()));
   }
   string buffer;
@@ -416,26 +407,24 @@ TEST(HpackHuffmanTableTest, SpecRequestExamples) {
 TEST(HpackHuffmanTableTest, SpecResponseExamples) {
   HpackHuffmanTable table;
   {
-    std::vector<HpackHuffmanSymbol> code = HpackResponseHuffmanCode();
+    std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
     EXPECT_TRUE(table.Initialize(&code[0], code.size()));
   }
   string buffer;
   string test_table[] = {
-    "\x40\x9f",
+    "\x98\xa7",
     "302",
-    "\xc3\x1b\x39\xbf\x38\x7f",
+    "\x73\xd5\xcd\x11\x1f",
     "private",
-    "\xa2\xfb\xa2\x03\x20\xf2\xab\x30\x31\x24\x01"
-        "\x8b\x49\x0d\x32\x09\xe8\x77",
+    "\xef\x6b\x3a\x7a\x0e\x6e\x8f\xa2\x63\xd0\x72\x9a\x6e\x83\x97\xd8"
+        "\x69\xbd\x87\x37\x47\xbb\xbf\xc7",
     "Mon, 21 Oct 2013 20:13:21 GMT",
-    "\xe3\x9e\x78\x64\xdd\x7a\xfd\x3d\x3d\x24\x87"
-        "\x47\xdb\x87\x28\x49\x55\xf6\xff",
+    "\xce\x31\x74\x3d\x80\x1b\x6d\xb1\x07\xcd\x1a\x39\x62\x44\xb7\x4f",
     "https://www.example.com",
-    "\xdf\x7d\xfb\x36\xd3\xd9\xe1\xfc\xfc\x3f\xaf"
-        "\xe7\xab\xfc\xfe\xfc\xbf\xaf\x3e\xdf\x2f"
-        "\x97\x7f\xd3\x6f\xf7\xfd\x79\xf6\xf9\x77"
-        "\xfd\x3d\xe1\x6b\xfa\x46\xfe\x10\xd8\x89"
-        "\x44\x7d\xe1\xce\x18\xe5\x65\xf7\x6c\x2f",
+    "\xc5\xad\xb7\x7f\x87\x6f\xc7\xfb\xf7\xfd\xbf\xbe\xbf\xf3\xf7\xf4"
+        "\xfb\x7e\xbb\xbe\x9f\x5f\x87\xe3\x7f\xef\xed\xfa\xee\xfa\x7c\x3f"
+        "\x1d\x5d\x1a\x23\xce\x54\x64\x36\xcd\x49\x4b\xd5\xd1\xcc\x5f\x05"
+        "\x35\x96\x9b",
     "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1",
   };
   // Round-trip each test example.
@@ -457,7 +446,7 @@ TEST(HpackHuffmanTableTest, SpecResponseExamples) {
 TEST(HpackHuffmanTableTest, RoundTripIndvidualSymbols) {
   HpackHuffmanTable table;
   {
-    std::vector<HpackHuffmanSymbol> code = HpackRequestHuffmanCode();
+    std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
     EXPECT_TRUE(table.Initialize(&code[0], code.size()));
   }
   for (size_t i = 0; i != 256; i++) {
@@ -479,7 +468,7 @@ TEST(HpackHuffmanTableTest, RoundTripIndvidualSymbols) {
 TEST(HpackHuffmanTableTest, RoundTripSymbolSequence) {
   HpackHuffmanTable table;
   {
-    std::vector<HpackHuffmanSymbol> code = HpackResponseHuffmanCode();
+    std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
     EXPECT_TRUE(table.Initialize(&code[0], code.size()));
   }
   char storage[512];
diff --git a/net/spdy/hpack_input_stream_test.cc b/net/spdy/hpack_input_stream_test.cc
index 565a2fa..b541745 100644
--- a/net/spdy/hpack_input_stream_test.cc
+++ b/net/spdy/hpack_input_stream_test.cc
@@ -24,7 +24,7 @@ const size_t kLiteralBound = 1024;
 
 class HpackInputStreamTest : public ::testing::Test {
   virtual void SetUp() {
-    std::vector<HpackHuffmanSymbol> code = HpackResponseHuffmanCode();
+    std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
     EXPECT_TRUE(huffman_table.Initialize(&code[0], code.size()));
   }
 
@@ -33,11 +33,10 @@ class HpackInputStreamTest : public ::testing::Test {
 };
 
 const char kEncodedFixture[] = "\x33"  // Length prefix.
-  "\xdf\x7d\xfb\x36\xd3\xd9\xe1\xfc\xfc\x3f\xaf"
-  "\xe7\xab\xfc\xfe\xfc\xbf\xaf\x3e\xdf\x2f"
-  "\x97\x7f\xd3\x6f\xf7\xfd\x79\xf6\xf9\x77"
-  "\xfd\x3d\xe1\x6b\xfa\x46\xfe\x10\xd8\x89"
-  "\x44\x7d\xe1\xce\x18\xe5\x65\xf7\x6c\x2f";
+  "\xc5\xad\xb7\x7f\x87\x6f\xc7\xfb\xf7\xfd\xbf\xbe\xbf\xf3\xf7\xf4"
+  "\xfb\x7e\xbb\xbe\x9f\x5f\x87\xe3\x7f\xef\xed\xfa\xee\xfa\x7c\x3f"
+  "\x1d\x5d\x1a\x23\xce\x54\x64\x36\xcd\x49\x4b\xd5\xd1\xcc\x5f\x05"
+  "\x35\x96\x9b";
 
 const char kDecodedFixture[] =
   "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1";