Switch to standard integer types in google_apis/.

google_apis/drive/base_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/base_requests.h"
 
+#include <stddef.h>
+
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/request_sender.h"
 #include "google_apis/drive/request_util.h"
@@ skipping 190 matching lines @@
     LOG(WARNING) << "Error while parsing entry response: " << error_message
                  << ", code: " << error_code << ", json:\n" << trimmed_json;
   }
   return value.Pass();
 }
 
 void GenerateMultipartBody(MultipartType multipart_type,
                            const std::string& predetermined_boundary,
                            const std::vector<ContentTypeAndData>& parts,
                            ContentTypeAndData* output,
-                           std::vector<uint64>* data_offset) {
+                           std::vector<uint64_t>* data_offset) {
   std::string boundary;
   // Generate random boundary.
   if (predetermined_boundary.empty()) {
     while (true) {
       boundary.resize(kBoundarySize);
       for (int i = 0; i < kBoundarySize; ++i) {
         // Subtract 2 from the array size to exclude '\0', and to turn the size
         // into the last index.
         const int last_char_index = arraysize(kBoundaryCharacters) - 2;
         boundary[i] = kBoundaryCharacters[base::RandInt(0,  last_char_index)];
@@ skipping 211 matching lines @@
     DVLOG(1) << "Extra header: " << headers[i];
   }
 
   // Set upload data if available.
   std::string upload_content_type;
   std::string upload_content;
   if (GetContentData(&upload_content_type, &upload_content)) {
     url_fetcher_->SetUploadData(upload_content_type, upload_content);
   } else {
     base::FilePath local_file_path;
-    int64 range_offset = 0;
-    int64 range_length = 0;
+    int64_t range_offset = 0;
+    int64_t range_length = 0;
     if (GetContentFile(&local_file_path, &range_offset, &range_length,
                        &upload_content_type)) {
       url_fetcher_->SetUploadFilePath(
           upload_content_type,
           local_file_path,
           range_offset,
           range_length,
           blocking_task_runner());
     } else {
       // Even if there is no content data, UrlFetcher requires to set empty
@@ skipping 20 matching lines @@
 std::vector<std::string> UrlFetchRequestBase::GetExtraRequestHeaders() const {
   return std::vector<std::string>();
 }
 
 bool UrlFetchRequestBase::GetContentData(std::string* upload_content_type,
                                          std::string* upload_content) {
   return false;
 }
 
 bool UrlFetchRequestBase::GetContentFile(base::FilePath* local_file_path,
-                                         int64* range_offset,
-                                         int64* range_length,
+                                         int64_t* range_offset,
+                                         int64_t* range_length,
                                          std::string* upload_content_type) {
   return false;
 }
 
 void UrlFetchRequestBase::GetOutputFilePath(
     base::FilePath* local_file_path,
     GetContentCallback* get_content_callback) {
 }
 
 void UrlFetchRequestBase::Cancel() {
@@ skipping 86 matching lines @@
 void EntryActionRequest::RunCallbackOnPrematureFailure(DriveApiErrorCode code) {
   callback_.Run(code);
 }
 
 //========================= InitiateUploadRequestBase ========================
 
 InitiateUploadRequestBase::InitiateUploadRequestBase(
     RequestSender* sender,
     const InitiateUploadCallback& callback,
     const std::string& content_type,
-    int64 content_length)
+    int64_t content_length)
     : UrlFetchRequestBase(sender),
       callback_(callback),
       content_type_(content_type),
       content_length_(content_length) {
   DCHECK(!callback_.is_null());
   DCHECK(!content_type_.empty());
   DCHECK_GE(content_length_, 0);
 }
 
 InitiateUploadRequestBase::~InitiateUploadRequestBase() {}
@@ skipping 30 matching lines @@
 
 //============================ UploadRangeResponse =============================
 
 UploadRangeResponse::UploadRangeResponse()
     : code(HTTP_SUCCESS),
       start_position_received(0),
       end_position_received(0) {
 }
 
 UploadRangeResponse::UploadRangeResponse(DriveApiErrorCode code,
-                                         int64 start_position_received,
-                                         int64 end_position_received)
+                                         int64_t start_position_received,
+                                         int64_t end_position_received)
     : code(code),
       start_position_received(start_position_received),
-      end_position_received(end_position_received) {
-}
+      end_position_received(end_position_received) {}
 
 UploadRangeResponse::~UploadRangeResponse() {
 }
 
 //========================== UploadRangeRequestBase ==========================
 
 UploadRangeRequestBase::UploadRangeRequestBase(RequestSender* sender,
                                                const GURL& upload_url)
     : UrlFetchRequestBase(sender),
       upload_url_(upload_url),
@@ skipping 15 matching lines @@
 void UploadRangeRequestBase::ProcessURLFetchResults(
     const URLFetcher* source) {
   DriveApiErrorCode code = GetErrorCode();
   net::HttpResponseHeaders* hdrs = source->GetResponseHeaders();
 
   if (code == HTTP_RESUME_INCOMPLETE) {
     // Retrieve value of the first "Range" header.
     // The Range header is appeared only if there is at least one received
     // byte. So, initialize the positions by 0 so that the [0,0) will be
     // returned via the |callback_| for empty data case.
-    int64 start_position_received = 0;
-    int64 end_position_received = 0;
+    int64_t start_position_received = 0;
+    int64_t end_position_received = 0;
     std::string range_received;
     hdrs->EnumerateHeader(NULL, kUploadResponseRange, &range_received);
     if (!range_received.empty()) {  // Parse the range header.
       std::vector<net::HttpByteRange> ranges;
       if (net::HttpUtil::ParseRangeHeader(range_received, &ranges) &&
           !ranges.empty() ) {
         // We only care about the first start-end pair in the range.
         //
         // Range header represents the range inclusively, while we are treating
         // ranges exclusively (i.e., end_position_received should be one passed
@@ skipping 41 matching lines @@
     DriveApiErrorCode code) {
   OnRangeRequestComplete(
       UploadRangeResponse(code, 0, 0), scoped_ptr<base::Value>());
 }
 
 //========================== ResumeUploadRequestBase =========================
 
 ResumeUploadRequestBase::ResumeUploadRequestBase(
     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)
     : UploadRangeRequestBase(sender, upload_location),
       start_position_(start_position),
       end_position_(end_position),
       content_length_(content_length),
       content_type_(content_type),
       local_file_path_(local_file_path) {
   DCHECK_LE(start_position_, end_position_);
 }
@@ skipping 20 matching lines @@
 
   std::vector<std::string> headers;
   headers.push_back(
       std::string(kUploadContentRange) +
       base::Int64ToString(start_position_) + "-" +
       base::Int64ToString(end_position_ - 1) + "/" +
       base::Int64ToString(content_length_));
   return headers;
 }
 
-bool ResumeUploadRequestBase::GetContentFile(
-    base::FilePath* local_file_path,
-    int64* range_offset,
-    int64* range_length,
-    std::string* upload_content_type) {
+bool ResumeUploadRequestBase::GetContentFile(base::FilePath* local_file_path,
+                                             int64_t* range_offset,
+                                             int64_t* range_length,
+                                             std::string* upload_content_type) {
   if (start_position_ == end_position_) {
     // No content data.
     return false;
   }
 
   *local_file_path = local_file_path_;
   *range_offset = start_position_;
   *range_length = end_position_ - start_position_;
   *upload_content_type = content_type_;
   return true;
 }
 
 //======================== GetUploadStatusRequestBase ========================
 
 GetUploadStatusRequestBase::GetUploadStatusRequestBase(RequestSender* sender,
                                                        const GURL& upload_url,
-                                                       int64 content_length)
+                                                       int64_t content_length)
     : UploadRangeRequestBase(sender, upload_url),
       content_length_(content_length) {}
 
 GetUploadStatusRequestBase::~GetUploadStatusRequestBase() {}
 
 std::vector<std::string>
 GetUploadStatusRequestBase::GetExtraRequestHeaders() const {
   // The header looks like
   // Content-Range: bytes */<content_length>
   // for example:
   // Content-Range: bytes */13851821
   DCHECK_GE(content_length_, 0);
 
   std::vector<std::string> headers;
   headers.push_back(
       std::string(kUploadContentRange) + "*/" +
       base::Int64ToString(content_length_));
   return headers;
 }
 
 //========================= MultipartUploadRequestBase ========================
 
 MultipartUploadRequestBase::MultipartUploadRequestBase(
     base::SequencedTaskRunner* blocking_task_runner,
     const std::string& metadata_json,
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const base::FilePath& local_file_path,
     const FileResourceCallback& callback,
     const ProgressCallback& progress_callback)
     : blocking_task_runner_(blocking_task_runner),
       metadata_json_(metadata_json),
       content_type_(content_type),
       local_path_(local_file_path),
       callback_(callback),
       progress_callback_(progress_callback),
       weak_ptr_factory_(this) {
@@ skipping 72 matching lines @@
     notify_complete_callback.Run();
   }
 }
 
 void MultipartUploadRequestBase::NotifyError(DriveApiErrorCode code) {
   callback_.Run(code, scoped_ptr<FileResource>());
 }
 
 void MultipartUploadRequestBase::NotifyUploadProgress(
     const net::URLFetcher* source,
-    int64 current,
-    int64 total) {
+    int64_t current,
+    int64_t total) {
   if (!progress_callback_.is_null())
     progress_callback_.Run(current, total);
 }
 
 void MultipartUploadRequestBase::OnDataParsed(
     DriveApiErrorCode code,
     const base::Closure& notify_complete_callback,
     scoped_ptr<base::Value> value) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (value)
@@ skipping 33 matching lines @@
 void DownloadFileRequestBase::GetOutputFilePath(
     base::FilePath* local_file_path,
     GetContentCallback* get_content_callback) {
   // Configure so that the downloaded content is saved to |output_file_path_|.
   *local_file_path = output_file_path_;
   *get_content_callback = get_content_callback_;
 }
 
 void DownloadFileRequestBase::OnURLFetchDownloadProgress(
     const URLFetcher* source,
-    int64 current,
-    int64 total) {
+    int64_t current,
+    int64_t total) {
   if (!progress_callback_.is_null())
     progress_callback_.Run(current, total);
 }
 
 void DownloadFileRequestBase::ProcessURLFetchResults(const URLFetcher* source) {
   DriveApiErrorCode code = GetErrorCode();
 
   // Take over the ownership of the the downloaded temp file.
   base::FilePath temp_file;
   if (code == HTTP_SUCCESS) {
     response_writer()->DisownFile();
     temp_file = output_file_path_;
   }
 
   download_action_callback_.Run(code, temp_file);
   OnProcessURLFetchResultsComplete();
 }
 
 void DownloadFileRequestBase::RunCallbackOnPrematureFailure(
     DriveApiErrorCode code) {
   download_action_callback_.Run(code, base::FilePath());
 }
 
 }  // namespace google_apis