webkit/browser/fileapi/sandbox_file_stream_writer.cc

   1 // Copyright (c) 2012 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 "webkit/browser/fileapi/sandbox_file_stream_writer.h"
   6
   7 #include "base/files/file_util_proxy.h"
   8 #include "base/sequenced_task_runner.h"
   9 #include "net/base/io_buffer.h"
  10 #include "net/base/net_errors.h"
  11 #include "webkit/browser/blob/file_stream_reader.h"
  12 #include "webkit/browser/fileapi/file_observers.h"
  13 #include "webkit/browser/fileapi/file_stream_writer.h"
  14 #include "webkit/browser/fileapi/file_system_context.h"
  15 #include "webkit/browser/fileapi/file_system_operation_runner.h"
  16 #include "webkit/browser/quota/quota_manager_proxy.h"
  17 #include "webkit/common/fileapi/file_system_util.h"
  18
  19 namespace fileapi {
  20
  21 namespace {
  22
  23 // Adjust the |quota| value in overwriting case (i.e. |file_size| > 0 and
  24 // |file_offset| < |file_size|) to make the remaining quota calculation easier.
  25 // Specifically this widens the quota for overlapping range (so that we can
  26 // simply compare written bytes against the adjusted quota).
  27 int64 AdjustQuotaForOverlap(int64 quota,
  28                             int64 file_offset,
  29                             int64 file_size) {
  30   DCHECK_LE(file_offset, file_size);
  31   if (quota < 0)
  32     quota = 0;
  33   int64 overlap = file_size - file_offset;
  34   if (kint64max - overlap > quota)
  35     quota += overlap;
  36   return quota;
  37 }
  38
  39 }  // namespace
  40
  41 SandboxFileStreamWriter::SandboxFileStreamWriter(
  42     FileSystemContext* file_system_context,
  43     const FileSystemURL& url,
  44     int64 initial_offset,
  45     const UpdateObserverList& observers)
  46     : file_system_context_(file_system_context),
  47       url_(url),
  48       initial_offset_(initial_offset),
  49       observers_(observers),
  50       file_size_(0),
  51       total_bytes_written_(0),
  52       allowed_bytes_to_write_(0),
  53       has_pending_operation_(false),
  54       default_quota_(kint64max),
  55       weak_factory_(this) {
  56   DCHECK(url_.is_valid());
  57 }
  58
  59 SandboxFileStreamWriter::~SandboxFileStreamWriter() {}
  60
  61 int SandboxFileStreamWriter::Write(
  62     net::IOBuffer* buf, int buf_len,
  63     const net::CompletionCallback& callback) {
  64   has_pending_operation_ = true;
  65   if (local_file_writer_)
  66     return WriteInternal(buf, buf_len, callback);
  67
  68   net::CompletionCallback write_task =
  69       base::Bind(&SandboxFileStreamWriter::DidInitializeForWrite,
  70                  weak_factory_.GetWeakPtr(),
  71                  make_scoped_refptr(buf), buf_len, callback);
  72   file_system_context_->operation_runner()->CreateSnapshotFile(
  73       url_, base::Bind(&SandboxFileStreamWriter::DidCreateSnapshotFile,
  74                        weak_factory_.GetWeakPtr(), write_task));
  75   return net::ERR_IO_PENDING;
  76 }
  77
  78 int SandboxFileStreamWriter::Cancel(const net::CompletionCallback& callback) {
  79   if (!has_pending_operation_)
  80     return net::ERR_UNEXPECTED;
  81
  82   DCHECK(!callback.is_null());
  83   cancel_callback_ = callback;
  84   return net::ERR_IO_PENDING;
  85 }
  86
  87 int SandboxFileStreamWriter::WriteInternal(
  88     net::IOBuffer* buf, int buf_len,
  89     const net::CompletionCallback& callback) {
  90   // allowed_bytes_to_write could be negative if the file size is
  91   // greater than the current (possibly new) quota.
  92   DCHECK(total_bytes_written_ <= allowed_bytes_to_write_ ||
  93          allowed_bytes_to_write_ < 0);
  94   if (total_bytes_written_ >= allowed_bytes_to_write_) {
  95     has_pending_operation_ = false;
  96     return net::ERR_FILE_NO_SPACE;
  97   }
  98
  99   if (buf_len > allowed_bytes_to_write_ - total_bytes_written_)
 100     buf_len = allowed_bytes_to_write_ - total_bytes_written_;
 101
 102   DCHECK(local_file_writer_.get());
 103   const int result = local_file_writer_->Write(
 104       buf, buf_len,
 105       base::Bind(&SandboxFileStreamWriter::DidWrite, weak_factory_.GetWeakPtr(),
 106                  callback));
 107   if (result != net::ERR_IO_PENDING)
 108     has_pending_operation_ = false;
 109   return result;
 110 }
 111
 112 void SandboxFileStreamWriter::DidCreateSnapshotFile(
 113     const net::CompletionCallback& callback,
 114     base::File::Error file_error,
 115     const base::File::Info& file_info,
 116     const base::FilePath& platform_path,
 117     const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
 118   DCHECK(!file_ref.get());
 119
 120   if (CancelIfRequested())
 121     return;
 122   if (file_error != base::File::FILE_OK) {
 123     callback.Run(net::FileErrorToNetError(file_error));
 124     return;
 125   }
 126   if (file_info.is_directory) {
 127     // We should not be writing to a directory.
 128     callback.Run(net::ERR_ACCESS_DENIED);
 129     return;
 130   }
 131   file_size_ = file_info.size;
 132   if (initial_offset_ > file_size_) {
 133     LOG(ERROR) << initial_offset_ << ", " << file_size_;
 134     // This shouldn't happen as long as we check offset in the renderer.
 135     NOTREACHED();
 136     initial_offset_ = file_size_;
 137   }
 138   DCHECK(!local_file_writer_.get());
 139   local_file_writer_.reset(FileStreamWriter::CreateForLocalFile(
 140       file_system_context_->default_file_task_runner(),
 141       platform_path,
 142       initial_offset_,
 143       FileStreamWriter::OPEN_EXISTING_FILE));
 144
 145   quota::QuotaManagerProxy* quota_manager_proxy =
 146       file_system_context_->quota_manager_proxy();
 147   if (!quota_manager_proxy) {
 148     // If we don't have the quota manager or the requested filesystem type
 149     // does not support quota, we should be able to let it go.
 150     allowed_bytes_to_write_ = default_quota_;
 151     callback.Run(net::OK);
 152     return;
 153   }
 154
 155   DCHECK(quota_manager_proxy->quota_manager());
 156   quota_manager_proxy->quota_manager()->GetUsageAndQuota(
 157       url_.origin(),
 158       FileSystemTypeToQuotaStorageType(url_.type()),
 159       base::Bind(&SandboxFileStreamWriter::DidGetUsageAndQuota,
 160                  weak_factory_.GetWeakPtr(), callback));
 161 }
 162
 163 void SandboxFileStreamWriter::DidGetUsageAndQuota(
 164     const net::CompletionCallback& callback,
 165     quota::QuotaStatusCode status,
 166     int64 usage, int64 quota) {
 167   if (CancelIfRequested())
 168     return;
 169   if (status != quota::kQuotaStatusOk) {
 170     LOG(WARNING) << "Got unexpected quota error : " << status;
 171     callback.Run(net::ERR_FAILED);
 172     return;
 173   }
 174
 175   allowed_bytes_to_write_ = quota - usage;
 176   callback.Run(net::OK);
 177 }
 178
 179 void SandboxFileStreamWriter::DidInitializeForWrite(
 180     net::IOBuffer* buf, int buf_len,
 181     const net::CompletionCallback& callback,
 182     int init_status) {
 183   if (CancelIfRequested())
 184     return;
 185   if (init_status != net::OK) {
 186     has_pending_operation_ = false;
 187     callback.Run(init_status);
 188     return;
 189   }
 190   allowed_bytes_to_write_ = AdjustQuotaForOverlap(
 191       allowed_bytes_to_write_, initial_offset_, file_size_);
 192   const int result = WriteInternal(buf, buf_len, callback);
 193   if (result != net::ERR_IO_PENDING)
 194     callback.Run(result);
 195 }
 196
 197 void SandboxFileStreamWriter::DidWrite(
 198     const net::CompletionCallback& callback,
 199     int write_response) {
 200   DCHECK(has_pending_operation_);
 201   has_pending_operation_ = false;
 202
 203   if (write_response <= 0) {
 204     if (CancelIfRequested())
 205       return;
 206     callback.Run(write_response);
 207     return;
 208   }
 209
 210   if (total_bytes_written_ + write_response + initial_offset_ > file_size_) {
 211     int overlapped = file_size_ - total_bytes_written_ - initial_offset_;
 212     if (overlapped < 0)
 213       overlapped = 0;
 214     observers_.Notify(&FileUpdateObserver::OnUpdate,
 215                       MakeTuple(url_, write_response - overlapped));
 216   }
 217   total_bytes_written_ += write_response;
 218
 219   if (CancelIfRequested())
 220     return;
 221   callback.Run(write_response);
 222 }
 223
 224 bool SandboxFileStreamWriter::CancelIfRequested() {
 225   if (cancel_callback_.is_null())
 226     return false;
 227
 228   net::CompletionCallback pending_cancel = cancel_callback_;
 229   has_pending_operation_ = false;
 230   cancel_callback_.Reset();
 231   pending_cancel.Run(net::OK);
 232   return true;
 233 }
 234
 235 int SandboxFileStreamWriter::Flush(const net::CompletionCallback& callback) {
 236   DCHECK(!has_pending_operation_);
 237   DCHECK(cancel_callback_.is_null());
 238
 239   // Write() is not called yet, so there's nothing to flush.
 240   if (!local_file_writer_)
 241     return net::OK;
 242
 243   return local_file_writer_->Flush(callback);
 244 }
 245
 246 }  // namespace fileapi