Reland of HttpChunkedDecoder: Support chunks longer than 2^31-1 bytes.

net/http/http_chunked_decoder.cc

 // Copyright (c) 2011 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.
 
 // Derived from:
 //   mozilla/netwerk/protocol/http/src/nsHttpChunkedDecoder.cpp
 // The license block is:
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
@@ skipping 51 matching lines @@
     : chunk_remaining_(0),
       chunk_terminator_remaining_(false),
       reached_last_chunk_(false),
       reached_eof_(false),
       bytes_after_eof_(0) {
 }
 
 int HttpChunkedDecoder::FilterBuf(char* buf, int buf_len) {
   int result = 0;
 
-  while (buf_len) {
-    if (chunk_remaining_) {
-      int num = std::min(chunk_remaining_, buf_len);
+  while (buf_len > 0) {
+    if (chunk_remaining_ > 0) {
+      // Since |chunk_remaining_| is positive and |buf_len| an int, the minimum
+      // of the two must be an int.
+      int num = static_cast<int>(
+          std::min(chunk_remaining_, static_cast<int64_t>(buf_len)));
 
       buf_len -= num;
       chunk_remaining_ -= num;
 
       result += num;
       buf += num;
 
-      // After each chunk's data there should be a CRLF
-      if (!chunk_remaining_)
+      // After each chunk's data there should be a CRLF.
+      if (chunk_remaining_ == 0)
         chunk_terminator_remaining_ = true;
       continue;
     } else if (reached_eof_) {
       bytes_after_eof_ += buf_len;
       break;  // Done!
     }
 
     int bytes_consumed = ScanForChunkRemaining(buf, buf_len);
     if (bytes_consumed < 0)
       return bytes_consumed; // Error
 
     buf_len -= bytes_consumed;
-    if (buf_len)
+    if (buf_len > 0)
       memmove(buf, buf + bytes_consumed, buf_len);
   }
 
   return result;
 }
 
 int HttpChunkedDecoder::ScanForChunkRemaining(const char* buf, int buf_len) {
   DCHECK_EQ(0, chunk_remaining_);
   DCHECK_GT(buf_len, 0);
 
   int bytes_consumed = 0;
 
   size_t index_of_lf = base::StringPiece(buf, buf_len).find('\n');
   if (index_of_lf != base::StringPiece::npos) {
     buf_len = static_cast<int>(index_of_lf);
     if (buf_len && buf[buf_len - 1] == '\r')  // Eliminate a preceding CR.
       buf_len--;
     bytes_consumed = static_cast<int>(index_of_lf) + 1;
 
     // Make buf point to the full line buffer to parse.
     if (!line_buf_.empty()) {
       line_buf_.append(buf, buf_len);
       buf = line_buf_.data();
       buf_len = static_cast<int>(line_buf_.size());
     }
 
     if (reached_last_chunk_) {
-      if (buf_len)
+      if (buf_len > 0)
         DVLOG(1) << "ignoring http trailer";
       else
         reached_eof_ = true;
     } else if (chunk_terminator_remaining_) {
-      if (buf_len) {
+      if (buf_len > 0) {
         DLOG(ERROR) << "chunk data not terminated properly";
         return ERR_INVALID_CHUNKED_ENCODING;
       }
       chunk_terminator_remaining_ = false;
-    } else if (buf_len) {
+    } else if (buf_len > 0) {
       // Ignore any chunk-extensions.
       size_t index_of_semicolon = base::StringPiece(buf, buf_len).find(';');
       if (index_of_semicolon != base::StringPiece::npos)
         buf_len = static_cast<int>(index_of_semicolon);
 
       if (!ParseChunkSize(buf, buf_len, &chunk_remaining_)) {
         DLOG(ERROR) << "Failed parsing HEX from: " <<
             std::string(buf, buf_len);
         return ERR_INVALID_CHUNKED_ENCODING;
       }
@@ skipping 37 matching lines @@
 //   RFC 7230: ^\X+$
 //        IE7: ^\X+[^\X]*$
 // Safari 3.1: ^[\t\r ]*\X+[\t ]*$
 //  Firefox 3: ^[\t\f\v\r ]*[+]?(0x)?\X+[^\X]*$
 // Opera 9.51: ^[\t\f\v ]*[+]?(0x)?\X+[^\X]*$
 //
 // Our strategy is to be as strict as possible, while not breaking
 // known sites.
 //
 //         Us: ^\X+[ ]*$
-bool HttpChunkedDecoder::ParseChunkSize(const char* start, int len, int* out) {
+bool HttpChunkedDecoder::ParseChunkSize(const char* start,
+                                        int len,
+                                        int64_t* out) {
   DCHECK_GE(len, 0);
 
   // Strip trailing spaces
-  while (len && start[len - 1] == ' ')
+  while (len > 0 && start[len - 1] == ' ')
     len--;
 
-  // Be more restrictive than HexStringToInt;
+  // Be more restrictive than HexStringToInt64;
   // don't allow inputs with leading "-", "+", "0x", "0X"
   base::StringPiece chunk_size(start, len);
   if (chunk_size.find_first_not_of("0123456789abcdefABCDEF")
       != base::StringPiece::npos) {
     return false;
   }
 
-  int parsed_number;
-  bool ok = base::HexStringToInt(chunk_size, &parsed_number);
+  int64_t parsed_number;
+  bool ok = base::HexStringToInt64(chunk_size, &parsed_number);
   if (ok && parsed_number >= 0) {
     *out = parsed_number;
     return true;
   }
   return false;
 }
 
 }  // namespace net