drive: Return cancel closure from FileSystem::GetFileContent

chrome/browser/chromeos/drive/file_system/download_operation.cc

 // Copyright 2013 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/chromeos/drive/file_system/download_operation.h"
 
 #include "base/callback_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 245 matching lines @@
 class DownloadOperation::DownloadParams {
  public:
   DownloadParams(
       const GetFileContentInitializedCallback initialized_callback,
       const google_apis::GetContentCallback get_content_callback,
       const GetFileCallback completion_callback,
       scoped_ptr<ResourceEntry> entry)
       : initialized_callback_(initialized_callback),
         get_content_callback_(get_content_callback),
         completion_callback_(completion_callback),
-        entry_(entry.Pass()) {
+        entry_(entry.Pass()),
+        weak_ptr_factory_(this) {
     DCHECK(!completion_callback_.is_null());
     DCHECK(entry_);
   }
 
+  base::Closure GetCancelClosure() {
+    return base::Bind(&DownloadParams::Cancel, weak_ptr_factory_.GetWeakPtr());
+  }
+
   void OnCacheFileFound(const base::FilePath& cache_file_path) const {
     if (initialized_callback_.is_null())
       return;
 
     DCHECK(entry_);
-    initialized_callback_.Run(
-        FILE_ERROR_OK, make_scoped_ptr(new ResourceEntry(*entry_)),
-        cache_file_path, base::Closure());
+    initialized_callback_.Run(FILE_ERROR_OK, cache_file_path,
+                              make_scoped_ptr(new ResourceEntry(*entry_)));
   }
 
-  void OnStartDownloading(const base::Closure& cancel_download_closure) const {
+  void OnStartDownloading(const base::Closure& cancel_download_closure) {
+    cancel_download_closure_ = cancel_download_closure;
     if (initialized_callback_.is_null()) {
       return;
     }
 
     DCHECK(entry_);
-    initialized_callback_.Run(
-        FILE_ERROR_OK, make_scoped_ptr(new ResourceEntry(*entry_)),
-        base::FilePath(), cancel_download_closure);
+    initialized_callback_.Run(FILE_ERROR_OK, base::FilePath(),
+                              make_scoped_ptr(new ResourceEntry(*entry_)));
   }
 
   void OnError(FileError error) const {
     completion_callback_.Run(
         error, base::FilePath(), scoped_ptr<ResourceEntry>());
   }
 
   void OnComplete(const base::FilePath& cache_file_path) {
     completion_callback_.Run(FILE_ERROR_OK, cache_file_path, entry_.Pass());
   }
 
   const google_apis::GetContentCallback& get_content_callback() const {
     return get_content_callback_;
   }
 
   const ResourceEntry& entry() const { return *entry_; }
 
  private:
+  void Cancel() {
+    if (!cancel_download_closure_.is_null())
+      cancel_download_closure_.Run();
+  }
+
   const GetFileContentInitializedCallback initialized_callback_;
   const google_apis::GetContentCallback get_content_callback_;
   const GetFileCallback completion_callback_;
 
   scoped_ptr<ResourceEntry> entry_;
+  base::Closure cancel_download_closure_;
 
+  base::WeakPtrFactory<DownloadParams> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(DownloadParams);
 };
 
 DownloadOperation::DownloadOperation(
     base::SequencedTaskRunner* blocking_task_runner,
     OperationObserver* observer,
     JobScheduler* scheduler,
     internal::ResourceMetadata* metadata,
     internal::FileCache* cache,
     const base::FilePath& temporary_file_directory)
     : blocking_task_runner_(blocking_task_runner),
       observer_(observer),
       scheduler_(scheduler),
       metadata_(metadata),
       cache_(cache),
       temporary_file_directory_(temporary_file_directory),
       weak_ptr_factory_(this) {
 }
 
 DownloadOperation::~DownloadOperation() {
 }
 
-void DownloadOperation::EnsureFileDownloadedByLocalId(
+base::Closure DownloadOperation::EnsureFileDownloadedByLocalId(
     const std::string& local_id,
     const ClientContext& context,
     const GetFileContentInitializedCallback& initialized_callback,
     const google_apis::GetContentCallback& get_content_callback,
     const GetFileCallback& completion_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!completion_callback.is_null());
 
   base::FilePath* drive_file_path = new base::FilePath;
   base::FilePath* cache_file_path = new base::FilePath;
   ResourceEntry* entry = new ResourceEntry;
   scoped_ptr<DownloadParams> params(new DownloadParams(
       initialized_callback, get_content_callback, completion_callback,
       make_scoped_ptr(entry)));
+  base::Closure cancel_closure = params->GetCancelClosure();
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CheckPreConditionForEnsureFileDownloadedByLocalId,
                  base::Unretained(metadata_),
                  base::Unretained(cache_),
                  local_id,
                  temporary_file_directory_,
                  drive_file_path,
                  cache_file_path,
                  entry),
       base::Bind(&DownloadOperation::EnsureFileDownloadedAfterCheckPreCondition,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&params),
                  context,
                  base::Owned(drive_file_path),
                  base::Owned(cache_file_path)));
+  return cancel_closure;
 }
 
-void DownloadOperation::EnsureFileDownloadedByPath(
+base::Closure DownloadOperation::EnsureFileDownloadedByPath(
     const base::FilePath& file_path,
     const ClientContext& context,
     const GetFileContentInitializedCallback& initialized_callback,
     const google_apis::GetContentCallback& get_content_callback,
     const GetFileCallback& completion_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!completion_callback.is_null());
 
   base::FilePath* drive_file_path = new base::FilePath(file_path);
   base::FilePath* cache_file_path = new base::FilePath;
   ResourceEntry* entry = new ResourceEntry;
   scoped_ptr<DownloadParams> params(new DownloadParams(
       initialized_callback, get_content_callback, completion_callback,
       make_scoped_ptr(entry)));
+  base::Closure cancel_closure = params->GetCancelClosure();
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CheckPreConditionForEnsureFileDownloadedByPath,
                  base::Unretained(metadata_),
                  base::Unretained(cache_),
                  file_path,
                  temporary_file_directory_,
                  cache_file_path,
                  entry),
       base::Bind(&DownloadOperation::EnsureFileDownloadedAfterCheckPreCondition,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&params),
                  context,
                  base::Owned(drive_file_path),
                  base::Owned(cache_file_path)));
+  return cancel_closure;
 }
 
 void DownloadOperation::EnsureFileDownloadedAfterCheckPreCondition(
     scoped_ptr<DownloadParams> params,
     const ClientContext& context,
     base::FilePath* drive_file_path,
     base::FilePath* cache_file_path,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(params);
@@ skipping 116 matching lines @@
   observer_->OnDirectoryChangedByOperation(file_path.DirName());
   params->OnComplete(*cache_file_path);
 }
 
 void DownloadOperation::CancelJob(JobID job_id) {
   scheduler_->CancelJob(job_id);
 }
 
 }  // namespace file_system
 }  // namespace drive