google_apis: Implement google_apis::ResponseWriter

chrome/browser/google_apis/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 "chrome/browser/google_apis/base_requests.h"
 
 #include "base/json/json_reader.h"
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/values.h"
 #include "chrome/browser/google_apis/request_sender.h"
+#include "chrome/browser/google_apis/task_util.h"
+#include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
 
 using net::URLFetcher;
 
@@ skipping 68 matching lines @@
 void ParseJson(base::TaskRunner* blocking_task_runner,
                const std::string& json,
                const ParseJsonCallback& callback) {
   base::PostTaskAndReplyWithResult(
       blocking_task_runner,
       FROM_HERE,
       base::Bind(&ParseJsonOnBlockingPool, json),
       callback);
 }
 
+//=========================== ResponseWriter ==================================
+ResponseWriter::ResponseWriter(base::TaskRunner* file_task_runner,
+                               const base::FilePath& file_path,
+                               const GetContentCallback& get_content_callback)
+    : get_content_callback_(get_content_callback) {
+  if (!file_path.empty()) {
+    file_writer_.reset(
+        new net::URLFetcherFileWriter(file_task_runner, file_path));
+  }
+}
+
+ResponseWriter::~ResponseWriter() {
+}
+
+void ResponseWriter::DisownFile() {
+  DCHECK(file_writer_);
+  file_writer_->DisownFile();
+}
+
+int ResponseWriter::Initialize(const net::CompletionCallback& callback) {
+  if (file_writer_)
+    return file_writer_->Initialize(callback);
+
+  data_.clear();
+  return net::OK;
+}
+
+int ResponseWriter::Write(net::IOBuffer* buffer,
+                          int num_bytes,
+                          const net::CompletionCallback& callback) {
+  if (!get_content_callback_.is_null()) {
+    get_content_callback_.Run(
+        HTTP_SUCCESS,
+        make_scoped_ptr(new std::string(buffer->data(), num_bytes)));
+  }
+
+  if (file_writer_)
+    return file_writer_->Write(buffer, num_bytes, callback);
+
+  data_.append(buffer->data(), num_bytes);
+  return num_bytes;
+}
+
+int ResponseWriter::Finish(const net::CompletionCallback& callback) {
+  if (file_writer_)
+    return file_writer_->Finish(callback);
+
+  return net::OK;
+}
+
 //============================ UrlFetchRequestBase ===========================
 
 UrlFetchRequestBase::UrlFetchRequestBase(RequestSender* sender)
     : re_authenticate_count_(0),
       sender_(sender),
       weak_ptr_factory_(this) {
 }
 
 UrlFetchRequestBase::~UrlFetchRequestBase() {}
 
@@ skipping 20 matching lines @@
   URLFetcher::RequestType request_type = GetRequestType();
   url_fetcher_.reset(
       URLFetcher::Create(url, request_type, this));
   url_fetcher_->SetRequestContext(sender_->url_request_context_getter());
   // Always set flags to neither send nor save cookies.
   url_fetcher_->SetLoadFlags(
       net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES |
       net::LOAD_DISABLE_CACHE);
 
   base::FilePath output_file_path;
-  if (GetOutputFilePath(&output_file_path)) {
-    url_fetcher_->SaveResponseToFileAtPath(
-        output_file_path,
-        blocking_task_runner());
-  }
+  GetContentCallback get_content_callback;
+  GetOutputFilePath(&output_file_path, &get_content_callback);
+  if (!get_content_callback.is_null())
+    get_content_callback = CreateRelayCallback(get_content_callback);
+  response_writer_ = new ResponseWriter(blocking_task_runner(),
+                                        output_file_path,
+                                        get_content_callback);
+  url_fetcher_->SaveResponseWithWriter(
+      scoped_ptr<net::URLFetcherResponseWriter>(response_writer_));
 
   // Add request headers.
   // Note that SetExtraRequestHeaders clears the current headers and sets it
   // to the passed-in headers, so calling it for each header will result in
   // only the last header being set in request headers.
   if (!custom_user_agent.empty())
     url_fetcher_->AddExtraRequestHeader("User-Agent: " + custom_user_agent);
   url_fetcher_->AddExtraRequestHeader(kGDataVersionHeader);
   url_fetcher_->AddExtraRequestHeader(
       base::StringPrintf(kAuthorizationHeaderFormat, access_token.data()));
@@ skipping 51 matching lines @@
   return false;
 }
 
 bool UrlFetchRequestBase::GetContentFile(base::FilePath* local_file_path,
                                          int64* range_offset,
                                          int64* range_length,
                                          std::string* upload_content_type) {
   return false;
 }
 
-bool UrlFetchRequestBase::GetOutputFilePath(base::FilePath* local_file_path) {
-  return false;
+void UrlFetchRequestBase::GetOutputFilePath(
+    base::FilePath* local_file_path,
+    GetContentCallback* get_content_callback) {
 }
 
 void UrlFetchRequestBase::Cancel() {
+  response_writer_ = NULL;
   url_fetcher_.reset(NULL);
   RunCallbackOnPrematureFailure(GDATA_CANCELLED);
   sender_->RequestFinished(this);
 }
 
 // static
 GDataErrorCode UrlFetchRequestBase::GetErrorCode(const URLFetcher* source) {
   GDataErrorCode code = static_cast<GDataErrorCode>(source->GetResponseCode());
   if (!source->GetStatus().is_success()) {
     switch (source->GetStatus().error()) {
@@ skipping 89 matching lines @@
   VLOG(1) << "JSON received from " << GetURL().spec() << ": "
           << data.size() << " bytes";
   ParseJson(blocking_task_runner(),
             data,
             base::Bind(&GetDataRequest::OnDataParsed,
                        weak_ptr_factory_.GetWeakPtr(),
                        fetch_error_code));
 }
 
 void GetDataRequest::ProcessURLFetchResults(const URLFetcher* source) {
-  std::string data;
-  source->GetResponseAsString(&data);
-  scoped_ptr<base::Value> root_value;
   GDataErrorCode fetch_error_code = GetErrorCode(source);
 
   switch (fetch_error_code) {
     case HTTP_SUCCESS:
     case HTTP_CREATED:
-      ParseResponse(fetch_error_code, data);
+      ParseResponse(fetch_error_code, response_writer()->data());
       break;
     default:
       RunCallbackOnPrematureFailure(fetch_error_code);
       OnProcessURLFetchResultsComplete();
       break;
   }
 }
 
 void GetDataRequest::RunCallbackOnPrematureFailure(
     GDataErrorCode fetch_error_code) {
@@ skipping 132 matching lines @@
 
     OnRangeRequestComplete(UploadRangeResponse(code,
                                                start_position_received,
                                                end_position_received),
                            scoped_ptr<base::Value>());
 
     OnProcessURLFetchResultsComplete();
   } else if (code == HTTP_CREATED || code == HTTP_SUCCESS) {
     // The upload is successfully done. Parse the response which should be
     // the entry's metadata.
-    std::string response_content;
-    source->GetResponseAsString(&response_content);
-
     ParseJson(blocking_task_runner(),
-              response_content,
+              response_writer()->data(),
               base::Bind(&UploadRangeRequestBase::OnDataParsed,
                          weak_ptr_factory_.GetWeakPtr(),
                          code));
   } else {
     // Failed to upload. Run callbacks to notify the error.
     OnRangeRequestComplete(
         UploadRangeResponse(code, -1, -1), scoped_ptr<base::Value>());
     OnProcessURLFetchResultsComplete();
   }
 }
@@ skipping 123 matching lines @@
   // get_content_callback may be null.
 }
 
 DownloadFileRequestBase::~DownloadFileRequestBase() {}
 
 // Overridden from UrlFetchRequestBase.
 GURL DownloadFileRequestBase::GetURL() const {
   return download_url_;
 }
 
-bool DownloadFileRequestBase::GetOutputFilePath(
-    base::FilePath* local_file_path) {
+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_;
-  return true;
+  *get_content_callback = get_content_callback_;
 }
 
 void DownloadFileRequestBase::OnURLFetchDownloadProgress(
     const URLFetcher* source,
     int64 current,
     int64 total) {
   if (!progress_callback_.is_null())
     progress_callback_.Run(current, total);
 }
 
-bool DownloadFileRequestBase::ShouldSendDownloadData() {
-  return !get_content_callback_.is_null();
-}
-
-void DownloadFileRequestBase::OnURLFetchDownloadData(
-    const URLFetcher* source,
-    scoped_ptr<std::string> download_data) {
-  if (!get_content_callback_.is_null())
-    get_content_callback_.Run(HTTP_SUCCESS, download_data.Pass());
-}
-
 void DownloadFileRequestBase::ProcessURLFetchResults(const URLFetcher* source) {
   GDataErrorCode code = GetErrorCode(source);
 
   // Take over the ownership of the the downloaded temp file.
   base::FilePath temp_file;
-  if (code == HTTP_SUCCESS &&
-      !source->GetResponseAsFilePath(true,  // take_ownership
-                                     &temp_file)) {
-    code = GDATA_FILE_ERROR;
+  if (code == HTTP_SUCCESS) {
+    response_writer()->DisownFile();
+    temp_file = output_file_path_;
   }
 
   download_action_callback_.Run(code, temp_file);
   OnProcessURLFetchResultsComplete();
 }
 
 void DownloadFileRequestBase::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
   download_action_callback_.Run(code, base::FilePath());
 }
 
 }  // namespace google_apis