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

components/drive/service/drive_api_service.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/service/drive_api_service.h"
 
+#include <stddef.h>
+
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
 #include "components/drive/drive_api_util.h"
 #include "google_apis/drive/auth_service.h"
 #include "google_apis/drive/base_requests.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/drive_api_requests.h"
@@ skipping 157 matching lines @@
 }
 
 BatchRequestConfigurator::~BatchRequestConfigurator() {
   // The batch requst has not been committed.
   if (batch_request_)
     cancel_callback_.Run();
 }
 
 google_apis::CancelCallback BatchRequestConfigurator::MultipartUploadNewFile(
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const std::string& parent_resource_id,
     const std::string& title,
     const base::FilePath& local_file_path,
     const UploadNewFileOptions& options,
     const google_apis::FileResourceCallback& callback,
     const google_apis::ProgressCallback& progress_callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   scoped_ptr<google_apis::BatchableDelegate> delegate(
       new google_apis::drive::MultipartUploadNewFileDelegate(
           task_runner_.get(), title, parent_resource_id, content_type,
           content_length, options.modified_date, options.last_viewed_by_me_date,
           local_file_path, options.properties, url_generator_, callback,
           progress_callback));
   // Batch request can be null when pre-authorization for the requst is failed
   // in request sender.
   if (batch_request_)
     batch_request_->AddRequest(delegate.release());
   else
     delegate->NotifyError(DRIVE_OTHER_ERROR);
   return cancel_callback_;
 }
 
 google_apis::CancelCallback
 BatchRequestConfigurator::MultipartUploadExistingFile(
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const std::string& resource_id,
     const base::FilePath& local_file_path,
     const UploadExistingFileOptions& options,
     const google_apis::FileResourceCallback& callback,
     const google_apis::ProgressCallback& progress_callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   scoped_ptr<google_apis::BatchableDelegate> delegate(
       new google_apis::drive::MultipartUploadExistingFileDelegate(
@@ skipping 152 matching lines @@
 
   FilesListRequest* request = new FilesListRequest(
       sender_.get(), url_generator_, callback);
   request->set_max_results(kMaxNumFilesResourcePerRequest);
   request->set_q(query);
   request->set_fields(kFileListFields);
   return sender_->StartRequestWithAuthRetry(request);
 }
 
 CancelCallback DriveAPIService::GetChangeList(
-    int64 start_changestamp,
+    int64_t start_changestamp,
     const ChangeListCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   ChangesListRequest* request = new ChangesListRequest(
       sender_.get(), url_generator_, callback);
   request->set_max_results(kMaxNumFilesResourcePerRequest);
   request->set_start_change_id(start_changestamp);
   request->set_fields(kChangeListFields);
   return sender_->StartRequestWithAuthRetry(request);
@@ skipping 221 matching lines @@
 
   ChildrenDeleteRequest* request =
       new ChildrenDeleteRequest(sender_.get(), url_generator_, callback);
   request->set_child_id(resource_id);
   request->set_folder_id(parent_resource_id);
   return sender_->StartRequestWithAuthRetry(request);
 }
 
 CancelCallback DriveAPIService::InitiateUploadNewFile(
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const std::string& parent_resource_id,
     const std::string& title,
     const UploadNewFileOptions& options,
     const InitiateUploadCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   InitiateUploadNewFileRequest* request =
       new InitiateUploadNewFileRequest(sender_.get(),
                                        url_generator_,
                                        content_type,
                                        content_length,
                                        parent_resource_id,
                                        title,
                                        callback);
   request->set_modified_date(options.modified_date);
   request->set_last_viewed_by_me_date(options.last_viewed_by_me_date);
   request->set_properties(options.properties);
   return sender_->StartRequestWithAuthRetry(request);
 }
 
 CancelCallback DriveAPIService::InitiateUploadExistingFile(
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const std::string& resource_id,
     const UploadExistingFileOptions& options,
     const InitiateUploadCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   InitiateUploadExistingFileRequest* request =
       new InitiateUploadExistingFileRequest(sender_.get(),
                                             url_generator_,
                                             content_type,
                                             content_length,
                                             resource_id,
                                             options.etag,
                                             callback);
   request->set_parent_resource_id(options.parent_resource_id);
   request->set_title(options.title);
   request->set_modified_date(options.modified_date);
   request->set_last_viewed_by_me_date(options.last_viewed_by_me_date);
   request->set_properties(options.properties);
   return sender_->StartRequestWithAuthRetry(request);
 }
 
 CancelCallback DriveAPIService::ResumeUpload(
     const GURL& upload_url,
-    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) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithAuthRetry(new ResumeUploadRequest(
       sender_.get(), upload_url, start_position, end_position, content_length,
       content_type, local_file_path, callback, progress_callback));
 }
 
 CancelCallback DriveAPIService::GetUploadStatus(
     const GURL& upload_url,
-    int64 content_length,
+    int64_t content_length,
     const UploadRangeCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithAuthRetry(new GetUploadStatusRequest(
       sender_.get(), upload_url, content_length, callback));
 }
 
 CancelCallback DriveAPIService::MultipartUploadNewFile(
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const std::string& parent_resource_id,
     const std::string& title,
     const base::FilePath& local_file_path,
     const drive::UploadNewFileOptions& options,
     const FileResourceCallback& callback,
     const google_apis::ProgressCallback& progress_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithAuthRetry(
       new google_apis::drive::SingleBatchableDelegateRequest(
           sender_.get(),
           new google_apis::drive::MultipartUploadNewFileDelegate(
               sender_->blocking_task_runner(), title, parent_resource_id,
               content_type, content_length, options.modified_date,
               options.last_viewed_by_me_date, local_file_path,
               options.properties, url_generator_, callback,
               progress_callback)));
 }
 
 CancelCallback DriveAPIService::MultipartUploadExistingFile(
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const std::string& resource_id,
     const base::FilePath& local_file_path,
     const drive::UploadExistingFileOptions& options,
     const FileResourceCallback& callback,
     const google_apis::ProgressCallback& progress_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithAuthRetry(
       new google_apis::drive::SingleBatchableDelegateRequest(
@@ skipping 127 matching lines @@
   // reference to RequestSender and we should ensure to delete the request when
   // the sender is deleted. Resolve the circulating dependency and fix it.
   const google_apis::CancelCallback callback =
       sender_->StartRequestWithAuthRetry(request.release());
   return make_scoped_ptr<BatchRequestConfiguratorInterface>(
       new BatchRequestConfigurator(weak_ref, sender_->blocking_task_runner(),
                                    url_generator_, callback));
 }
 
 }  // namespace drive