fileapi: FileWriter and LocalFileWriter.

webkit/fileapi/local_file_writer.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 "webkit/fileapi/local_file_writer.h"
+
+#include "base/callback.h"
+#include "base/message_loop.h"
+#include "net/base/file_stream.h"
+#include "net/base/io_buffer.h"
+
+namespace fileapi {
+
+namespace {
+
+const int kOpenFlagsForWrite = base::PLATFORM_FILE_OPEN |
+                               base::PLATFORM_FILE_WRITE |
+                               base::PLATFORM_FILE_ASYNC;
+
+const int kOpenFlagsForCreate = base::PLATFORM_FILE_CREATE_ALWAYS |
+                                base::PLATFORM_FILE_WRITE |
+                                base::PLATFORM_FILE_ASYNC;
+
+}  // namespace
+
+LocalFileWriter::LocalFileWriter(const FilePath& file_path,
+                                 int64 initial_offset,
+                                 FileOpenMode mode)
+    : file_path_(file_path),
+      file_open_flags_(mode == CREATE ? kOpenFlagsForCreate
+                                      : kOpenFlagsForWrite),
+      initial_offset_(initial_offset),
+      has_pending_operation_(false),
+      weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
+
+LocalFileWriter::~LocalFileWriter() {
+  // Invalidate weak pointers so that we won't receive any callbacks from
+  // in-flight stream operations, which might be triggered during the file close
+  // in the FileStream destructor.
+  weak_factory_.InvalidateWeakPtrs();
+
+  // FileStream's destructor closes the file safely, since we opened the file
+  // by its Open() method.
+}
+
+int LocalFileWriter::Write(net::IOBuffer* buf, int buf_len,
+                           const net::CompletionCallback& callback) {
+  DCHECK(!has_pending_operation_);
+  DCHECK(cancel_callback_.is_null());
+
+  has_pending_operation_ = true;
+  if (stream_impl_.get()) {
+    int result = InitiateWrite(buf, buf_len, callback);
+    if (result != net::ERR_IO_PENDING)
+      has_pending_operation_ = false;
+    return result;
+  }
+  return InitiateOpen(callback,
+                      base::Bind(&LocalFileWriter::ReadyToWrite,
+                                 weak_factory_.GetWeakPtr(),
+                                 make_scoped_refptr(buf), buf_len, callback));
+}
+
+int LocalFileWriter::Cancel(const net::CompletionCallback& callback) {
+  if (!has_pending_operation_)
+    return net::ERR_UNEXPECTED;
+
+  DCHECK(!callback.is_null());
+  cancel_callback_ = callback;
+  return net::ERR_IO_PENDING;
+}
+
+int LocalFileWriter::InitiateOpen(const net::CompletionCallback& error_callback,
+                                  const base::Closure& main_operation) {
+  DCHECK(has_pending_operation_);
+  DCHECK(!stream_impl_.get());
+
+  stream_impl_.reset(new net::FileStream(NULL));
+  return stream_impl_->Open(file_path_,
+                            file_open_flags_,
+                            base::Bind(&LocalFileWriter::DidOpen,
+                                       weak_factory_.GetWeakPtr(),
+                                       error_callback,
+                                       main_operation));
+}
+
+void LocalFileWriter::DidOpen(const net::CompletionCallback& error_callback,
+                              const base::Closure& main_operation,
+                              int result) {
+  DCHECK(has_pending_operation_);
+  DCHECK(stream_impl_.get());
+
+  if (CancelIfRequested())
+    return;
+
+  if (result != net::OK) {
+    has_pending_operation_ = false;
+    stream_impl_.reset(NULL);
+    error_callback.Run(result);
+    return;
+  }
+
+  InitiateSeek(error_callback, main_operation);
+}
+
+void LocalFileWriter::InitiateSeek(
+    const net::CompletionCallback& error_callback,
+    const base::Closure& main_operation) {
+  DCHECK(has_pending_operation_);
+  DCHECK(stream_impl_.get());
+
+  if (initial_offset_ == 0) {
+    // No need to seek.
+    main_operation.Run();
+    return;
+  }
+
+  int result = stream_impl_->Seek(net::FROM_BEGIN, initial_offset_,
+                                  base::Bind(&LocalFileWriter::DidSeek,
+                                             weak_factory_.GetWeakPtr(),
+                                             error_callback,
+                                             main_operation));
+  if (result != net::ERR_IO_PENDING) {
+    has_pending_operation_ = false;
+    error_callback.Run(result);
+  }
+}
+
+void LocalFileWriter::DidSeek(const net::CompletionCallback& error_callback,
+                              const base::Closure& main_operation,
+                              int64 result) {
+  DCHECK(has_pending_operation_);
+
+  if (CancelIfRequested())
+    return;
+
+  if (result != initial_offset_)
+    result = net::ERR_INVALID_ARGUMENT;

[kinuko, 2012/04/23 12:50:29]

This is not necessarily the given argument is invalid. (It's just a file and it
could be changed at any time)
Hmm... let's use net::ERR_FAILED for now, but please add a TODO comment to add a
better, more specific error code.

[kinaba, 2012/04/24 07:35:04]

Done.

+
+  if (result < 0) {
+    has_pending_operation_ = false;
+    error_callback.Run(static_cast<int>(result));
+    return;
+  }
+
+  main_operation.Run();
+}
+
+void LocalFileWriter::ReadyToWrite(net::IOBuffer* buf, int buf_len,
+                                   const net::CompletionCallback& callback) {
+  DCHECK(has_pending_operation_);
+
+  int result = InitiateWrite(buf, buf_len, callback);
+  if (result != net::ERR_IO_PENDING) {
+    has_pending_operation_ = false;
+    callback.Run(result);
+  }
+}
+
+int LocalFileWriter::InitiateWrite(net::IOBuffer* buf, int buf_len,
+                                   const net::CompletionCallback& callback) {
+  DCHECK(has_pending_operation_);
+  DCHECK(stream_impl_.get());
+
+  return stream_impl_->Write(buf, buf_len,
+                             base::Bind(&LocalFileWriter::DidWrite,
+                                        weak_factory_.GetWeakPtr(),
+                                        callback));
+}
+
+void LocalFileWriter::DidWrite(const net::CompletionCallback& callback,
+                               int result) {
+  DCHECK(has_pending_operation_);
+
+  if (CancelIfRequested())
+    return;
+  has_pending_operation_ = false;
+  callback.Run(result);
+}
+
+bool LocalFileWriter::CancelIfRequested() {
+  DCHECK(has_pending_operation_);
+
+  if (cancel_callback_.is_null())
+    return false;
+
+  net::CompletionCallback pending_cancel = cancel_callback_;
+  has_pending_operation_ = false;
+  cancel_callback_.Reset();
+  pending_cancel.Run(net::OK);
+  return true;
+}
+
+}  // namespace fileapi