Rename gdata_errorcode.h to drive_api_error_codes.h

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 <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
-#include "google_apis/drive/gdata_errorcode.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;
 }  // namespace base
 
 namespace google_apis {
 
 class FileResource;
 class RequestSender;
 
 // Callback used for requests that the server returns FileResource data
 // formatted into JSON value.
-typedef base::Callback<void(GDataErrorCode error,
+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;
 
 // Callback used to get the content from DownloadFileRequest.
 typedef base::Callback<void(
-    GDataErrorCode error,
+    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);
 
 //======================= AuthenticatedRequestInterface ======================
 
 // An interface class for implementing a request which requires OAuth2
 // authentication.
 class AuthenticatedRequestInterface {
@@ skipping 10 matching lines @@
   // |callback| is called when re-authentication is needed for a certain
   // number of times (see kMaxReAuthenticateAttemptsPerRequest in .cc).
   // The callback should retry by calling Start() again with a new access
   // token, or just call OnAuthFailed() if a retry is not attempted.
   // |callback| must not be null.
   virtual void Start(const std::string& access_token,
                      const std::string& custom_user_agent,
                      const ReAuthenticateCallback& callback) = 0;
 
   // Invoked when the authentication failed with an error code |code|.
-  virtual void OnAuthFailed(GDataErrorCode code) = 0;
+  virtual void OnAuthFailed(DriveApiErrorCode code) = 0;
 
   // Gets a weak pointer to this request object. Since requests may be
   // deleted when it is canceled by user action, for posting asynchronous tasks
   // on the authentication request object, weak pointers have to be used.
   // TODO(kinaba): crbug.com/134814 use more clean life time management than
   // using weak pointers.
   virtual base::WeakPtr<AuthenticatedRequestInterface> GetWeakPtr() = 0;
 
   // Cancels the request. It will invoke the callback object passed in
-  // each request's constructor with error code GDATA_CANCELLED.
+  // each request's constructor with error code DRIVE_CANCELLED.
   virtual void Cancel() = 0;
 };
 
 //=========================== ResponseWriter ==================================
 
 // Saves the response for the request to a file or string.
 class ResponseWriter : public net::URLFetcherResponseWriter {
  public:
   // If file_path is not empty, the response will be saved with file_writer_,
   // otherwise it will be saved to data_.
@@ skipping 78 matching lines @@
   // is read.
   virtual void GetOutputFilePath(base::FilePath* local_file_path,
                                  GetContentCallback* get_content_callback);
 
   // Invoked by OnURLFetchComplete when the request completes without an
   // authentication error. Must be implemented by a derived class.
   virtual void ProcessURLFetchResults(const net::URLFetcher* source) = 0;
 
   // Invoked by this base class upon an authentication error or cancel by
   // a user request. Must be implemented by a derived class.
-  virtual void RunCallbackOnPrematureFailure(GDataErrorCode code) = 0;
+  virtual void RunCallbackOnPrematureFailure(DriveApiErrorCode code) = 0;
 
   // Invoked from derived classes when ProcessURLFetchResults() is completed.
   void OnProcessURLFetchResultsComplete();
 
-  // Returns an appropriate GDataErrorCode based on the HTTP response code and
-  // the status of the URLFetcher.
-  GDataErrorCode GetErrorCode();
+  // Returns an appropriate DriveApiErrorCode based on the HTTP response code
+  // and the status of the URLFetcher.
+  DriveApiErrorCode GetErrorCode();
 
   // Returns true if called on the thread where the constructor was called.
   bool CalledOnValidThread();
 
   // Returns the writer which is used to save the response for the request.
   ResponseWriter* response_writer() const { return response_writer_; }
 
   // Returns the task runner that should be used for blocking tasks.
   base::SequencedTaskRunner* blocking_task_runner() const;
 
  private:
   // URLFetcherDelegate overrides.
   void OnURLFetchComplete(const net::URLFetcher* source) override;
 
   // AuthenticatedRequestInterface overrides.
-  void OnAuthFailed(GDataErrorCode code) override;
+  void OnAuthFailed(DriveApiErrorCode code) override;
 
   ReAuthenticateCallback re_authenticate_callback_;
   int re_authenticate_count_;
   scoped_ptr<net::URLFetcher> url_fetcher_;
   ResponseWriter* response_writer_;  // Owned by |url_fetcher_|.
   RequestSender* sender_;
-  GDataErrorCode error_code_;
+  DriveApiErrorCode error_code_;
 
   base::ThreadChecker thread_checker_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<UrlFetchRequestBase> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(UrlFetchRequestBase);
 };
 
 //============================ EntryActionRequest ============================
 
 // Callback type for requests that return only error status, like: Delete/Move.
-typedef base::Callback<void(GDataErrorCode error)> EntryActionCallback;
+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 {
  public:
   // |callback| is called when the request is finished either by success or by
   // failure. It must not be null.
   EntryActionRequest(RequestSender* sender,
                      const EntryActionCallback& callback);
   ~EntryActionRequest() override;
 
  protected:
   // Overridden from UrlFetchRequestBase.
   void ProcessURLFetchResults(const net::URLFetcher* source) override;
-  void RunCallbackOnPrematureFailure(GDataErrorCode code) override;
+  void RunCallbackOnPrematureFailure(DriveApiErrorCode code) override;
 
  private:
   const EntryActionCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(EntryActionRequest);
 };
 
 //=========================== InitiateUploadRequestBase=======================
 
 // Callback type for DriveServiceInterface::InitiateUpload.
-typedef base::Callback<void(GDataErrorCode error,
+typedef base::Callback<void(DriveApiErrorCode error,
                             const GURL& upload_url)> InitiateUploadCallback;
 
 // This class provides base implementation for performing the request for
 // initiating the upload of a file.
 // |callback| will be called with the obtained upload URL. The URL will be
 // used with requests for resuming the file uploading.
 //
 // Here's the flow of uploading:
 // 1) Get the upload URL with a class inheriting InitiateUploadRequestBase.
 // 2) Upload the first 1GB (see kUploadChunkSize in drive_uploader.cc)
 //    of the target file to the upload URL
 // 3) If there is more data to upload, go to 2).
 //
 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);
   ~InitiateUploadRequestBase() override;
 
   // UrlFetchRequestBase overrides.
   void ProcessURLFetchResults(const net::URLFetcher* source) override;
-  void RunCallbackOnPrematureFailure(GDataErrorCode code) 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_;
 
   DISALLOW_COPY_AND_ASSIGN(InitiateUploadRequestBase);
 };
 
 //========================== UploadRangeRequestBase ==========================
 
 // Struct for response to ResumeUpload and GetUploadStatus.
 struct UploadRangeResponse {
   UploadRangeResponse();
-  UploadRangeResponse(GDataErrorCode code,
+  UploadRangeResponse(DriveApiErrorCode code,
                       int64 start_position_received,
                       int64 end_position_received);
   ~UploadRangeResponse();
 
-  GDataErrorCode code;
+  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;
 };
 
 // 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;
 
   // UrlFetchRequestBase overrides.
   GURL GetURL() const override;
   net::URLFetcher::RequestType GetRequestType() const override;
   void ProcessURLFetchResults(const net::URLFetcher* source) override;
-  void RunCallbackOnPrematureFailure(GDataErrorCode code) override;
+  void RunCallbackOnPrematureFailure(DriveApiErrorCode code) override;
 
   // This method will be called when the request is done, regardless of
   // whether it is succeeded or failed.
   //
   // 1) If there is more data to upload, |code| of |response| is set to
   // HTTP_RESUME_INCOMPLETE, and positions are set appropriately. Also, |value|
   // will be set to NULL.
   // 2) If the upload is complete, |code| is set to HTTP_CREATED for a new file
   // or HTTP_SUCCESS for an existing file. Positions are set to -1, and |value|
   // is set to a parsed JSON value representing the uploaded file.
   // 3) If a premature failure is found, |code| is set to a value representing
   // the situation. Positions are set to 0, and |value| is set to NULL.
   //
   // See also the comments for UploadRangeResponse.
   // Note: Subclasses should have responsibility to run some callback
   // in this method to notify the finish status to its clients (or ignore it
   // under its responsibility).
   virtual void OnRangeRequestComplete(
       const UploadRangeResponse& response, scoped_ptr<base::Value> value) = 0;
 
  private:
   // Called when ParseJson() is completed.
-  void OnDataParsed(GDataErrorCode code, scoped_ptr<base::Value> value);
+  void OnDataParsed(DriveApiErrorCode code, scoped_ptr<base::Value> value);
 
   const GURL upload_url_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<UploadRangeRequestBase> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(UploadRangeRequestBase);
 };
 
@@ skipping 103 matching lines @@
 
   // Overridden from AuthenticatedRequestInterface.
   void Start(const std::string& access_token,
              const std::string& custom_user_agent,
              const ReAuthenticateCallback& callback) override;
 
   // Overridden from UrlFetchRequestBase.
   bool GetContentData(std::string* upload_content_type,
                       std::string* upload_content) override;
   void ProcessURLFetchResults(const net::URLFetcher* source) override;
-  void RunCallbackOnPrematureFailure(GDataErrorCode code) override;
+  void RunCallbackOnPrematureFailure(DriveApiErrorCode code) override;
 
   // content::UrlFetcherDelegate overrides.
   void OnURLFetchUploadProgress(const net::URLFetcher* source,
                                 int64 current,
                                 int64 total) override;
 
   // Parses the response value and invokes |callback_| with |FileResource|.
-  void OnDataParsed(GDataErrorCode code, scoped_ptr<base::Value> value);
+  void OnDataParsed(DriveApiErrorCode code, scoped_ptr<base::Value> value);
 
   // Whether to the request has modified date information or not.
   bool has_modified_date() const { return has_modified_date_; }
 
  private:
   // Continues to rest part of |Start| method after determining boundary string
   // of multipart/related.
   void OnPrepareUploadContent(const std::string& access_token,
                               const std::string& custom_user_agent,
                               const ReAuthenticateCallback& callback,
@@ skipping 18 matching lines @@
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<MultipartUploadRequestBase> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MultipartUploadRequestBase);
 };
 
 //============================ DownloadFileRequest ===========================
 
 // Callback type for receiving the completion of DownloadFileRequest.
-typedef base::Callback<void(GDataErrorCode error,
+typedef base::Callback<void(DriveApiErrorCode error,
                             const base::FilePath& temp_file)>
     DownloadActionCallback;
 
 // This is a base class for performing the request for downloading a file.
 class DownloadFileRequestBase : public UrlFetchRequestBase {
  public:
   // download_action_callback:
   //   This callback is called when the download is complete. Must not be null.
   //
   // get_content_callback:
@@ skipping 18 matching lines @@
       const GURL& download_url,
       const base::FilePath& output_file_path);
   ~DownloadFileRequestBase() override;
 
  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(GDataErrorCode code) override;
+  void RunCallbackOnPrematureFailure(DriveApiErrorCode code) override;
 
   // net::URLFetcherDelegate overrides.
   void OnURLFetchDownloadProgress(const net::URLFetcher* source,
                                   int64 current,
                                   int64 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_