Drive API: Simplify lifetime management of child requests in BatchUploadRequest.

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/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
@@ skipping 543 matching lines @@
 
 void UrlFetchRequestBase::OnAuthFailed(DriveApiErrorCode code) {
   CompleteRequestWithError(code);
 }
 
 base::WeakPtr<AuthenticatedRequestInterface>
 UrlFetchRequestBase::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
-//============================ BatchableRequestBase ============================
-
-net::URLFetcher::RequestType BatchableRequestBase::GetRequestType() const {
-  return UrlFetchRequestBase::GetRequestType();
-}
-
-std::vector<std::string> BatchableRequestBase::GetExtraRequestHeaders() const {
-  return UrlFetchRequestBase::GetExtraRequestHeaders();
-}
-
-void BatchableRequestBase::Prepare(const PrepareCallback& callback) {
-  return UrlFetchRequestBase::Prepare(callback);
-}
-
-bool BatchableRequestBase::GetContentData(
-    std::string* upload_content_type, std::string* upload_content) {
-  return UrlFetchRequestBase::GetContentData(
-      upload_content_type, upload_content);
-}
-
-void BatchableRequestBase::ProcessURLFetchResults(
-    const net::URLFetcher* source) {
-  ProcessURLFetchResults(GetErrorCode(), response_writer()->data());
-}
-
 //============================ EntryActionRequest ============================
 
 EntryActionRequest::EntryActionRequest(RequestSender* sender,
                                        const EntryActionCallback& callback)
     : UrlFetchRequestBase(sender),
       callback_(callback) {
   DCHECK(!callback_.is_null());
 }
 
 EntryActionRequest::~EntryActionRequest() {}
@@ skipping 249 matching lines @@
   std::vector<std::string> headers;
   headers.push_back(
       std::string(kUploadContentRange) + "*/" +
       base::Int64ToString(content_length_));
   return headers;
 }
 
 //========================= MultipartUploadRequestBase ========================
 
 MultipartUploadRequestBase::MultipartUploadRequestBase(
-    RequestSender* sender,
+    base::SequencedTaskRunner* blocking_task_runner,
     const std::string& metadata_json,
     const std::string& content_type,
     int64 content_length,
     const base::FilePath& local_file_path,
     const FileResourceCallback& callback,
     const ProgressCallback& progress_callback)
-    : BatchableRequestBase(sender),
+    : blocking_task_runner_(blocking_task_runner),
       metadata_json_(metadata_json),
       content_type_(content_type),
       local_path_(local_file_path),
       callback_(callback),
       progress_callback_(progress_callback),
       weak_ptr_factory_(this) {
   DCHECK(!content_type.empty());
   DCHECK_GE(content_length, 0);
   DCHECK(!local_file_path.empty());
   DCHECK(!callback.is_null());
 }
 
 MultipartUploadRequestBase::~MultipartUploadRequestBase() {
 }
 
+std::vector<std::string> MultipartUploadRequestBase::GetExtraRequestHeaders()
+    const {
+  return std::vector<std::string>();
+}
+
 void MultipartUploadRequestBase::Prepare(const PrepareCallback& callback) {
   // If the request is cancelled, the request instance will be deleted in
   // |UrlFetchRequestBase::Cancel| and OnPrepareUploadContent won't be called.
   std::string* const upload_content_type = new std::string();
   std::string* const upload_content_data = new std::string();
   PostTaskAndReplyWithResult(
-      blocking_task_runner(), FROM_HERE,
+      blocking_task_runner_.get(), FROM_HERE,
       base::Bind(&GetMultipartContent, boundary_, metadata_json_, content_type_,
                  local_path_, base::Unretained(upload_content_type),
                  base::Unretained(upload_content_data)),
       base::Bind(&MultipartUploadRequestBase::OnPrepareUploadContent,
                  weak_ptr_factory_.GetWeakPtr(), callback,
                  base::Owned(upload_content_type),
                  base::Owned(upload_content_data)));
 }
 
 void MultipartUploadRequestBase::OnPrepareUploadContent(
@@ skipping 17 matching lines @@
 
 bool MultipartUploadRequestBase::GetContentData(
     std::string* upload_content_type,
     std::string* upload_content_data) {
   // TODO(hirono): Pass stream instead of actual data to reduce memory usage.
   upload_content_type->swap(upload_content_type_);
   upload_content_data->swap(upload_content_data_);
   return true;
 }
 
-void MultipartUploadRequestBase::ProcessURLFetchResults(
-    DriveApiErrorCode code, const std::string& body) {
+void MultipartUploadRequestBase::NotifyResult(
+    DriveApiErrorCode code,
+    const std::string& body,
+    const base::Closure& notify_complete_callback) {
   // The upload is successfully done. Parse the response which should be
   // the entry's metadata.
   if (code == HTTP_CREATED || code == HTTP_SUCCESS) {
     ParseJsonOnBlockingPool(
-        blocking_task_runner(), body,
+        blocking_task_runner_.get(), body,
         base::Bind(&MultipartUploadRequestBase::OnDataParsed,
-                   weak_ptr_factory_.GetWeakPtr(), code));
+                   weak_ptr_factory_.GetWeakPtr(), code,
+                   notify_complete_callback));
   } else {
-    OnDataParsed(code, scoped_ptr<base::Value>());
+    NotifyError(code);
+    notify_complete_callback.Run();
   }
 }
 
-void MultipartUploadRequestBase::RunCallbackOnPrematureFailure(
-    DriveApiErrorCode code) {
+void MultipartUploadRequestBase::NotifyError(DriveApiErrorCode code) {
   callback_.Run(code, scoped_ptr<FileResource>());
 }
 
-void MultipartUploadRequestBase::OnURLFetchUploadProgress(
+void MultipartUploadRequestBase::NotifyUploadProgress(
     const net::URLFetcher* source,
     int64 current,
     int64 total) {
   if (!progress_callback_.is_null())
     progress_callback_.Run(current, total);
 }
 
-void MultipartUploadRequestBase::OnDataParsed(DriveApiErrorCode code,
-                                              scoped_ptr<base::Value> value) {
-  DCHECK(CalledOnValidThread());
+void MultipartUploadRequestBase::OnDataParsed(
+    DriveApiErrorCode code,
+    const base::Closure& notify_complete_callback,
+    scoped_ptr<base::Value> value) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (value)
     callback_.Run(code, google_apis::FileResource::CreateFrom(*value));
   else
-    callback_.Run(DRIVE_PARSE_ERROR, scoped_ptr<FileResource>());
-  OnProcessURLFetchResultsComplete();
+    NotifyError(DRIVE_PARSE_ERROR);
+  notify_complete_callback.Run();
 }
 
 //============================ DownloadFileRequestBase =========================
 
 DownloadFileRequestBase::DownloadFileRequestBase(
     RequestSender* sender,
     const DownloadActionCallback& download_action_callback,
     const GetContentCallback& get_content_callback,
     const ProgressCallback& progress_callback,
     const GURL& download_url,
@@ skipping 45 matching lines @@
   download_action_callback_.Run(code, temp_file);
   OnProcessURLFetchResultsComplete();
 }
 
 void DownloadFileRequestBase::RunCallbackOnPrematureFailure(
     DriveApiErrorCode code) {
   download_action_callback_.Run(code, base::FilePath());
 }
 
 }  // namespace google_apis