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