Switch to standard integer types in google_apis/.

google_apis/drive/drive_api_requests.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 "google_apis/drive/drive_api_requests.h"
 
+#include <stddef.h>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
@@ skipping 777 matching lines @@
 GURL ChildrenDeleteRequest::GetURL() const {
   return url_generator_.GetChildrenDeleteUrl(child_id_, folder_id_);
 }
 
 //======================= InitiateUploadNewFileRequest =======================
 
 InitiateUploadNewFileRequest::InitiateUploadNewFileRequest(
     RequestSender* sender,
     const DriveApiUrlGenerator& url_generator,
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const std::string& parent_resource_id,
     const std::string& title,
     const InitiateUploadCallback& callback)
-    : InitiateUploadRequestBase(sender,
-                                callback,
-                                content_type,
-                                content_length),
+    : InitiateUploadRequestBase(sender, callback, content_type, content_length),
       url_generator_(url_generator),
       parent_resource_id_(parent_resource_id),
-      title_(title) {
-}
+      title_(title) {}
 
 InitiateUploadNewFileRequest::~InitiateUploadNewFileRequest() {}
 
 GURL InitiateUploadNewFileRequest::GetURL() const {
   return url_generator_.GetInitiateUploadNewFileUrl(!modified_date_.is_null());
 }
 
 net::URLFetcher::RequestType
 InitiateUploadNewFileRequest::GetRequestType() const {
   return net::URLFetcher::POST;
@@ skipping 27 matching lines @@
            << *upload_content << "]";
   return true;
 }
 
 //===================== InitiateUploadExistingFileRequest ====================
 
 InitiateUploadExistingFileRequest::InitiateUploadExistingFileRequest(
     RequestSender* sender,
     const DriveApiUrlGenerator& url_generator,
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const std::string& resource_id,
     const std::string& etag,
     const InitiateUploadCallback& callback)
-    : InitiateUploadRequestBase(sender,
-                                callback,
-                                content_type,
-                                content_length),
+    : InitiateUploadRequestBase(sender, callback, content_type, content_length),
       url_generator_(url_generator),
       resource_id_(resource_id),
-      etag_(etag) {
-}
+      etag_(etag) {}
 
 InitiateUploadExistingFileRequest::~InitiateUploadExistingFileRequest() {}
 
 GURL InitiateUploadExistingFileRequest::GetURL() const {
   return url_generator_.GetInitiateUploadExistingFileUrl(
       resource_id_, !modified_date_.is_null());
 }
 
 net::URLFetcher::RequestType
 InitiateUploadExistingFileRequest::GetRequestType() const {
@@ skipping 38 matching lines @@
   DVLOG(1) << "InitiateUploadExistingFile data: " << *upload_content_type
            << ", [" << *upload_content << "]";
   return true;
 }
 
 //============================ ResumeUploadRequest ===========================
 
 ResumeUploadRequest::ResumeUploadRequest(
     RequestSender* sender,
     const GURL& upload_location,
-    int64 start_position,
-    int64 end_position,
-    int64 content_length,
+    int64_t start_position,
+    int64_t end_position,
+    int64_t content_length,
     const std::string& content_type,
     const base::FilePath& local_file_path,
     const UploadRangeCallback& callback,
     const ProgressCallback& progress_callback)
     : ResumeUploadRequestBase(sender,
                               upload_location,
                               start_position,
                               end_position,
                               content_length,
                               content_type,
                               local_file_path),
       callback_(callback),
       progress_callback_(progress_callback) {
   DCHECK(!callback_.is_null());
 }
 
 ResumeUploadRequest::~ResumeUploadRequest() {}
 
 void ResumeUploadRequest::OnRangeRequestComplete(
     const UploadRangeResponse& response,
     scoped_ptr<base::Value> value) {
   DCHECK(CalledOnValidThread());
   ParseFileResourceWithUploadRangeAndRun(callback_, response, value.Pass());
 }
 
 void ResumeUploadRequest::OnURLFetchUploadProgress(
-    const net::URLFetcher* source, int64 current, int64 total) {
+    const net::URLFetcher* source,
+    int64_t current,
+    int64_t total) {
   if (!progress_callback_.is_null())
     progress_callback_.Run(current, total);
 }
 
 //========================== GetUploadStatusRequest ==========================
 
 GetUploadStatusRequest::GetUploadStatusRequest(
     RequestSender* sender,
     const GURL& upload_url,
-    int64 content_length,
+    int64_t content_length,
     const UploadRangeCallback& callback)
-    : GetUploadStatusRequestBase(sender,
-                                 upload_url,
-                                 content_length),
+    : GetUploadStatusRequestBase(sender, upload_url, content_length),
       callback_(callback) {
   DCHECK(!callback.is_null());
 }
 
 GetUploadStatusRequest::~GetUploadStatusRequest() {}
 
 void GetUploadStatusRequest::OnRangeRequestComplete(
     const UploadRangeResponse& response,
     scoped_ptr<base::Value> value) {
   DCHECK(CalledOnValidThread());
   ParseFileResourceWithUploadRangeAndRun(callback_, response, value.Pass());
 }
 
 //======================= MultipartUploadNewFileDelegate =======================
 
 MultipartUploadNewFileDelegate::MultipartUploadNewFileDelegate(
     base::SequencedTaskRunner* task_runner,
     const std::string& title,
     const std::string& parent_resource_id,
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const base::Time& modified_date,
     const base::Time& last_viewed_by_me_date,
     const base::FilePath& local_file_path,
     const Properties& properties,
     const DriveApiUrlGenerator& url_generator,
     const FileResourceCallback& callback,
     const ProgressCallback& progress_callback)
     : MultipartUploadRequestBase(
           task_runner,
           CreateMultipartUploadMetadataJson(title,
                                             parent_resource_id,
                                             modified_date,
                                             last_viewed_by_me_date,
                                             properties),
           content_type,
           content_length,
           local_file_path,
           callback,
           progress_callback),
       has_modified_date_(!modified_date.is_null()),
-      url_generator_(url_generator) {
-}
+      url_generator_(url_generator) {}
 
 MultipartUploadNewFileDelegate::~MultipartUploadNewFileDelegate() {
 }
 
 GURL MultipartUploadNewFileDelegate::GetURL() const {
   return url_generator_.GetMultipartUploadNewFileUrl(has_modified_date_);
 }
 
 net::URLFetcher::RequestType MultipartUploadNewFileDelegate::GetRequestType()
     const {
   return net::URLFetcher::POST;
 }
 
 //====================== MultipartUploadExistingFileDelegate ===================
 
 MultipartUploadExistingFileDelegate::MultipartUploadExistingFileDelegate(
     base::SequencedTaskRunner* task_runner,
     const std::string& title,
     const std::string& resource_id,
     const std::string& parent_resource_id,
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const base::Time& modified_date,
     const base::Time& last_viewed_by_me_date,
     const base::FilePath& local_file_path,
     const std::string& etag,
     const Properties& properties,
     const DriveApiUrlGenerator& url_generator,
     const FileResourceCallback& callback,
     const ProgressCallback& progress_callback)
     : MultipartUploadRequestBase(
           task_runner,
           CreateMultipartUploadMetadataJson(title,
                                             parent_resource_id,
                                             modified_date,
                                             last_viewed_by_me_date,
                                             properties),
           content_type,
           content_length,
           local_file_path,
           callback,
           progress_callback),
       resource_id_(resource_id),
       etag_(etag),
       has_modified_date_(!modified_date.is_null()),
-      url_generator_(url_generator) {
-}
+      url_generator_(url_generator) {}
 
 MultipartUploadExistingFileDelegate::~MultipartUploadExistingFileDelegate() {
 }
 
 std::vector<std::string>
 MultipartUploadExistingFileDelegate::GetExtraRequestHeaders() const {
   std::vector<std::string> headers(
       MultipartUploadRequestBase::GetExtraRequestHeaders());
   headers.push_back(util::GenerateIfMatchHeader(etag_));
   return headers;
@@ skipping 144 matching lines @@
           weak_ptr_factory_.GetWeakPtr()));
 }
 
 void SingleBatchableDelegateRequest::RunCallbackOnPrematureFailure(
     DriveApiErrorCode code) {
   delegate_->NotifyError(code);
 }
 
 void SingleBatchableDelegateRequest::OnURLFetchUploadProgress(
     const net::URLFetcher* source,
-    int64 current,
-    int64 total) {
+    int64_t current,
+    int64_t total) {
   delegate_->NotifyUploadProgress(source, current, total);
 }
 
 //========================== BatchUploadRequest ==========================
 
 BatchUploadChildEntry::BatchUploadChildEntry(BatchableDelegate* request)
     : request(request), prepared(false), data_offset(0), data_size(0) {
 }
 
 BatchUploadChildEntry::~BatchUploadChildEntry() {
@@ skipping 77 matching lines @@
 
 void BatchUploadRequest::MayCompletePrepare() {
   if (!committed_ || prepare_callback_.is_null())
     return;
   for (const auto& child : child_requests_) {
     if (!child->prepared)
       return;
   }
 
   // Build multipart body here.
-  int64 total_size = 0;
+  int64_t total_size = 0;
   std::vector<ContentTypeAndData> parts;
   for (auto& child : child_requests_) {
     std::string type;
     std::string data;
     const bool result = child->request->GetContentData(&type, &data);
     // Upload request must have content data.
     DCHECK(result);
 
     const GURL url = child->request->GetURL();
     std::string method;
@@ skipping 19 matching lines @@
     parts.push_back(ContentTypeAndData());
     parts.back().type = kHttpContentType;
     parts.back().data = header;
     parts.back().data.append(data);
   }
 
   UMA_HISTOGRAM_COUNTS_100(kUMADriveTotalFileCountInBatchUpload, parts.size());
   UMA_HISTOGRAM_MEMORY_KB(kUMADriveTotalFileSizeInBatchUpload,
                           total_size / 1024);
 
-  std::vector<uint64> part_data_offset;
+  std::vector<uint64_t> part_data_offset;
   GenerateMultipartBody(MULTIPART_MIXED, boundary_, parts, &upload_content_,
                         &part_data_offset);
   DCHECK(part_data_offset.size() == child_requests_.size());
   for (size_t i = 0; i < child_requests_.size(); ++i) {
     child_requests_[i]->data_offset += part_data_offset[i];
   }
   prepare_callback_.Run(HTTP_SUCCESS);
 }
 
 bool BatchUploadRequest::GetContentData(std::string* upload_content_type,
@@ skipping 63 matching lines @@
 }
 
 void BatchUploadRequest::RunCallbackOnPrematureFailure(DriveApiErrorCode code) {
   for (auto child : child_requests_) {
     child->request->NotifyError(code);
   }
   child_requests_.clear();
 }
 
 void BatchUploadRequest::OnURLFetchUploadProgress(const net::URLFetcher* source,
-                                                  int64 current,
-                                                  int64 total) {
+                                                  int64_t current,
+                                                  int64_t total) {
   for (auto child : child_requests_) {
     if (child->data_offset <= current &&
         current <= child->data_offset + child->data_size) {
       child->request->NotifyUploadProgress(source, current - child->data_offset,
                                            child->data_size);
     } else if (last_progress_value_ < child->data_offset + child->data_size &&
                child->data_offset + child->data_size < current) {
       child->request->NotifyUploadProgress(source, child->data_size,
                                            child->data_size);
     }
   }
   last_progress_value_ = current;
 }
 }  // namespace drive
 }  // namespace google_apis