Use the exact-width integer types defined in <stdint.h> rather than

net/base/elements_upload_data_stream.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/base/elements_upload_data_stream.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_element_reader.h"
 
 namespace net {
 
 ElementsUploadDataStream::ElementsUploadDataStream(
     ScopedVector<UploadElementReader> element_readers,
-    int64 identifier)
+    int64_t identifier)
     : UploadDataStream(false, identifier),
       element_readers_(element_readers.Pass()),
       element_index_(0),
       read_failed_(false),
       weak_ptr_factory_(this) {
 }
 
 ElementsUploadDataStream::~ElementsUploadDataStream() {
 }
 
 scoped_ptr<UploadDataStream> ElementsUploadDataStream::CreateWithReader(
     scoped_ptr<UploadElementReader> reader,
-    int64 identifier) {
+    int64_t identifier) {
   ScopedVector<UploadElementReader> readers;
   readers.push_back(reader.Pass());
   return scoped_ptr<UploadDataStream>(
       new ElementsUploadDataStream(readers.Pass(), identifier));
 }
 
 int ElementsUploadDataStream::InitInternal() {
   return InitElements(0);
 }
 
@@ skipping 32 matching lines @@
     int result = reader->Init(
         base::Bind(&ElementsUploadDataStream::OnInitElementCompleted,
                    weak_ptr_factory_.GetWeakPtr(),
                    i));
     DCHECK(result != ERR_IO_PENDING || !reader->IsInMemory());
     DCHECK_LE(result, OK);
     if (result != OK)
       return result;
   }
 
-  uint64 total_size = 0;
+  uint64_t total_size = 0;
   for (size_t i = 0; i < element_readers_.size(); ++i) {
     total_size += element_readers_[i]->GetContentLength();
   }
   SetSize(total_size);
   return OK;
 }
 
 void ElementsUploadDataStream::OnInitElementCompleted(size_t index,
                                                       int result) {
   DCHECK_NE(ERR_IO_PENDING, result);
@@ skipping 26 matching lines @@
                    weak_ptr_factory_.GetWeakPtr(),
                    buf));
     if (result == ERR_IO_PENDING)
       return ERR_IO_PENDING;
     ProcessReadResult(buf, result);
   }
 
   if (read_failed_) {
     // If an error occured during read operation, then pad with zero.
     // Otherwise the server will hang waiting for the rest of the data.
-    int num_bytes_to_fill = static_cast<int>(std::min(
-        static_cast<uint64>(buf->BytesRemaining()),
-        size() - position() - buf->BytesConsumed()));
+    int num_bytes_to_fill =
+        static_cast<int>(std::min(static_cast<uint64_t>(buf->BytesRemaining()),
+                                  size() - position() - buf->BytesConsumed()));
     DCHECK_GE(num_bytes_to_fill, 0);
     memset(buf->data(), 0, num_bytes_to_fill);
     buf->DidConsume(num_bytes_to_fill);
   }
 
   return buf->BytesConsumed();
 }
 
 void ElementsUploadDataStream::OnReadElementCompleted(
     const scoped_refptr<DrainableIOBuffer>& buf,
@@ skipping 12 matching lines @@
   DCHECK(!read_failed_);
 
   if (result >= 0) {
     buf->DidConsume(result);
   } else {
     read_failed_ = true;
   }
 }
 
 }  // namespace net