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

net/spdy/core/hpack/hpack_huffman_decoder.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.
 //
 // Decoder for strings encoded using the HPACK Huffman Code (see
 // https://httpwg.github.io/specs/rfc7541.html#huffman.code).
 //
 // This implementation is inspired by the One-Shift algorithm described in
 // "On the Implementation of Minimum Redundancy Prefix Codes", by Alistair
 // Moffat and Andrew Turpin, 1997.
@@ skipping 17 matching lines @@
 #include <bitset>
 #include <limits>
 #include <utility>
 
 #include "base/logging.h"
 #include "net/spdy/core/hpack/hpack_input_stream.h"
 
 namespace net {
 namespace {
 
-typedef HpackHuffmanDecoder::HuffmanWord HuffmanWord;
-typedef HpackHuffmanDecoder::HuffmanCodeLength HuffmanCodeLength;
+typedef SpdyHpackHuffmanDecoder::HuffmanWord HuffmanWord;
+typedef SpdyHpackHuffmanDecoder::HuffmanCodeLength HuffmanCodeLength;
 
 const HuffmanCodeLength kHuffmanWordLength =
     std::numeric_limits<HuffmanWord>::digits;
 
 const HuffmanCodeLength kMinCodeLength = 5;
 const HuffmanCodeLength kMaxCodeLength = 30;
 
 const HuffmanWord kInvalidLJCode = ~static_cast<HuffmanWord>(0);
 // Length of a code in bits to the first code with that length, left-justified.
 // Note that this can be computed from kLengthToFirstCanonical.
@@ skipping 123 matching lines @@
 
 #endif  // DCHECK_IS_ON()
 
 }  // namespace
 
 // TODO(jamessynge): Should we read these magic numbers from
 // kLengthToFirstLJCode? Would that reduce cache consumption? Slow decoding?
 // TODO(jamessynge): Is this being inlined by the compiler? Should we inline
 // into DecodeString the tests for code lengths 5 through 8 (> 99% of codes
 // according to the HPACK spec)?
-HpackHuffmanDecoder::HuffmanCodeLength HpackHuffmanDecoder::CodeLengthOfPrefix(
-    HpackHuffmanDecoder::HuffmanWord value) {
+SpdyHpackHuffmanDecoder::HuffmanCodeLength SpdyHpackHuffmanDecoder::CodeLengthOfPrefix(
+    SpdyHpackHuffmanDecoder::HuffmanWord value) {
   HuffmanCodeLength length;
   if (value < 0xb8000000) {
     if (value < 0x50000000) {
       length = 5;
     } else {
       length = 6;
     }
   } else {
     if (value < 0xfe000000) {
       if (value < 0xf8000000) {
@@ skipping 65 matching lines @@
               }
             }
           }
         }
       }
     }
   }
   return length;
 }
 
-HuffmanWord HpackHuffmanDecoder::DecodeToCanonical(
+HuffmanWord SpdyHpackHuffmanDecoder::DecodeToCanonical(
     HuffmanCodeLength code_length,
     HuffmanWord bits) {
   DCHECK_LE(kMinCodeLength, code_length);
   DCHECK_LE(code_length, kMaxCodeLength);
 
   // What is the first left-justified code of length |code_length|?
   HuffmanWord first_lj_code = kLengthToFirstLJCode[code_length];
   DCHECK_NE(kInvalidLJCode, first_lj_code);
 
   // Which canonical symbol corresponds to the high order |code_length|
   // bits of |first_lj_code|?
   HuffmanWord first_canonical = kLengthToFirstCanonical[code_length];
   DCHECK_NE(kInvalidCanonical, first_canonical);
 
   // What is the position of the canonical symbol being decoded within
   // the canonical symbols of length |code_length|?
   HuffmanWord ordinal_in_length =
       ((bits - first_lj_code) >> (kHuffmanWordLength - code_length));
 
   // Combined these two to produce the position of the canonical symbol
   // being decoded within all of the canonical symbols.
   return first_canonical + ordinal_in_length;
 }
 
-uint8_t HpackHuffmanDecoder::CanonicalToSource(HuffmanWord canonical) {
+uint8_t SpdyHpackHuffmanDecoder::CanonicalToSource(HuffmanWord canonical) {
   DCHECK_LT(canonical, 256u);
   return kCanonicalToSymbol[canonical];
 }
 
 // TODO(jamessynge): Maybe further refactorings, including just passing in a
 // SpdyStringPiece instead of an HpackInputStream, thus avoiding the PeekBits
 // calls, and also allowing us to separate the code into portions dealing with
 // long strings, and a later portion dealing with the last few bytes of strings.
 // TODO(jamessynge): Determine if that is worth it by adding some counters to
 // measure the distribution of string sizes seen in practice.
-bool HpackHuffmanDecoder::DecodeString(HpackInputStream* in, SpdyString* out) {
+bool SpdyHpackHuffmanDecoder::DecodeString(HpackInputStream* in, SpdyString* out) {
   out->clear();
 
   // Load |bits| with the leading bits of the input stream, left justified
   // (i.e. the bits of the first byte are the high-order bits of |bits|,
   // and the bits of the fourth byte are the low-order bits of |bits|).
   // |peeked_success| if there are more bits in |*in| (i.e. the encoding
   // of the string to be decoded is more than 4 bytes).
 
   auto bits_available_and_bits = in->InitializePeekBits();
   HuffmanCodeLength bits_available = bits_available_and_bits.first;
@@ skipping 74 matching lines @@
       // Get some more bits for decoding (up to 8). |peeked_success| is true
       // if we got any bits.
       peeked_success = in->PeekBits(&bits_available, &bits);
     }
     DLOG_IF(WARNING, (VLOG_IS_ON(2) && bits_available < 32 && !peeked_success))
         << "no more peeking possible";
   }
 }
 
 }  // namespace net