Snapshot of all changes to get jumbo in blink and content.

net/spdy/core/hpack/hpack_huffman_decoder_test.cc

 // 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/spdy/core/hpack/hpack_huffman_decoder.h"
 
 #include <bitset>
 #include <limits>
 
 #include "base/logging.h"
@@ skipping 15 matching lines @@
 uint32_t RandUint32() {
   return static_cast<uint32_t>(base::RandUint64() & 0xffffffff);
 }
 
 }  // anonymous namespace
 
 // Bits(HuffmanWord) constructs a bitset<32>, which produces nicely formatted
 // binary numbers when LOG'd.
 typedef std::bitset<32> Bits;
 
-typedef HpackHuffmanDecoder::HuffmanWord HuffmanWord;
-typedef HpackHuffmanDecoder::HuffmanCodeLength HuffmanCodeLength;
+typedef SpdyHpackHuffmanDecoder::HuffmanWord HuffmanWord;
+typedef SpdyHpackHuffmanDecoder::HuffmanCodeLength HuffmanCodeLength;
 
 class HpackHuffmanDecoderPeer {
  public:
   static HuffmanCodeLength CodeLengthOfPrefix(HuffmanWord value) {
-    return HpackHuffmanDecoder::CodeLengthOfPrefix(value);
+    return SpdyHpackHuffmanDecoder::CodeLengthOfPrefix(value);
   }
 
   static HuffmanWord DecodeToCanonical(HuffmanCodeLength code_length,
                                        HuffmanWord bits) {
-    return HpackHuffmanDecoder::DecodeToCanonical(code_length, bits);
+    return SpdyHpackHuffmanDecoder::DecodeToCanonical(code_length, bits);
   }
 
   static uint8_t CanonicalToSource(HuffmanWord canonical) {
-    return HpackHuffmanDecoder::CanonicalToSource(canonical);
+    return SpdyHpackHuffmanDecoder::CanonicalToSource(canonical);
   }
 };
 
 // Tests of the ability to decode the HPACK Huffman Code, defined in:
 //     https://httpwg.github.io/specs/rfc7541.html#huffman.code
 class HpackHuffmanDecoderTest : public ::testing::Test {
  protected:
   HpackHuffmanDecoderTest() : table_(ObtainHpackHuffmanTable()) {}
 
   // Since kHpackHuffmanCode doesn't include the canonical symbol value,
@@ skipping 108 matching lines @@
       a2b_hex("25a849e95ba97d7f"),
       "custom-key",
       a2b_hex("25a849e95bb8e8b4bf"),
       "custom-value",
   };
   // Round-trip each test example.
   for (size_t i = 0; i != arraysize(test_table); i += 2) {
     const SpdyString& encodedFixture(test_table[i]);
     const SpdyString& decodedFixture(test_table[i + 1]);
     HpackInputStream input_stream(encodedFixture);
-    EXPECT_TRUE(HpackHuffmanDecoder::DecodeString(&input_stream, &buffer));
+    EXPECT_TRUE(SpdyHpackHuffmanDecoder::DecodeString(&input_stream, &buffer));
     EXPECT_EQ(decodedFixture, buffer);
     buffer = EncodeString(decodedFixture);
     EXPECT_EQ(encodedFixture, buffer);
   }
 }
 
 TEST_F(HpackHuffmanDecoderTest, SpecResponseExamples) {
   SpdyString buffer;
   // clang-format off
   SpdyString test_table[] = {
@@ skipping 11 matching lines @@
             "d5af27087f3672c1ab270fb5291f9587"
             "316065c003ed4ee5b1063d5007"),
     "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1",
   };
   // clang-format on
   // Round-trip each test example.
   for (size_t i = 0; i != arraysize(test_table); i += 2) {
     const SpdyString& encodedFixture(test_table[i]);
     const SpdyString& decodedFixture(test_table[i + 1]);
     HpackInputStream input_stream(encodedFixture);
-    EXPECT_TRUE(HpackHuffmanDecoder::DecodeString(&input_stream, &buffer));
+    EXPECT_TRUE(SpdyHpackHuffmanDecoder::DecodeString(&input_stream, &buffer));
     EXPECT_EQ(decodedFixture, buffer);
     buffer = EncodeString(decodedFixture);
     EXPECT_EQ(encodedFixture, buffer);
   }
 }
 
 TEST_F(HpackHuffmanDecoderTest, RoundTripIndividualSymbols) {
   for (size_t i = 0; i != 256; i++) {
     char c = static_cast<char>(i);
     char storage[3] = {c, c, c};
     SpdyStringPiece input(storage, arraysize(storage));
     SpdyString buffer_in = EncodeString(input);
     SpdyString buffer_out;
     HpackInputStream input_stream(buffer_in);
-    EXPECT_TRUE(HpackHuffmanDecoder::DecodeString(&input_stream, &buffer_out));
+    EXPECT_TRUE(SpdyHpackHuffmanDecoder::DecodeString(&input_stream, &buffer_out));
     EXPECT_EQ(input, buffer_out);
   }
 }
 
 // Creates 256 input strings, each with a unique byte value i used to sandwich
 // all the other higher byte values.
 TEST_F(HpackHuffmanDecoderTest, RoundTripSymbolSequences) {
   SpdyString input;
   SpdyString encoded;
   SpdyString decoded;
   for (size_t i = 0; i != 256; i++) {
     input.clear();
     auto ic = static_cast<char>(i);
     input.push_back(ic);
     for (size_t j = i; j != 256; j++) {
       input.push_back(static_cast<char>(j));
       input.push_back(ic);
     }
     EncodeString(input, &encoded);
     HpackInputStream input_stream(encoded);
-    EXPECT_TRUE(HpackHuffmanDecoder::DecodeString(&input_stream, &decoded));
+    EXPECT_TRUE(SpdyHpackHuffmanDecoder::DecodeString(&input_stream, &decoded));
     EXPECT_EQ(input, decoded);
   }
 }
 
 }  // namespace test
 }  // namespace net