src/chrome/browser/chromeos/file_system_provider/fileapi/file_stream_writer.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/file_system_provider/fileapi/file_stream_writer.h"
   6
   7 #include "base/debug/trace_event.h"
   8 #include "base/memory/ref_counted.h"
   9 #include "chrome/browser/chromeos/file_system_provider/fileapi/provider_async_file_util.h"
  10 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
  11 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
  12 #include "content/public/browser/browser_thread.h"
  13 #include "net/base/io_buffer.h"
  14 #include "net/base/net_errors.h"
  15
  16 using content::BrowserThread;
  17
  18 namespace chromeos {
  19 namespace file_system_provider {
  20 namespace {
  21
  22 // Dicards the callback from CloseFile().
  23 void EmptyStatusCallback(base::File::Error /* result */) {
  24 }
  25
  26 }  // namespace
  27
  28 class FileStreamWriter::OperationRunner
  29     : public base::RefCountedThreadSafe<FileStreamWriter::OperationRunner> {
  30  public:
  31   OperationRunner() : file_handle_(-1) {}
  32
  33   // Opens a file for writing and calls the completion callback. Must be called
  34   // on UI thread.
  35   void OpenFileOnUIThread(
  36       const storage::FileSystemURL& url,
  37       const storage::AsyncFileUtil::StatusCallback& callback) {
  38     DCHECK_CURRENTLY_ON(BrowserThread::UI);
  39
  40     util::FileSystemURLParser parser(url);
  41     if (!parser.Parse()) {
  42       BrowserThread::PostTask(
  43           BrowserThread::IO,
  44           FROM_HERE,
  45           base::Bind(callback, base::File::FILE_ERROR_SECURITY));
  46       return;
  47     }
  48
  49     file_system_ = parser.file_system()->GetWeakPtr();
  50     abort_callback_ = parser.file_system()->OpenFile(
  51         parser.file_path(),
  52         ProvidedFileSystemInterface::OPEN_FILE_MODE_WRITE,
  53         base::Bind(
  54             &OperationRunner::OnOpenFileCompletedOnUIThread, this, callback));
  55   }
  56
  57   // Closes a file. Ignores result, since outlives the caller. Must be called on
  58   // UI thread.
  59   void CloseFileOnUIThread() {
  60     DCHECK_CURRENTLY_ON(BrowserThread::UI);
  61     if (file_system_.get() && file_handle_ != -1) {
  62       // Closing a file must not be aborted, since we could end up on files
  63       // which are never closed.
  64       file_system_->CloseFile(file_handle_, base::Bind(&EmptyStatusCallback));
  65     }
  66   }
  67
  68   // Requests writing bytes to the file. In case of either success or a failure
  69   // |callback| is executed. Must be called on UI thread.
  70   void WriteFileOnUIThread(
  71       scoped_refptr<net::IOBuffer> buffer,
  72       int64 offset,
  73       int length,
  74       const storage::AsyncFileUtil::StatusCallback& callback) {
  75     DCHECK_CURRENTLY_ON(BrowserThread::UI);
  76
  77     // If the file system got unmounted, then abort the writing operation.
  78     if (!file_system_.get()) {
  79       BrowserThread::PostTask(
  80           BrowserThread::IO,
  81           FROM_HERE,
  82           base::Bind(callback, base::File::FILE_ERROR_ABORT));
  83       return;
  84     }
  85
  86     abort_callback_ = file_system_->WriteFile(
  87         file_handle_,
  88         buffer.get(),
  89         offset,
  90         length,
  91         base::Bind(
  92             &OperationRunner::OnWriteFileCompletedOnUIThread, this, callback));
  93   }
  94
  95   // Aborts the most recent operation (if exists), and calls the callback.
  96   void AbortOnUIThread(const storage::AsyncFileUtil::StatusCallback& callback) {
  97     DCHECK_CURRENTLY_ON(BrowserThread::UI);
  98
  99     if (abort_callback_.is_null()) {
 100       // No operation to be cancelled. At most a callback call, which will be
 101       // discarded.
 102       BrowserThread::PostTask(BrowserThread::IO,
 103                               FROM_HERE,
 104                               base::Bind(callback, base::File::FILE_OK));
 105       return;
 106     }
 107
 108     const ProvidedFileSystemInterface::AbortCallback abort_callback =
 109         abort_callback_;
 110     abort_callback_ = ProvidedFileSystemInterface::AbortCallback();
 111     abort_callback.Run(base::Bind(
 112         &OperationRunner::OnAbortCompletedOnUIThread, this, callback));
 113   }
 114
 115  private:
 116   friend class base::RefCountedThreadSafe<OperationRunner>;
 117
 118   virtual ~OperationRunner() {}
 119
 120   // Remembers a file handle for further operations and forwards the result to
 121   // the IO thread.
 122   void OnOpenFileCompletedOnUIThread(
 123       const storage::AsyncFileUtil::StatusCallback& callback,
 124       int file_handle,
 125       base::File::Error result) {
 126     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 127
 128     file_handle_ = file_handle;
 129     BrowserThread::PostTask(
 130         BrowserThread::IO, FROM_HERE, base::Bind(callback, result));
 131   }
 132
 133   // Forwards a response of writing to a file to the IO thread.
 134   void OnWriteFileCompletedOnUIThread(
 135       const storage::AsyncFileUtil::StatusCallback& callback,
 136       base::File::Error result) {
 137     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 138     BrowserThread::PostTask(
 139         BrowserThread::IO, FROM_HERE, base::Bind(callback, result));
 140   }
 141
 142   // Forwards a response of aborting an operation to the IO thread.
 143   void OnAbortCompletedOnUIThread(
 144       const storage::AsyncFileUtil::StatusCallback& callback,
 145       base::File::Error result) {
 146     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 147     BrowserThread::PostTask(
 148         BrowserThread::IO, FROM_HERE, base::Bind(callback, result));
 149   }
 150
 151   ProvidedFileSystemInterface::AbortCallback abort_callback_;
 152   base::WeakPtr<ProvidedFileSystemInterface> file_system_;
 153   int file_handle_;
 154
 155   DISALLOW_COPY_AND_ASSIGN(OperationRunner);
 156 };
 157
 158 FileStreamWriter::FileStreamWriter(const storage::FileSystemURL& url,
 159                                    int64 initial_offset)
 160     : url_(url),
 161       current_offset_(initial_offset),
 162       runner_(new OperationRunner),
 163       state_(NOT_INITIALIZED),
 164       weak_ptr_factory_(this) {
 165 }
 166
 167 FileStreamWriter::~FileStreamWriter() {
 168   BrowserThread::PostTask(
 169       BrowserThread::UI,
 170       FROM_HERE,
 171       base::Bind(&OperationRunner::CloseFileOnUIThread, runner_));
 172 }
 173
 174 void FileStreamWriter::Initialize(
 175     const base::Closure& pending_closure,
 176     const net::CompletionCallback& error_callback) {
 177   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 178   DCHECK_EQ(NOT_INITIALIZED, state_);
 179   state_ = INITIALIZING;
 180
 181   BrowserThread::PostTask(
 182       BrowserThread::UI,
 183       FROM_HERE,
 184       base::Bind(&OperationRunner::OpenFileOnUIThread,
 185                  runner_,
 186                  url_,
 187                  base::Bind(&FileStreamWriter::OnOpenFileCompleted,
 188                             weak_ptr_factory_.GetWeakPtr(),
 189                             pending_closure,
 190                             error_callback)));
 191 }
 192
 193 void FileStreamWriter::OnOpenFileCompleted(
 194     const base::Closure& pending_closure,
 195     const net::CompletionCallback& error_callback,
 196     base::File::Error result) {
 197   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 198   DCHECK_EQ(INITIALIZING, state_);
 199
 200   // In case of an error, return immediately using the |error_callback| of the
 201   // Write() pending request.
 202   if (result != base::File::FILE_OK) {
 203     state_ = FAILED;
 204     error_callback.Run(net::FileErrorToNetError(result));
 205     return;
 206   }
 207
 208   DCHECK_EQ(base::File::FILE_OK, result);
 209   state_ = INITIALIZED;
 210
 211   // Run the task waiting for the initialization to be completed.
 212   pending_closure.Run();
 213 }
 214
 215 int FileStreamWriter::Write(net::IOBuffer* buffer,
 216                             int buffer_length,
 217                             const net::CompletionCallback& callback) {
 218   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 219   TRACE_EVENT_ASYNC_BEGIN1("file_system_provider",
 220                            "FileStreamWriter::Write",
 221                            this,
 222                            "buffer_length",
 223                            buffer_length);
 224
 225   switch (state_) {
 226     case NOT_INITIALIZED:
 227       // Lazily initialize with the first call to Write().
 228       Initialize(base::Bind(&FileStreamWriter::WriteAfterInitialized,
 229                             weak_ptr_factory_.GetWeakPtr(),
 230                             make_scoped_refptr(buffer),
 231                             buffer_length,
 232                             base::Bind(&FileStreamWriter::OnWriteCompleted,
 233                                        weak_ptr_factory_.GetWeakPtr(),
 234                                        callback)),
 235                  base::Bind(&FileStreamWriter::OnWriteCompleted,
 236                             weak_ptr_factory_.GetWeakPtr(),
 237                             callback));
 238       break;
 239
 240     case INITIALIZING:
 241       NOTREACHED();
 242       break;
 243
 244     case INITIALIZED:
 245       WriteAfterInitialized(buffer,
 246                             buffer_length,
 247                             base::Bind(&FileStreamWriter::OnWriteCompleted,
 248                                        weak_ptr_factory_.GetWeakPtr(),
 249                                        callback));
 250       break;
 251
 252     case FAILED:
 253       NOTREACHED();
 254       break;
 255   }
 256
 257   return net::ERR_IO_PENDING;
 258 }
 259
 260 int FileStreamWriter::Cancel(const net::CompletionCallback& callback) {
 261   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 262
 263   BrowserThread::PostTask(
 264       BrowserThread::UI,
 265       FROM_HERE,
 266       base::Bind(&OperationRunner::AbortOnUIThread,
 267                  runner_,
 268                  base::Bind(&FileStreamWriter::OnAbortCompleted,
 269                             weak_ptr_factory_.GetWeakPtr(),
 270                             callback)));
 271   return net::ERR_IO_PENDING;
 272 }
 273
 274 int FileStreamWriter::Flush(const net::CompletionCallback& callback) {
 275   if (state_ != INITIALIZED)
 276     return net::ERR_FAILED;
 277
 278   return net::OK;
 279 }
 280
 281 void FileStreamWriter::OnWriteFileCompleted(
 282     int buffer_length,
 283     const net::CompletionCallback& callback,
 284     base::File::Error result) {
 285   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 286   DCHECK_EQ(INITIALIZED, state_);
 287
 288   if (result != base::File::FILE_OK) {
 289     state_ = FAILED;
 290     callback.Run(net::FileErrorToNetError(result));
 291     return;
 292   }
 293
 294   current_offset_ += buffer_length;
 295   callback.Run(buffer_length);
 296 }
 297
 298 void FileStreamWriter::OnWriteCompleted(net::CompletionCallback callback,
 299                                         int result) {
 300   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 301   callback.Run(result);
 302   TRACE_EVENT_ASYNC_END0(
 303       "file_system_provider", "FileStreamWriter::Write", this);
 304 }
 305
 306 void FileStreamWriter::OnAbortCompleted(const net::CompletionCallback& callback,
 307                                         base::File::Error result) {
 308   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 309
 310   if (result != base::File::FILE_OK)
 311     state_ = FAILED;
 312
 313   callback.Run(net::FileErrorToNetError(result));
 314 }
 315
 316 void FileStreamWriter::WriteAfterInitialized(
 317     scoped_refptr<net::IOBuffer> buffer,
 318     int buffer_length,
 319     const net::CompletionCallback& callback) {
 320   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 321   DCHECK_EQ(INITIALIZED, state_);
 322
 323   BrowserThread::PostTask(
 324       BrowserThread::UI,
 325       FROM_HERE,
 326       base::Bind(&OperationRunner::WriteFileOnUIThread,
 327                  runner_,
 328                  buffer,
 329                  current_offset_,
 330                  buffer_length,
 331                  base::Bind(&FileStreamWriter::OnWriteFileCompleted,
 332                             weak_ptr_factory_.GetWeakPtr(),
 333                             buffer_length,
 334                             callback)));
 335 }
 336
 337 }  // namespace file_system_provider
 338 }  // namespace chromeos