[fsp] Simplify aborting logic.

chrome/browser/chromeos/file_system_provider/fileapi/file_stream_reader.cc

 // Copyright 2014 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/file_system_provider/fileapi/file_stream_reader.h"
 
 #include "base/debug/trace_event.h"
 #include "base/files/file.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/chromeos/file_system_provider/abort_callback.h"
@@ skipping 26 matching lines @@
     : public base::RefCountedThreadSafe<FileStreamReader::OperationRunner> {
  public:
   OperationRunner() : file_handle_(-1) {}
 
   // Opens a file for reading and calls the completion callback. Must be called
   // on UI thread.
   void OpenFileOnUIThread(
       const storage::FileSystemURL& url,
       const storage::AsyncFileUtil::StatusCallback& callback) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    DCHECK(abort_callback_.is_null());
 
     util::FileSystemURLParser parser(url);
     if (!parser.Parse()) {
       BrowserThread::PostTask(
           BrowserThread::IO,
           FROM_HERE,
           base::Bind(callback, base::File::FILE_ERROR_SECURITY));
       return;
     }
 
     file_system_ = parser.file_system()->GetWeakPtr();
     file_path_ = parser.file_path();
     abort_callback_ = parser.file_system()->OpenFile(
         file_path_,
         ProvidedFileSystemInterface::OPEN_FILE_MODE_READ,
         base::Bind(
             &OperationRunner::OnOpenFileCompletedOnUIThread, this, callback));
   }
 
   // Closes a file. Ignores result, since it is called from a constructor.
   // Must be called on UI thread.
   void CloseFileOnUIThread() {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    DCHECK(abort_callback_.is_null());
+
     if (file_system_.get() && file_handle_ != -1) {
       // Closing a file must not be aborted, since we could end up on files
       // which are never closed.
       file_system_->CloseFile(file_handle_, base::Bind(&EmptyStatusCallback));
     }
   }
 
   // Requests reading contents of a file. In case of either success or a failure
   // |callback| is executed. It can be called many times, until |has_more| is
   // set to false. This function guarantees that it will succeed only if the
   // file has not been changed while reading. Must be called on UI thread.
   void ReadFileOnUIThread(
       scoped_refptr<net::IOBuffer> buffer,
       int64 offset,
       int length,
       const ProvidedFileSystemInterface::ReadChunkReceivedCallback& callback) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    DCHECK(abort_callback_.is_null());
 
     // If the file system got unmounted, then abort the reading operation.
     if (!file_system_.get()) {
       BrowserThread::PostTask(
           BrowserThread::IO,
           FROM_HERE,
           base::Bind(
               callback, 0, false /* has_more */, base::File::FILE_ERROR_ABORT));
       return;
     }
 
     abort_callback_ = file_system_->ReadFile(
         file_handle_,
         buffer.get(),
         offset,
         length,
         base::Bind(
             &OperationRunner::OnReadFileCompletedOnUIThread, this, callback));
   }
 
   // Requests metadata of a file. In case of either succes or a failure,
   // |callback| is executed. Must be called on UI thread.
   void GetMetadataOnUIThread(
       const ProvidedFileSystemInterface::GetMetadataCallback& callback) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    DCHECK(abort_callback_.is_null());
 
     // If the file system got unmounted, then abort the get length operation.
     if (!file_system_.get()) {
       BrowserThread::PostTask(
           BrowserThread::IO,
           FROM_HERE,
           base::Bind(callback,
                      base::Passed(make_scoped_ptr<EntryMetadata>(NULL)),
                      base::File::FILE_ERROR_ABORT));
       return;
     }
 
     abort_callback_ = file_system_->GetMetadata(
         file_path_,
         ProvidedFileSystemInterface::METADATA_FIELD_DEFAULT,
         base::Bind(&OperationRunner::OnGetMetadataCompletedOnUIThread,
                    this,
                    callback));
   }
 
   // Aborts the most recent operation (if exists), and calls the callback.
-  void AbortOnUIThread(const storage::AsyncFileUtil::StatusCallback& callback) {
+  void AbortOnUIThread() {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-    if (abort_callback_.is_null()) {
-      // No operation to be cancelled. At most a callback call, which will be
-      // discarded.
-      BrowserThread::PostTask(BrowserThread::IO,
-                              FROM_HERE,
-                              base::Bind(callback, base::File::FILE_OK));
+    if (abort_callback_.is_null())
       return;
-    }
 
     const AbortCallback last_abort_callback = abort_callback_;
     abort_callback_ = AbortCallback();
-    last_abort_callback.Run(base::Bind(
-        &OperationRunner::OnAbortCompletedOnUIThread, this, callback));
+    last_abort_callback.Run();
   }
 
  private:
   friend class base::RefCountedThreadSafe<OperationRunner>;
 
   virtual ~OperationRunner() {}
 
   // Remembers a file handle for further operations and forwards the result to
   // the IO thread.
   void OnOpenFileCompletedOnUIThread(
       const storage::AsyncFileUtil::StatusCallback& callback,
       int file_handle,
       base::File::Error result) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    abort_callback_ = AbortCallback();
 
     if (result == base::File::FILE_OK)
       file_handle_ = file_handle;
 
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE, base::Bind(callback, result));
   }
 
   // Forwards a metadata to the IO thread.
   void OnGetMetadataCompletedOnUIThread(
       const ProvidedFileSystemInterface::GetMetadataCallback& callback,
       scoped_ptr<EntryMetadata> metadata,
       base::File::Error result) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    abort_callback_ = AbortCallback();
+
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(callback, base::Passed(&metadata), result));
   }
 
   // Forwards a response of reading from a file to the IO thread.
   void OnReadFileCompletedOnUIThread(
       const ProvidedFileSystemInterface::ReadChunkReceivedCallback&
           chunk_received_callback,
       int chunk_length,
       bool has_more,
       base::File::Error result) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    if (!has_more)
+      abort_callback_ = AbortCallback();
+
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(chunk_received_callback, chunk_length, has_more, result));
   }
 
-  // Forwards a response of aborting an operation to the IO thread.
-  void OnAbortCompletedOnUIThread(
-      const storage::AsyncFileUtil::StatusCallback& callback,
-      base::File::Error result) {
-    DCHECK_CURRENTLY_ON(BrowserThread::UI);
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE, base::Bind(callback, result));
-  }
-
   AbortCallback abort_callback_;
   base::WeakPtr<ProvidedFileSystemInterface> file_system_;
   base::FilePath file_path_;
   int file_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(OperationRunner);
 };
 
 FileStreamReader::FileStreamReader(storage::FileSystemContext* context,
                                    const storage::FileSystemURL& url,
                                    int64 initial_offset,
                                    const base::Time& expected_modification_time)
     : url_(url),
       current_offset_(initial_offset),
       current_length_(0),
       expected_modification_time_(expected_modification_time),
       runner_(new OperationRunner),
       state_(NOT_INITIALIZED),
       weak_ptr_factory_(this) {
 }
 
 FileStreamReader::~FileStreamReader() {
   // FileStreamReader doesn't have a Cancel() method like in FileStreamWriter.
   // Therefore, aborting is done from the destructor.
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&OperationRunner::AbortOnUIThread,
-                                     runner_,
-                                     base::Bind(&EmptyStatusCallback)));
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&OperationRunner::AbortOnUIThread, runner_));
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&OperationRunner::CloseFileOnUIThread, runner_));
 }
 
 void FileStreamReader::Initialize(
     const base::Closure& pending_closure,
     const net::Int64CompletionCallback& error_callback) {
@@ skipping 244 matching lines @@
     callback.Run(net::ERR_UPLOAD_FILE_CHANGED);
     return;
   }
 
   DCHECK_EQ(base::File::FILE_OK, result);
   callback.Run(metadata->size);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos