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 "storage/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 "storage/browser/blob/file_stream_reader.h"
12#include "storage/browser/fileapi/file_observers.h"
13#include "storage/browser/fileapi/file_stream_writer.h"
14#include "storage/browser/fileapi/file_system_context.h"
15#include "storage/browser/fileapi/file_system_operation_runner.h"
16#include "storage/browser/quota/quota_manager_proxy.h"
17#include "storage/common/fileapi/file_system_util.h"
18
19namespace storage {
20
21namespace {
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).
27int64 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
41SandboxFileStreamWriter::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
59SandboxFileStreamWriter::~SandboxFileStreamWriter() {}
60
61int 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
78int 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
87int 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
112void 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<storage::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  storage::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
163void SandboxFileStreamWriter::DidGetUsageAndQuota(
164    const net::CompletionCallback& callback,
165    storage::QuotaStatusCode status,
166    int64 usage,
167    int64 quota) {
168  if (CancelIfRequested())
169    return;
170  if (status != storage::kQuotaStatusOk) {
171    LOG(WARNING) << "Got unexpected quota error : " << status;
172    callback.Run(net::ERR_FAILED);
173    return;
174  }
175
176  allowed_bytes_to_write_ = quota - usage;
177  callback.Run(net::OK);
178}
179
180void SandboxFileStreamWriter::DidInitializeForWrite(
181    net::IOBuffer* buf, int buf_len,
182    const net::CompletionCallback& callback,
183    int init_status) {
184  if (CancelIfRequested())
185    return;
186  if (init_status != net::OK) {
187    has_pending_operation_ = false;
188    callback.Run(init_status);
189    return;
190  }
191  allowed_bytes_to_write_ = AdjustQuotaForOverlap(
192      allowed_bytes_to_write_, initial_offset_, file_size_);
193  const int result = WriteInternal(buf, buf_len, callback);
194  if (result != net::ERR_IO_PENDING)
195    callback.Run(result);
196}
197
198void SandboxFileStreamWriter::DidWrite(
199    const net::CompletionCallback& callback,
200    int write_response) {
201  DCHECK(has_pending_operation_);
202  has_pending_operation_ = false;
203
204  if (write_response <= 0) {
205    if (CancelIfRequested())
206      return;
207    callback.Run(write_response);
208    return;
209  }
210
211  if (total_bytes_written_ + write_response + initial_offset_ > file_size_) {
212    int overlapped = file_size_ - total_bytes_written_ - initial_offset_;
213    if (overlapped < 0)
214      overlapped = 0;
215    observers_.Notify(&FileUpdateObserver::OnUpdate,
216                      MakeTuple(url_, write_response - overlapped));
217  }
218  total_bytes_written_ += write_response;
219
220  if (CancelIfRequested())
221    return;
222  callback.Run(write_response);
223}
224
225bool SandboxFileStreamWriter::CancelIfRequested() {
226  if (cancel_callback_.is_null())
227    return false;
228
229  net::CompletionCallback pending_cancel = cancel_callback_;
230  has_pending_operation_ = false;
231  cancel_callback_.Reset();
232  pending_cancel.Run(net::OK);
233  return true;
234}
235
236int SandboxFileStreamWriter::Flush(const net::CompletionCallback& callback) {
237  DCHECK(!has_pending_operation_);
238  DCHECK(cancel_callback_.is_null());
239
240  // Write() is not called yet, so there's nothing to flush.
241  if (!local_file_writer_)
242    return net::OK;
243
244  return local_file_writer_->Flush(callback);
245}
246
247}  // namespace storage
248