| // 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; |
| } // namespace base |
| |
| namespace google_apis { |
| |
| class FileResource; |
| class RequestSender; |
| |
| // Content type for multipart body. |
| enum MultipartType { |
| MULTIPART_RELATED, |
| MULTIPART_MIXED |
| }; |
| |
| // Pair of content type and data. |
| struct ContentTypeAndData { |
| std::string type; |
| std::string data; |
| }; |
| |
| 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, |
| std::unique_ptr<FileResource> entry)> |
| FileResourceCallback; |
| |
| // Callback used for DownloadFileRequest and ResumeUploadRequestBase. |
| 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, |
| std::unique_ptr<std::string> content)> |
| GetContentCallback; |
| |
| // Parses JSON passed in |json|. Returns NULL on failure. |
| std::unique_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_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; |
| |
| virtual ~AuthenticatedRequestInterface() {} |
| |
| // Starts the request with |access_token|. User-Agent header will be set |
| // to |custom_user_agent| if the value is not empty. |
| // |
| // |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(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 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_. |
| ResponseWriter(base::SequencedTaskRunner* file_task_runner, |
| const base::FilePath& file_path, |
| const GetContentCallback& get_content_callback); |
| ~ResponseWriter() override; |
| |
| const std::string& data() const { return data_; } |
| |
| // Disowns the output file. |
| void DisownFile(); |
| |
| // URLFetcherResponseWriter overrides: |
| int Initialize(const net::CompletionCallback& callback) override; |
| int Write(net::IOBuffer* buffer, |
| int num_bytes, |
| const net::CompletionCallback& callback) override; |
| int Finish(int net_error, const net::CompletionCallback& callback) override; |
| |
| private: |
| void DidWrite(scoped_refptr<net::IOBuffer> buffer, |
| const net::CompletionCallback& callback, |
| int result); |
| |
| const GetContentCallback get_content_callback_; |
| std::string data_; |
| std::unique_ptr<net::URLFetcherFileWriter> file_writer_; |
| base::WeakPtrFactory<ResponseWriter> weak_ptr_factory_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ResponseWriter); |
| }; |
| |
| //============================ UrlFetchRequestBase =========================== |
| |
| // Base class for requests that are fetching URLs. |
| class UrlFetchRequestBase : public AuthenticatedRequestInterface, |
| public net::URLFetcherDelegate { |
| public: |
| // AuthenticatedRequestInterface overrides. |
| void Start(const std::string& access_token, |
| const std::string& custom_user_agent, |
| const ReAuthenticateCallback& callback) override; |
| base::WeakPtr<AuthenticatedRequestInterface> GetWeakPtr() override; |
| void Cancel() override; |
| |
| protected: |
| explicit UrlFetchRequestBase(RequestSender* sender); |
| ~UrlFetchRequestBase() override; |
| |
| // Does async initialization for the request. |Start| calls this method so you |
| // don't need to call this before |Start|. |
| virtual void Prepare(const PrepareCallback& callback); |
| |
| // Gets URL for the request. |
| virtual GURL GetURL() const = 0; |
| |
| // Returns the request type. A derived class should override this method |
| // for a request type other than HTTP GET. |
| virtual net::URLFetcher::RequestType GetRequestType() const; |
| |
| // Returns the extra HTTP headers for the request. A derived class should |
| // override this method to specify any extra headers needed for the request. |
| virtual std::vector<std::string> GetExtraRequestHeaders() const; |
| |
| // Used by a derived class to add any content data to the request. |
| // Returns true if |upload_content_type| and |upload_content| are updated |
| // with the content type and data for the request. |
| // 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_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 |
| // 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(DriveApiErrorCode code) = 0; |
| |
| // Invoked from derived classes when ProcessURLFetchResults() is completed. |
| void OnProcessURLFetchResultsComplete(); |
| |
| // 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: |
| // Continues |Start| function after |Prepare|. |
| void StartAfterPrepare(const std::string& access_token, |
| const std::string& custom_user_agent, |
| const ReAuthenticateCallback& callback, |
| DriveApiErrorCode code); |
| |
| // Invokes callback with |code| and request to delete the request to |
| // |sender_|. |
| void CompleteRequestWithError(DriveApiErrorCode code); |
| |
| // URLFetcherDelegate overrides. |
| void OnURLFetchComplete(const net::URLFetcher* source) override; |
| |
| // AuthenticatedRequestInterface overrides. |
| void OnAuthFailed(DriveApiErrorCode code) override; |
| |
| ReAuthenticateCallback re_authenticate_callback_; |
| int re_authenticate_count_; |
| std::unique_ptr<net::URLFetcher> url_fetcher_; |
| ResponseWriter* response_writer_; // Owned by |url_fetcher_|. |
| RequestSender* sender_; |
| 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); |
| }; |
| |
| //============================ BatchableDelegate ============================ |
| |
| // Delegate to be used by |SingleBatchableDelegateRequest| and |
| // |BatchUploadRequest|. |
| class BatchableDelegate { |
| public: |
| virtual ~BatchableDelegate() {} |
| |
| // See UrlFetchRequestBase. |
| virtual GURL GetURL() const = 0; |
| virtual net::URLFetcher::RequestType GetRequestType() const = 0; |
| virtual std::vector<std::string> GetExtraRequestHeaders() const = 0; |
| virtual void Prepare(const PrepareCallback& callback) = 0; |
| virtual bool GetContentData(std::string* upload_content_type, |
| std::string* upload_content) = 0; |
| |
| // Notifies result of the request. Usually, it parses the |code| and |
| // |response_body|, then notifies the parsed value to client code of the |
| // API. |callback| must be called on completion. The instance must not |
| // do anything after calling |callback| since the instance may be deleted in |
| // |callback|. |
| virtual void NotifyResult(DriveApiErrorCode code, |
| 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_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 { |
| 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(DriveApiErrorCode code) override; |
| |
| private: |
| const EntryActionCallback callback_; |
| |
| DISALLOW_COPY_AND_ASSIGN(EntryActionRequest); |
| }; |
| |
| //=========================== InitiateUploadRequestBase======================= |
| |
| // Callback type for DriveServiceInterface::InitiateUpload. |
| 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_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_t content_length_; |
| |
| DISALLOW_COPY_AND_ASSIGN(InitiateUploadRequestBase); |
| }; |
| |
| //========================== UploadRangeRequestBase ========================== |
| |
| // Struct for response to ResumeUpload and GetUploadStatus. |
| struct UploadRangeResponse { |
| UploadRangeResponse(); |
| UploadRangeResponse(DriveApiErrorCode code, |
| 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_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; |
| |
| // UrlFetchRequestBase overrides. |
| GURL GetURL() const override; |
| net::URLFetcher::RequestType GetRequestType() const override; |
| void ProcessURLFetchResults(const net::URLFetcher* source) 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, |
| std::unique_ptr<base::Value> value) = 0; |
| |
| private: |
| // Called when ParseJson() is completed. |
| void OnDataParsed(DriveApiErrorCode code, std::unique_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); |
| }; |
| |
| //========================== ResumeUploadRequestBase ========================= |
| |
| // This class performs the request for resuming the upload of a file. |
| // More specifically, this request uploads a chunk of data carried in |buf| |
| // of ResumeUploadResponseBase. This class is designed to share the |
| // implementation of upload resuming between GData WAPI and Drive API v2. |
| // The subclasses should implement OnRangeRequestComplete inherited by |
| // UploadRangeRequestBase, because the type of the response should be |
| // different (although the format in the server response is JSON). |
| class ResumeUploadRequestBase : public UploadRangeRequestBase { |
| protected: |
| // |start_position| is the start of range of contents currently stored in |
| // |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_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_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_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_t content_length); |
| ~GetUploadStatusRequestBase() override; |
| |
| protected: |
| // UrlFetchRequestBase overrides. |
| std::vector<std::string> GetExtraRequestHeaders() const override; |
| |
| private: |
| 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_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_t current, |
| int64_t total) override; |
| // Parses the response value and invokes |callback_| with |FileResource|. |
| void OnDataParsed(DriveApiErrorCode code, |
| const base::Closure& callback, |
| std::unique_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, |
| std::string* upload_content_data, |
| bool result); |
| |
| scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_; |
| const std::string metadata_json_; |
| const std::string content_type_; |
| const base::FilePath local_path_; |
| const FileResourceCallback callback_; |
| const ProgressCallback progress_callback_; |
| |
| // Boundary of multipart body. |
| std::string boundary_; |
| |
| // Upload content of multipart body. |
| std::string upload_content_type_; |
| std::string upload_content_data_; |
| |
| 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<MultipartUploadRequestBase> weak_ptr_factory_; |
| |
| DISALLOW_COPY_AND_ASSIGN(MultipartUploadRequestBase); |
| }; |
| |
| //============================ DownloadFileRequest =========================== |
| |
| // Callback type for receiving the completion of DownloadFileRequest. |
| 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: |
| // This callback is called when some part of the content is |
| // read. Used to read the download content progressively. May be null. |
| // |
| // progress_callback: |
| // This callback is called for periodically reporting the number of bytes |
| // downloaded so far. May be null. |
| // |
| // download_url: |
| // Specifies the target file to download. |
| // |
| // output_file_path: |
| // Specifies the file path to save the downloaded file. |
| // |
| DownloadFileRequestBase( |
| RequestSender* sender, |
| const DownloadActionCallback& download_action_callback, |
| const GetContentCallback& get_content_callback, |
| const ProgressCallback& progress_callback, |
| 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(DriveApiErrorCode code) override; |
| |
| // net::URLFetcherDelegate overrides. |
| void OnURLFetchDownloadProgress(const net::URLFetcher* source, |
| int64_t current, |
| int64_t total, |
| int64_t current_network_bytes) 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_ |