Remove limit on individual hpack string literals.

net/spdy/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 286 matching lines @@
   return static_cast<char>(kCanonicalToSymbol[canonical]);
 }
 
 // TODO(jamessynge): Maybe further refactorings, including just passing in a
 // StringPiece 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,
-                                       size_t out_capacity,
                                        std::string* 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();
@@ skipping 44 matching lines @@
             << "    HasMoreData: " << in->HasMoreData();
         return !in->HasMoreData();
       }
       // We're dealing with a long code. It *might* be useful to add a special
       // method to HpackInputStream for getting more than "at most 8" bits
       // at a time.
       do {
         peeked_success = in->PeekBits(&bits_available, &bits);
       } while (peeked_success && bits_available < 32);
     } else {
-      if (out->size() == out_capacity) {
-        // This code would cause us to overflow |out_capacity|.
-        // TODO(jamessynge) Avoid this case by pre-allocating out based on
-        // scaling up the encoded size by 8/5 (shortest codes are 5 bits).
-        DLOG(WARNING) << "Output size too large: " << out_capacity;
-        return false;
-      }
-
       // Convert from the prefix code of length |code_length| to the
       // canonical symbol (i.e. where the input symbols (bytes) are ordered by
       // increasing code length and then by their increasing uint8 value).
       HuffmanWord canonical = DecodeToCanonical(code_length, bits);
 
       bits = bits << code_length;
       bits_available -= code_length;
       in->ConsumeBits(code_length);
 
       if (canonical < 256) {
@@ skipping 11 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(1) && bits_available < 32 && !peeked_success))
         << "no more peeking possible";
   }
 }
 
 }  // namespace net