Switch to standard integer types in net/.

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/metrics/histogram_macros.h"
@@ skipping 26 matching lines @@
   HEADER_HTTP_09_RESPONSE_OVER_SSL = 6,
   HEADER_HTTP_09_ON_REUSED_SOCKET = 7,
   NUM_HEADER_EVENTS
 };
 
 void RecordHeaderParserEvent(HttpHeaderParserEvent header_event) {
   UMA_HISTOGRAM_ENUMERATION("Net.HttpHeaderParserEvent", header_event,
                             NUM_HEADER_EVENTS);
 }
 
-const uint64 kMaxMergedHeaderAndBodySize = 1400;
+const uint64_t 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 14 matching lines @@
   // 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;
 }
 
 scoped_ptr<base::Value> NetLogSendRequestBodyCallback(
-    uint64 length,
+    uint64_t length,
     bool is_chunked,
     bool did_merge,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("length", static_cast<int>(length));
   dict->SetBoolean("is_chunked", is_chunked);
   dict->SetBoolean("did_merge", did_merge);
   return dict.Pass();
 }
 
@@ skipping 187 matching lines @@
     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_);
 
-    uint64 todo = request_->upload_data_stream->size();
+    uint64_t todo = request_->upload_data_stream->size();
     while (todo) {
       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);
@@ skipping 427 matching lines @@
     // Save the overflow data, which can be in two places.  There may be
     // some left over in |user_read_buf_|, plus there may be more
     // in |read_buf_|.  But the part left over in |user_read_buf_| must have
     // come from the |read_buf_|, so there's room to put it back at the
     // start first.
     int additional_save_amount = read_buf_->offset() - read_buf_unused_offset_;
     int save_amount = 0;
     if (chunked_decoder_.get()) {
       save_amount = chunked_decoder_->bytes_after_eof();
     } else if (response_body_length_ >= 0) {
-      int64 extra_data_read = response_body_read_ - response_body_length_;
+      int64_t extra_data_read = response_body_read_ - response_body_length_;
       if (extra_data_read > 0) {
         save_amount = static_cast<int>(extra_data_read);
         if (result > 0)
           result -= save_amount;
       }
     }
 
     CHECK_LE(save_amount + additional_save_amount, kMaxBufSize);
     if (read_buf_->capacity() < save_amount + additional_save_amount) {
       read_buf_->SetCapacity(save_amount + additional_save_amount);
@@ skipping 374 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) {
-    uint64 merged_size = request_headers.size() + request_body->size();
+    uint64_t merged_size = request_headers.size() + request_body->size();
     if (merged_size <= kMaxMergedHeaderAndBodySize)
       return true;
   }
   return false;
 }
 
 void HttpStreamParser::ValidateStatusLine(const std::string& status_line) {
   HttpStatusLineValidator::StatusLineStatus status =
       HttpStatusLineValidator::ValidateStatusLine(status_line);
   UMA_HISTOGRAM_ENUMERATION("Net.HttpStatusLineStatus", status,
                             HttpStatusLineValidator::STATUS_LINE_MAX);
 }
 
 }  // namespace net