google_apis: Stop accessing URLFetcher from ResponseWriter

google_apis/drive/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 "google_apis/drive/base_requests.h"
 
 #include "base/json/json_reader.h"
 #include "base/location.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 89 matching lines @@
                const std::string& json,
                const ParseJsonCallback& callback) {
   base::PostTaskAndReplyWithResult(
       blocking_task_runner,
       FROM_HERE,
       base::Bind(&ParseJsonInternal, json),
       callback);
 }
 
 //=========================== ResponseWriter ==================================
-ResponseWriter::ResponseWriter(net::URLFetcher* url_fetcher,
-                               base::SequencedTaskRunner* file_task_runner,
+ResponseWriter::ResponseWriter(base::SequencedTaskRunner* file_task_runner,
                                const base::FilePath& file_path,
                                const GetContentCallback& get_content_callback)
-    : url_fetcher_(url_fetcher),
-      get_content_callback_(get_content_callback) {
+    : get_content_callback_(get_content_callback),
+      weak_ptr_factory_(this) {
   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) {
-  // |get_content_callback_| and |file_writer_| are used only when the response
-  // code is successful one.
-  if (IsSuccessfulResponseCode(url_fetcher_->GetResponseCode())) {
-    if (!get_content_callback_.is_null()) {
-      get_content_callback_.Run(
-          HTTP_SUCCESS,
-          make_scoped_ptr(new std::string(buffer->data(), num_bytes)));
-    }
+  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);
+  if (file_writer_) {
+    const int result = file_writer_->Write(
+        buffer, num_bytes,
+        base::Bind(&ResponseWriter::DidWrite,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   make_scoped_refptr(buffer), callback));
+    if (result != net::ERR_IO_PENDING)
+      DidWrite(buffer, net::CompletionCallback(), result);
+    return result;
   }
 
   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;
 }
 
+void ResponseWriter::DidWrite(scoped_refptr<net::IOBuffer> buffer,
+                              const net::CompletionCallback& callback,
+                              int result) {
+  if (result > 0) {
+    // Even if file_writer_ is used, append the data to |data_|, so that it can
+    // be used to get error information in case of server side errors.
+    // The size limit is to avoid consuming too much redundant memory.
+    const size_t kMaxStringSize = 1024*1024;
+    if (data_.size() < kMaxStringSize) {
+      data_.append(buffer->data(), std::min(static_cast<size_t>(result),
+                                            kMaxStringSize - data_.size()));
+    }
+  }
+
+  if (!callback.is_null())
+    callback.Run(result);
+}
+
 //============================ UrlFetchRequestBase ===========================
 
 UrlFetchRequestBase::UrlFetchRequestBase(RequestSender* sender)
     : re_authenticate_count_(0),
       sender_(sender),
       error_code_(GDATA_OTHER_ERROR),
       weak_ptr_factory_(this) {
 }
 
 UrlFetchRequestBase::~UrlFetchRequestBase() {}
@@ skipping 25 matching lines @@
   // 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;
   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(url_fetcher_.get(),
-                                        blocking_task_runner(),
+  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())
@@ skipping 548 matching lines @@
   download_action_callback_.Run(code, temp_file);
   OnProcessURLFetchResultsComplete();
 }
 
 void DownloadFileRequestBase::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
   download_action_callback_.Run(code, base::FilePath());
 }
 
 }  // namespace google_apis