google_apis: Implement google_apis::ResponseWriter

chrome/browser/google_apis/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 CHROME_BROWSER_GOOGLE_APIS_BASE_REQUESTS_H_
 #define CHROME_BROWSER_GOOGLE_APIS_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 "chrome/browser/google_apis/gdata_errorcode.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 RequestSender;
 
 // Callback used to pass parsed JSON from ParseJson(). If parsing error occurs,
 // then the passed argument is null.
 typedef base::Callback<void(scoped_ptr<base::Value> value)> ParseJsonCallback;
 
 // 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,
+    scoped_ptr<std::string> content)> GetContentCallback;
+
 // Parses JSON passed in |json| on |blocking_task_runner|. Runs |callback| on
 // the calling thread when finished with either success or failure.
 // The callback must not be null.
 void ParseJson(base::TaskRunner* blocking_task_runner,
                const std::string& json,
                const ParseJsonCallback& callback);
 
 //======================= AuthenticatedRequestInterface ======================
 
 // An interface class for implementing a request which requires OAuth2
@@ skipping 26 matching lines @@
   // 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.
   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::TaskRunner* file_task_runner,
+                 const base::FilePath& file_path,
+                 const GetContentCallback& get_content_callback);
+  virtual ~ResponseWriter();
+
+  const std::string& data() const { return data_; }
+
+  // Disowns the output file.
+  void DisownFile();
+
+  // URLFetcherResponseWriter overrides:
+  virtual int Initialize(const net::CompletionCallback& callback) OVERRIDE;
+  virtual int Write(net::IOBuffer* buffer,
+                    int num_bytes,
+                    const net::CompletionCallback& callback) OVERRIDE;
+  virtual int Finish(const net::CompletionCallback& callback) OVERRIDE;
+
+ private:
+  const GetContentCallback get_content_callback_;
+  std::string data_;
+  scoped_ptr<net::URLFetcherFileWriter> file_writer_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResponseWriter);
+};
+
 //============================ UrlFetchRequestBase ===========================
 
 // Base class for requests that are fetching URLs.
 class UrlFetchRequestBase : public AuthenticatedRequestInterface,
                             public net::URLFetcherDelegate {
  public:
   // AuthenticatedRequestInterface overrides.
   virtual void Start(const std::string& access_token,
                      const std::string& custom_user_agent,
                      const ReAuthenticateCallback& callback) OVERRIDE;
@@ skipping 27 matching lines @@
   // 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,
                               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.
-  virtual bool GetOutputFilePath(base::FilePath* local_file_path);
+  // get_content_callback is called when some part of the response is read.

[wtc, 2013/10/24 18:36:39]

Nit: Please stress the fact that get_content_callback is an output argument.
Maybe somethign like:
  Sets |get_content_callback|, which is called when some part of the response is
read.

[hashimoto, 2013/10/25 05:29:14]

Done.

+  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;
 
   // 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.
   static GDataErrorCode GetErrorCode(const net::URLFetcher* source);
 
   // 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::TaskRunner* blocking_task_runner() const;
 
  private:
   // URLFetcherDelegate overrides.
   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 
   // AuthenticatedRequestInterface overrides.
   virtual void OnAuthFailed(GDataErrorCode 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_;
 
   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);
 };
@@ skipping 245 matching lines @@
   virtual std::vector<std::string> GetExtraRequestHeaders() const OVERRIDE;
 
  private:
   const int64 content_length_;
 
   DISALLOW_COPY_AND_ASSIGN(GetUploadStatusRequestBase);
 };
 
 //============================ DownloadFileRequest ===========================
 
-// Callback type for getting the content from DownloadFileRequest.
-typedef base::Callback<void(
-    GDataErrorCode error,
-    scoped_ptr<std::string> content)> GetContentCallback;
-
 // Callback type for receiving the completion of DownloadFileRequest.
 typedef base::Callback<void(GDataErrorCode 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.
@@ skipping 17 matching lines @@
       const DownloadActionCallback& download_action_callback,
       const GetContentCallback& get_content_callback,
       const ProgressCallback& progress_callback,
       const GURL& download_url,
       const base::FilePath& output_file_path);
   virtual ~DownloadFileRequestBase();
 
  protected:
   // UrlFetchRequestBase overrides.
   virtual GURL GetURL() const OVERRIDE;
-  virtual bool GetOutputFilePath(base::FilePath* local_file_path) OVERRIDE;
+  virtual void GetOutputFilePath(
+      base::FilePath* local_file_path,
+      GetContentCallback* get_content_callback) OVERRIDE;
   virtual void ProcessURLFetchResults(const net::URLFetcher* source) OVERRIDE;
   virtual void RunCallbackOnPrematureFailure(GDataErrorCode code) OVERRIDE;
 
   // net::URLFetcherDelegate overrides.
   virtual void OnURLFetchDownloadProgress(const net::URLFetcher* source,
                                           int64 current, int64 total) OVERRIDE;
-  virtual bool ShouldSendDownloadData() OVERRIDE;
-  virtual void OnURLFetchDownloadData(
-      const net::URLFetcher* source,
-      scoped_ptr<std::string> download_data) 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  // CHROME_BROWSER_GOOGLE_APIS_BASE_REQUESTS_H_