Switch to standard integer types in components/, part 1 of 4.

components/drive/drive_uploader.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 "components/drive/drive_uploader.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
+#include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "components/drive/service/drive_service_interface.h"
 #include "content/public/browser/power_save_blocker.h"
 #include "google_apis/drive/drive_api_parser.h"
 
 using google_apis::CancelCallback;
 using google_apis::FileResource;
 using google_apis::DRIVE_CANCELLED;
@@ skipping 10 matching lines @@
 using google_apis::UploadRangeResponse;
 
 namespace drive {
 
 namespace {
 // Upload data is split to multiple HTTP request each conveying kUploadChunkSize
 // bytes (except the request for uploading the last chunk of data).
 // The value must be a multiple of 512KB according to the spec of GData WAPI and
 // Drive API v2. It is set to a smaller value than 2^31 for working around
 // server side error (crbug.com/264089).
-const int64 kUploadChunkSize = (1LL << 30);  // 1GB
+const int64_t kUploadChunkSize = (1LL << 30);  // 1GB
 // Maximum file size to be uploaded by multipart requests. The file that is
 // larger than the size is processed by resumable upload.
-const int64 kMaxMultipartUploadSize = (1LL << 20);  // 1MB
+const int64_t kMaxMultipartUploadSize = (1LL << 20);  // 1MB
 
 // Drive upload protocol. This is used to back a histogram. Sync this with UMA
 // enum "DriveUploadProtocol" and treat this as append-only.
 enum DriveUploadProtocol {
   UPLOAD_METHOD_RESUMABLE,
   UPLOAD_METHOD_MULTIPART,
   UPLOAD_METHOD_BATCH,
   UPLOAD_METHOD_MAX_VALUE
 };
 
@@ skipping 73 matching lines @@
   const UploadCompletionCallback completion_callback;
 
   // Callback to periodically notify the upload progress.
   const ProgressCallback progress_callback;
 
   // Location URL where file is to be uploaded to, returned from
   // InitiateUpload. Used for the subsequent ResumeUpload requests.
   GURL upload_location;
 
   // Header content-Length.
-  int64 content_length;
+  int64_t content_length;
 
-  int64 next_start_position;
+  int64_t next_start_position;
 
   // Blocks system suspend while upload is in progress.
   scoped_ptr<content::PowerSaveBlocker> power_save_blocker;
 
   // Fields for implementing cancellation. |cancel_callback| is non-null if
   // there is an in-flight HTTP request. In that case, |cancell_callback| will
   // cancel the operation. |cancelled| is initially false and turns to true
   // once Cancel() is called. DriveUploader will check this field before after
   // an async task other than HTTP requests and cancels the subsequent requests
   // if this is flagged to true.
@@ skipping 249 matching lines @@
   DCHECK_GE(upload_file_info->next_start_position, 0);
   DCHECK_LE(upload_file_info->next_start_position,
             upload_file_info->content_length);
 
   if (upload_file_info->cancelled) {
     UploadFailed(upload_file_info.Pass(), DRIVE_CANCELLED);
     return;
   }
 
   // Limit the size of data uploaded per each request by kUploadChunkSize.
-  const int64 end_position = std::min(
-      upload_file_info->content_length,
-      upload_file_info->next_start_position + kUploadChunkSize);
+  const int64_t end_position =
+      std::min(upload_file_info->content_length,
+               upload_file_info->next_start_position + kUploadChunkSize);
 
   UploadFileInfo* info_ptr = upload_file_info.get();
   info_ptr->cancel_callback = drive_service_->ResumeUpload(
       info_ptr->upload_location,
       info_ptr->next_start_position,
       end_position,
       info_ptr->content_length,
       info_ptr->content_type,
       info_ptr->file_path,
       base::Bind(&DriveUploader::OnUploadRangeResponseReceived,
@@ skipping 54 matching lines @@
 
   DVLOG(1) << "Received range " << response.start_position_received
            << "-" << response.end_position_received
            << " for [" << upload_file_info->file_path.value() << "]";
 
   upload_file_info->next_start_position = response.end_position_received;
   UploadNextChunk(upload_file_info.Pass());
 }
 
 void DriveUploader::OnUploadProgress(const ProgressCallback& callback,
-                                     int64 start_position,
-                                     int64 total_size,
-                                     int64 progress_of_chunk,
-                                     int64 total_of_chunk) {
+                                     int64_t start_position,
+                                     int64_t total_size,
+                                     int64_t progress_of_chunk,
+                                     int64_t total_of_chunk) {
   if (!callback.is_null())
     callback.Run(start_position + progress_of_chunk, total_size);
 }
 
 void DriveUploader::UploadFailed(scoped_ptr<UploadFileInfo> upload_file_info,
                                  DriveApiErrorCode error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG(1) << "Upload failed " << upload_file_info->DebugString();
 
@@ skipping 22 matching lines @@
   } else {
     DVLOG(1) << "Upload failed " << upload_file_info->DebugString();
     if (error == HTTP_PRECONDITION)
       error = HTTP_CONFLICT;  // ETag mismatch.
     upload_file_info->completion_callback.Run(
         error, upload_file_info->upload_location, scoped_ptr<FileResource>());
   }
 }
 
 }  // namespace drive