drive: Return cancel closure from FileSystem::GetFileContent

chrome/browser/chromeos/drive/drive_file_stream_reader.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/drive_file_stream_reader.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/callback_helpers.h"
@@ skipping 11 matching lines @@
 using content::BrowserThread;
 
 namespace drive {
 namespace {
 
 // Converts FileError code to net::Error code.
 int FileErrorToNetError(FileError error) {
   return net::FileErrorToNetError(FileErrorToBaseFileError(error));
 }
 
-// Runs task on UI thread.
-void RunTaskOnUIThread(const base::Closure& task) {
-  google_apis::RunTaskOnThread(
-      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI), task);
-}
-
 // Computes the concrete |start| offset and the |length| of |range| in a file
 // of |total| size.
 //
 // This is a thin wrapper of HttpByteRange::ComputeBounds, extended to allow
 // an empty range at the end of the file, like "Range: bytes 0-" on a zero byte
 // file. This is for convenience in unifying implementation with the seek
 // operation of stream reader. HTTP doesn't allow such ranges but we want to
 // treat such seeking as valid.
 bool ComputeConcretePosition(net::HttpByteRange range, int64 total,
                              int64* start, int64* length) {
@@ skipping 218 matching lines @@
   base::ResetAndReturn(&callback_).Run(error_code_);
 }
 
 }  // namespace internal
 
 namespace {
 
 // Calls FileSystemInterface::GetFileContent if the file system
 // is available. If not, the |completion_callback| is invoked with
 // FILE_ERROR_FAILED.
-void GetFileContentOnUIThread(
+base::Closure GetFileContentOnUIThread(
     const DriveFileStreamReader::FileSystemGetter& file_system_getter,
     const base::FilePath& drive_file_path,
     const GetFileContentInitializedCallback& initialized_callback,
     const google_apis::GetContentCallback& get_content_callback,
     const FileOperationCallback& completion_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FileSystemInterface* file_system = file_system_getter.Run();
   if (!file_system) {
     completion_callback.Run(FILE_ERROR_FAILED);
-    return;
+    return base::Closure();
   }
 
-  file_system->GetFileContent(drive_file_path,
-                              initialized_callback,
-                              get_content_callback,
-                              completion_callback);
+  return google_apis::CreateRelayCallback(
+      file_system->GetFileContent(drive_file_path,
+                                  initialized_callback,
+                                  get_content_callback,
+                                  completion_callback));
 }
 
 // Helper to run FileSystemInterface::GetFileContent on UI thread.
 void GetFileContent(
     const DriveFileStreamReader::FileSystemGetter& file_system_getter,
     const base::FilePath& drive_file_path,
     const GetFileContentInitializedCallback& initialized_callback,
     const google_apis::GetContentCallback& get_content_callback,
-    const FileOperationCallback& completion_callback) {
+    const FileOperationCallback& completion_callback,
+    const base::Callback<void(const base::Closure&)>& reply_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  BrowserThread::PostTask(
+  BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GetFileContentOnUIThread,
                  file_system_getter,
                  drive_file_path,
                  google_apis::CreateRelayCallback(initialized_callback),
                  google_apis::CreateRelayCallback(get_content_callback),
-                 google_apis::CreateRelayCallback(completion_callback)));
+                 google_apis::CreateRelayCallback(completion_callback)),
+      reply_callback);
 }
 
 }  // namespace
 
 DriveFileStreamReader::DriveFileStreamReader(
     const FileSystemGetter& file_system_getter,
     base::SequencedTaskRunner* file_task_runner)
     : file_system_getter_(file_system_getter),
       file_task_runner_(file_task_runner),
       weak_ptr_factory_(this) {
@@ skipping 20 matching lines @@
       drive_file_path,
       base::Bind(&DriveFileStreamReader
                      ::InitializeAfterGetFileContentInitialized,
                  weak_ptr_factory_.GetWeakPtr(),
                  byte_range,
                  callback),
       base::Bind(&DriveFileStreamReader::OnGetContent,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&DriveFileStreamReader::OnGetFileContentCompletion,
                  weak_ptr_factory_.GetWeakPtr(),
-                 callback));
+                 callback),
+      base::Bind(&DriveFileStreamReader::StoreCancelDownloadClosure,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 int DriveFileStreamReader::Read(net::IOBuffer* buffer, int buffer_length,
                                 const net::CompletionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(reader_proxy_);
   DCHECK(buffer);
   DCHECK(!callback.is_null());
   return reader_proxy_->Read(buffer, buffer_length, callback);
 }
 
+void DriveFileStreamReader::StoreCancelDownloadClosure(
+    const base::Closure& cancel_download_closure) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  cancel_download_closure_ = cancel_download_closure;
+}
+
 void DriveFileStreamReader::InitializeAfterGetFileContentInitialized(
     const net::HttpByteRange& byte_range,
     const InitializeCompletionCallback& callback,
     FileError error,
-    scoped_ptr<ResourceEntry> entry,
     const base::FilePath& local_cache_file_path,
-    const base::Closure& ui_cancel_download_closure) {
+    scoped_ptr<ResourceEntry> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!cancel_download_closure_.is_null());

[kinaba, 2014/03/28 08:25:43]

nit: Could you add some short comment on why we can be sure DCHECK always holds?

[hashimoto, 2014/03/28 09:34:21]

Done.

 
   if (error != FILE_ERROR_OK) {
     callback.Run(FileErrorToNetError(error), scoped_ptr<ResourceEntry>());
     return;
   }
   DCHECK(entry);
 
   int64 range_start = 0, range_length = 0;
   if (!ComputeConcretePosition(byte_range, entry->file_info().size(),
                                &range_start, &range_length)) {
     // If |byte_range| is invalid (e.g. out of bounds), return with an error.
     // At the same time, we cancel the in-flight downloading operation if
     // needed and and invalidate weak pointers so that we won't
     // receive unwanted callbacks.
-    if (!ui_cancel_download_closure.is_null())
-      RunTaskOnUIThread(ui_cancel_download_closure);
+    cancel_download_closure_.Run();
     weak_ptr_factory_.InvalidateWeakPtrs();
     callback.Run(
         net::ERR_REQUEST_RANGE_NOT_SATISFIABLE, scoped_ptr<ResourceEntry>());
     return;
   }
 
   if (local_cache_file_path.empty()) {
     // The file is not cached, and being downloaded.
-    DCHECK(!ui_cancel_download_closure.is_null());
     reader_proxy_.reset(
         new internal::NetworkReaderProxy(
-            range_start, range_length,
-            base::Bind(&RunTaskOnUIThread, ui_cancel_download_closure)));
+            range_start, range_length, cancel_download_closure_));
     callback.Run(net::OK, entry.Pass());
     return;
   }
 
   // Otherwise, open the stream for file.
   scoped_ptr<util::LocalFileReader> file_reader(
       new util::LocalFileReader(file_task_runner_.get()));
   util::LocalFileReader* file_reader_ptr = file_reader.get();
   file_reader_ptr->Open(
       local_cache_file_path,
@@ skipping 50 matching lines @@
     // Note: due to the same reason, LocalReaderProxy::OnCompleted may
     // or may not be called. This is timing issue, and it is difficult to avoid
     // unfortunately.
     if (error != FILE_ERROR_OK) {
       callback.Run(FileErrorToNetError(error), scoped_ptr<ResourceEntry>());
     }
   }
 }
 
 }  // namespace drive