Switch to standard integer types in google_apis/.

google_apis/drive/base_requests.h

 // 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.
 //
 // This file provides base classes used to issue HTTP requests for Google
 // APIs.
 
 #ifndef GOOGLE_APIS_DRIVE_BASE_REQUESTS_H_
 #define GOOGLE_APIS_DRIVE_BASE_REQUESTS_H_
 
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
+#include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "google_apis/drive/drive_api_error_codes.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_fetcher_response_writer.h"
 #include "url/gurl.h"
 
 namespace base {
 class Value;
@@ skipping 18 matching lines @@
 
 typedef base::Callback<void(DriveApiErrorCode)> PrepareCallback;
 
 // Callback used for requests that the server returns FileResource data
 // formatted into JSON value.
 typedef base::Callback<void(DriveApiErrorCode error,
                             scoped_ptr<FileResource> entry)>
     FileResourceCallback;
 
 // Callback used for DownloadFileRequest and ResumeUploadRequestBase.
-typedef base::Callback<void(int64 progress, int64 total)> ProgressCallback;
+typedef base::Callback<void(int64_t progress, int64_t total)> ProgressCallback;
 
 // Callback used to get the content from DownloadFileRequest.
 typedef base::Callback<void(
     DriveApiErrorCode error,
     scoped_ptr<std::string> content)> GetContentCallback;
 
 // Parses JSON passed in |json|. Returns NULL on failure.
 scoped_ptr<base::Value> ParseJson(const std::string& json);
 
 // Generate multipart body. If |predetermined_boundary| is not empty, it uses
 // the string as boundary. Otherwise it generates random boundary that does not
 // conflict with |parts|. If |data_offset| is not nullptr, it stores the
 // index of first byte of each part in multipart body.
 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);
 
 //======================= AuthenticatedRequestInterface ======================
 
 // An interface class for implementing a request which requires OAuth2
 // authentication.
 class AuthenticatedRequestInterface {
  public:
   // Called when re-authentication is required. See Start() for details.
   typedef base::Callback<void(AuthenticatedRequestInterface* request)>
       ReAuthenticateCallback;
@@ skipping 102 matching lines @@
   // Note that this and GetContentFile() cannot be used together.
   virtual bool GetContentData(std::string* upload_content_type,
                               std::string* upload_content);
 
   // Used by a derived class to add content data which is the whole file or
   // a part of the file at |local_file_path|.
   // Returns true if all the arguments are updated for the content being
   // uploaded.
   // Note that this and GetContentData() cannot be used together.
   virtual bool 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);
 
   // Used by a derived class to set an output file path if they want to save
   // the downloaded content to a file at a specific path.
   // Sets |get_content_callback|, which is called when some part of the response
   // is read.
   virtual void GetOutputFilePath(base::FilePath* local_file_path,
                                  GetContentCallback* get_content_callback);
 
   // Invoked by OnURLFetchComplete when the request completes without an
@@ skipping 78 matching lines @@
                             const std::string& response_body,
                             const base::Closure& callback) = 0;
 
   // Notifies error. Unlike |NotifyResult|, it must report error
   // synchronously. The instance may be deleted just after calling
   // NotifyError.
   virtual void NotifyError(DriveApiErrorCode code) = 0;
 
   // Notifies progress.
   virtual void NotifyUploadProgress(const net::URLFetcher* source,
-                                    int64 current,
-                                    int64 total) = 0;
+                                    int64_t current,
+                                    int64_t total) = 0;
 };
 
 //============================ EntryActionRequest ============================
 
 // Callback type for requests that return only error status, like: Delete/Move.
 typedef base::Callback<void(DriveApiErrorCode error)> EntryActionCallback;
 
 // This class performs a simple action over a given entry (document/file).
 // It is meant to be used for requests that return no JSON blobs.
 class EntryActionRequest : public UrlFetchRequestBase {
@@ skipping 34 matching lines @@
 //
 class InitiateUploadRequestBase : public UrlFetchRequestBase {
  protected:
   // |callback| will be called with the upload URL, where upload data is
   // uploaded to with ResumeUploadRequestBase. It must not be null.
   // |content_type| and |content_length| should be the attributes of the
   // uploading file.
   InitiateUploadRequestBase(RequestSender* sender,
                             const InitiateUploadCallback& callback,
                             const std::string& content_type,
-                            int64 content_length);
+                            int64_t content_length);
   ~InitiateUploadRequestBase() override;
 
   // UrlFetchRequestBase overrides.
   void ProcessURLFetchResults(const net::URLFetcher* source) override;
   void RunCallbackOnPrematureFailure(DriveApiErrorCode code) override;
   std::vector<std::string> GetExtraRequestHeaders() const override;
 
  private:
   const InitiateUploadCallback callback_;
   const std::string content_type_;
-  const int64 content_length_;
+  const int64_t content_length_;
 
   DISALLOW_COPY_AND_ASSIGN(InitiateUploadRequestBase);
 };
 
 //========================== UploadRangeRequestBase ==========================
 
 // Struct for response to ResumeUpload and GetUploadStatus.
 struct UploadRangeResponse {
   UploadRangeResponse();
   UploadRangeResponse(DriveApiErrorCode code,
-                      int64 start_position_received,
-                      int64 end_position_received);
+                      int64_t start_position_received,
+                      int64_t end_position_received);
   ~UploadRangeResponse();
 
   DriveApiErrorCode code;
   // The values of "Range" header returned from the server. The values are
   // used to continue uploading more data. These are set to -1 if an upload
   // is complete.
   // |start_position_received| is inclusive and |end_position_received| is
   // exclusive to follow the common C++ manner, although the response from
   // the server has "Range" header in inclusive format at both sides.
-  int64 start_position_received;
-  int64 end_position_received;
+  int64_t start_position_received;
+  int64_t end_position_received;
 };
 
 // Base class for a URL fetch request expecting the response containing the
 // current uploading range. This class processes the response containing
 // "Range" header and invoke OnRangeRequestComplete.
 class UploadRangeRequestBase : public UrlFetchRequestBase {
  protected:
   // |upload_url| is the URL of where to upload the file to.
   UploadRangeRequestBase(RequestSender* sender, const GURL& upload_url);
   ~UploadRangeRequestBase() override;
@@ skipping 51 matching lines @@
   // |buf|. |end_position| is the end of range of contents currently stared in
   // |buf|. This is exclusive. For instance, if you are to upload the first
   // 500 bytes of data, |start_position| is 0 and |end_position| is 500.
   // |content_length| and |content_type| are the length and type of the
   // file content to be uploaded respectively.
   // |buf| holds current content to be uploaded.
   // See also UploadRangeRequestBase's comment for remaining parameters
   // meaning.
   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);
   ~ResumeUploadRequestBase() override;
 
   // UrlFetchRequestBase overrides.
   std::vector<std::string> GetExtraRequestHeaders() const override;
   bool 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) override;
 
  private:
   // The parameters for the request. See ResumeUploadParams for the details.
-  const int64 start_position_;
-  const int64 end_position_;
-  const int64 content_length_;
+  const int64_t start_position_;
+  const int64_t end_position_;
+  const int64_t content_length_;
   const std::string content_type_;
   const base::FilePath local_file_path_;
 
   DISALLOW_COPY_AND_ASSIGN(ResumeUploadRequestBase);
 };
 
 //======================== GetUploadStatusRequestBase ========================
 
 // This class performs the request for getting the current upload status
 // of a file.
 // This request calls OnRangeRequestComplete() with:
 // - HTTP_RESUME_INCOMPLETE and the range of previously uploaded data,
 //   if a file has been partially uploaded. |value| is not used.
 // - HTTP_SUCCESS or HTTP_CREATED (up to the upload mode) and |value|
 //   for the uploaded data, if a file has been completely uploaded.
 // See also UploadRangeRequestBase.
 class GetUploadStatusRequestBase : public UploadRangeRequestBase {
  public:
   // |content_length| is the whole data size to be uploaded.
   // See also UploadRangeRequestBase's constructor comment for other
   // parameters.
   GetUploadStatusRequestBase(RequestSender* sender,
                              const GURL& upload_url,
-                             int64 content_length);
+                             int64_t content_length);
   ~GetUploadStatusRequestBase() override;
 
  protected:
   // UrlFetchRequestBase overrides.
   std::vector<std::string> GetExtraRequestHeaders() const override;
 
  private:
-  const int64 content_length_;
+  const int64_t content_length_;
 
   DISALLOW_COPY_AND_ASSIGN(GetUploadStatusRequestBase);
 };
 
 //=========================== MultipartUploadRequestBase=======================
 
 // This class provides base implementation for performing the request for
 // uploading a file by multipart body.
 class MultipartUploadRequestBase : public BatchableDelegate {
  public:
   // Set boundary. Only tests can use this method.
   void SetBoundaryForTesting(const std::string& boundary);
 
  protected:
   // |callback| will be called with the file resource.upload URL.
   // |content_type| and |content_length| should be the attributes of the
   // uploading file. Other parameters are optional and can be empty or null
   // depending on Upload URL provided by the subclasses.
   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);
   ~MultipartUploadRequestBase() override;
 
   // BatchableDelegate.
   std::vector<std::string> GetExtraRequestHeaders() const override;
   void Prepare(const PrepareCallback& callback) override;
   bool GetContentData(std::string* upload_content_type,
                       std::string* upload_content) override;
   void NotifyResult(DriveApiErrorCode code,
                     const std::string& body,
                     const base::Closure& callback) override;
   void NotifyError(DriveApiErrorCode code) override;
   void NotifyUploadProgress(const net::URLFetcher* source,
-                            int64 current,
-                            int64 total) override;
+                            int64_t current,
+                            int64_t total) override;
   // Parses the response value and invokes |callback_| with |FileResource|.
   void OnDataParsed(DriveApiErrorCode code,
                     const base::Closure& callback,
                     scoped_ptr<base::Value> value);
 
  private:
   // Continues to rest part of |Start| method after determining boundary string
   // of multipart/related.
   void OnPrepareUploadContent(const PrepareCallback& callback,
                               std::string* upload_content_type,
@@ skipping 62 matching lines @@
  protected:
   // UrlFetchRequestBase overrides.
   GURL GetURL() const override;
   void GetOutputFilePath(base::FilePath* local_file_path,
                          GetContentCallback* get_content_callback) override;
   void ProcessURLFetchResults(const net::URLFetcher* source) override;
   void RunCallbackOnPrematureFailure(DriveApiErrorCode code) override;
 
   // net::URLFetcherDelegate overrides.
   void OnURLFetchDownloadProgress(const net::URLFetcher* source,
-                                  int64 current,
-                                  int64 total) override;
+                                  int64_t current,
+                                  int64_t total) override;
 
  private:
   const DownloadActionCallback download_action_callback_;
   const GetContentCallback get_content_callback_;
   const ProgressCallback progress_callback_;
   const GURL download_url_;
   const base::FilePath output_file_path_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadFileRequestBase);
 };
 
 }  // namespace google_apis
 
 #endif  // GOOGLE_APIS_DRIVE_BASE_REQUESTS_H_