Switch to standard integer types in net/.

net/url_request/url_fetcher_core.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/url_request/url_fetcher_core.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 137 matching lines @@
   DCHECK(upload_content.empty() || !upload_content_type.empty());
 
   upload_content_type_ = upload_content_type;
   upload_content_ = upload_content;
   upload_content_set_ = true;
 }
 
 void URLFetcherCore::SetUploadFilePath(
     const std::string& upload_content_type,
     const base::FilePath& file_path,
-    uint64 range_offset,
-    uint64 range_length,
+    uint64_t range_offset,
+    uint64_t range_length,
     scoped_refptr<base::TaskRunner> file_task_runner) {
   AssertHasNoUploadData();
   DCHECK(!is_chunked_upload_);
   DCHECK_EQ(upload_range_offset_, 0ULL);
   DCHECK_EQ(upload_range_length_, 0ULL);
   DCHECK(upload_content_type_.empty());
   DCHECK(!upload_content_type.empty());
 
   upload_content_type_ = upload_content_type;
   upload_file_path_ = file_path;
@@ skipping 482 matching lines @@
   // If the context has been shut down, or there's no ThrottlerManager, just
   // start the request.  In the former case, StartURLRequest() will just inform
   // the URLFetcher::Delegate the request has been canceled.
   if (context && context->throttler_manager()) {
     if (!original_url_throttler_entry_.get()) {
       original_url_throttler_entry_ =
           context->throttler_manager()->RegisterRequestUrl(original_url_);
     }
 
     if (original_url_throttler_entry_.get()) {
-      int64 delay =
+      int64_t delay =
           original_url_throttler_entry_->ReserveSendingTimeForNextRequest(
               GetBackoffReleaseTime());
       if (delay != 0) {
         base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
             FROM_HERE, base::Bind(&URLFetcherCore::StartURLRequest, this),
             base::TimeDelta::FromMilliseconds(delay));
         return;
       }
     }
   }
@@ skipping 219 matching lines @@
       (request_type_ != URLFetcher::HEAD)) {
     if (!request_->Read(buffer_.get(), kBufferSize, &bytes_read))
       bytes_read = -1;  // Match OnReadCompleted() interface contract.
   }
   OnReadCompleted(request_.get(), bytes_read);
 }
 
 void URLFetcherCore::InformDelegateUploadProgress() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   if (request_.get()) {
-    int64 current = request_->GetUploadProgress().position();
+    int64_t current = request_->GetUploadProgress().position();
     if (current_upload_bytes_ != current) {
       current_upload_bytes_ = current;
-      int64 total = -1;
+      int64_t total = -1;
       if (!is_chunked_upload_) {
-        total = static_cast<int64>(request_->GetUploadProgress().size());
+        total = static_cast<int64_t>(request_->GetUploadProgress().size());
         // Total may be zero if the UploadDataStream::Init has not been called
         // yet. Don't send the upload progress until the size is initialized.
         if (!total)
           return;
       }
       delegate_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(
               &URLFetcherCore::InformDelegateUploadProgressInDelegateThread,
               this, current, total));
     }
   }
 }
 
 void URLFetcherCore::InformDelegateUploadProgressInDelegateThread(
-    int64 current, int64 total) {
+    int64_t current,
+    int64_t total) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchUploadProgress(fetcher_, current, total);
 }
 
 void URLFetcherCore::InformDelegateDownloadProgress() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/455952 is fixed.
   tracked_objects::ScopedTracker tracking_profile2(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "455952 delegate_task_runner_->PostTask()"));
 
   delegate_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &URLFetcherCore::InformDelegateDownloadProgressInDelegateThread,
           this, current_response_bytes_, total_response_bytes_));
 }
 
 void URLFetcherCore::InformDelegateDownloadProgressInDelegateThread(
-    int64 current, int64 total) {
+    int64_t current,
+    int64_t total) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchDownloadProgress(fetcher_, current, total);
 }
 
 void URLFetcherCore::AssertHasNoUploadData() const {
   DCHECK(!upload_content_set_);
   DCHECK(upload_content_.empty());
   DCHECK(upload_file_path_.empty());
   DCHECK(upload_stream_factory_.is_null());
 }
 
 }  // namespace net