Update from https://crrev.com/306655

net/http/http_stream_parser.cc

 // Copyright (c) 2012 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/http/http_stream_parser.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_chunked_decoder.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
 
 namespace net {
 
 namespace {
 
-const size_t kMaxMergedHeaderAndBodySize = 1400;
+const uint64 kMaxMergedHeaderAndBodySize = 1400;
 const size_t kRequestBodyBufferSize = 1 << 14;  // 16KB
 
 std::string GetResponseHeaderLines(const HttpResponseHeaders& headers) {
   std::string raw_headers = headers.raw_headers();
   const char* null_separated_headers = raw_headers.c_str();
   const char* header_line = null_separated_headers;
   std::string cr_separated_headers;
   while (header_line[0] != 0) {
     cr_separated_headers += header_line;
     cr_separated_headers += "\n";
@@ skipping 13 matching lines @@
   // There's at least one |field_name| header.  Check if there are any more
   // such headers, and if so, return true if they have different values.
   std::string field_value2;
   while (headers.EnumerateHeader(&it, field_name, &field_value2)) {
     if (field_value != field_value2)
       return true;
   }
   return false;
 }
 
-base::Value* NetLogSendRequestBodyCallback(int length,
+base::Value* NetLogSendRequestBodyCallback(uint64 length,
                                            bool is_chunked,
                                            bool did_merge,
                                            NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
-  dict->SetInteger("length", length);
+  dict->SetInteger("length", static_cast<int>(length));
   dict->SetBoolean("is_chunked", is_chunked);
   dict->SetBoolean("did_merge", did_merge);
   return dict;
 }
 
 // Returns true if |error_code| is an error for which we give the server a
 // chance to send a body containing error information, if the error was received
 // while trying to upload a request body.
 bool ShouldTryReadingOnUploadError(int error_code) {
   return (error_code == ERR_CONNECTION_RESET);
@@ skipping 168 matching lines @@
       request_body_read_buf_ = request_body_send_buf_;
     }
   }
 
   io_state_ = STATE_SEND_HEADERS;
 
   // If we have a small request body, then we'll merge with the headers into a
   // single write.
   bool did_merge = false;
   if (ShouldMergeRequestHeadersAndBody(request, request_->upload_data_stream)) {
-    size_t merged_size =
-        request_headers_length_ + request_->upload_data_stream->size();
+    int merged_size = static_cast<int>(
+        request_headers_length_ + request_->upload_data_stream->size());
     scoped_refptr<IOBuffer> merged_request_headers_and_body(
         new IOBuffer(merged_size));
     // We'll repurpose |request_headers_| to store the merged headers and
     // body.
     request_headers_ = new DrainableIOBuffer(
         merged_request_headers_and_body.get(), merged_size);
 
     memcpy(request_headers_->data(), request.data(), request_headers_length_);
     request_headers_->DidConsume(request_headers_length_);
 
-    size_t todo = request_->upload_data_stream->size();
+    uint64 todo = request_->upload_data_stream->size();
     while (todo) {
-      int consumed = request_->upload_data_stream
-          ->Read(request_headers_.get(), todo, CompletionCallback());
+      int consumed = request_->upload_data_stream->Read(
+          request_headers_.get(), static_cast<int>(todo), CompletionCallback());
       DCHECK_GT(consumed, 0);  // Read() won't fail if not chunked.
       request_headers_->DidConsume(consumed);
       todo -= consumed;
     }
     DCHECK(request_->upload_data_stream->IsEOF());
     // Reset the offset, so the buffer can be read from the beginning.
     request_headers_->SetOffset(0);
     did_merge = true;
 
     net_log_.AddEvent(
@@ skipping 770 matching lines @@
 }
 
 // static
 bool HttpStreamParser::ShouldMergeRequestHeadersAndBody(
     const std::string& request_headers,
     const UploadDataStream* request_body) {
   if (request_body != NULL &&
       // IsInMemory() ensures that the request body is not chunked.
       request_body->IsInMemory() &&
       request_body->size() > 0) {
-    size_t merged_size = request_headers.size() + request_body->size();
+    uint64 merged_size = request_headers.size() + request_body->size();
     if (merged_size <= kMaxMergedHeaderAndBodySize)
       return true;
   }
   return false;
 }
 
 }  // namespace net