Remove limit on individual hpack string literals.

net/spdy/hpack/hpack_input_stream.cc

 // Copyright 2014 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/hpack/hpack_input_stream.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "net/spdy/hpack/hpack_huffman_decoder.h"
 #include "net/spdy/spdy_bug_tracker.h"
 
 namespace net {
 
 using base::StringPiece;
 using std::string;
 
-HpackInputStream::HpackInputStream(uint32_t max_string_literal_size,
-                                   StringPiece buffer)
-    : max_string_literal_size_(max_string_literal_size),
-      buffer_(buffer),
+HpackInputStream::HpackInputStream(StringPiece buffer)
+    : buffer_(buffer),
       bit_offset_(0),
       parsed_bytes_(0),
       parsed_bytes_current_(0),
       need_more_data_(false) {}
 
 HpackInputStream::~HpackInputStream() {}
 
 bool HpackInputStream::HasMoreData() const {
   return !buffer_.empty();
 }
@@ skipping 88 matching lines @@
 
   return !has_more;
 }
 
 bool HpackInputStream::DecodeNextIdentityString(StringPiece* str) {
   uint32_t size = 0;
   if (!DecodeNextUint32(&size)) {
     return false;
   }
 
-  if (size > max_string_literal_size_) {
-    return false;
-  }
-
   if (size > buffer_.size()) {
     need_more_data_ = true;
     return false;
   }
 
   *str = StringPiece(buffer_.data(), size);
   buffer_.remove_prefix(size);
   parsed_bytes_current_ += size;
   return true;
 }
 
 bool HpackInputStream::DecodeNextHuffmanString(string* str) {
   uint32_t encoded_size = 0;
   if (!DecodeNextUint32(&encoded_size)) {
     if (!need_more_data_) {
       DVLOG(1) << "HpackInputStream::DecodeNextHuffmanString "
                << "unable to decode size";
     }
     return false;
   }
 
   if (encoded_size > buffer_.size()) {
     need_more_data_ = true;
     DVLOG(1) << "HpackInputStream::DecodeNextHuffmanString " << encoded_size
              << " > " << buffer_.size();
     return false;
   }
 
-  HpackInputStream bounded_reader(max_string_literal_size_,
-                                  StringPiece(buffer_.data(), encoded_size));
+  HpackInputStream bounded_reader(StringPiece(buffer_.data(), encoded_size));
   buffer_.remove_prefix(encoded_size);
   parsed_bytes_current_ += encoded_size;
 
-  // DecodeString will not append more than |max_string_literal_size_| chars
-  // to |str|.
-  return HpackHuffmanDecoder::DecodeString(&bounded_reader,
-                                           max_string_literal_size_, str);
+  return HpackHuffmanDecoder::DecodeString(&bounded_reader, str);
 }
 
 bool HpackInputStream::PeekBits(size_t* peeked_count, uint32_t* out) const {
   size_t byte_offset = (bit_offset_ + *peeked_count) / 8;
   size_t bit_offset = (bit_offset_ + *peeked_count) % 8;
 
   if (*peeked_count >= 32 || byte_offset >= buffer_.size()) {
     return false;
   }
   // We'll read the minimum of the current byte remainder,
@@ skipping 72 matching lines @@
 
 bool HpackInputStream::NeedMoreData() const {
   return need_more_data_;
 }
 
 void HpackInputStream::MarkCurrentPosition() {
   parsed_bytes_ = parsed_bytes_current_;
 }
 
 }  // namespace net