1 // Copyright 2013 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/sync_file_system/local/syncable_file_system_operation.h" 6 7 #include "base/logging.h" 8 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h" 9 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h" 10 #include "chrome/browser/sync_file_system/local/syncable_file_operation_runner.h" 11 #include "chrome/browser/sync_file_system/syncable_file_system_util.h" 12 #include "net/url_request/url_request.h" 13 #include "storage/browser/fileapi/file_system_context.h" 14 #include "storage/browser/fileapi/file_system_operation.h" 15 #include "storage/browser/fileapi/file_system_operation_context.h" 16 #include "storage/browser/fileapi/file_system_url.h" 17 #include "storage/browser/fileapi/file_writer_delegate.h" 18 #include "storage/common/blob/shareable_file_reference.h" 19 20 using storage::FileSystemURL; 21 22 namespace sync_file_system { 23 24 namespace { 25 26 void WriteCallbackAdapter( 27 const SyncableFileSystemOperation::WriteCallback& callback, 28 base::File::Error status) { 29 callback.Run(status, 0, true); 30 } 31 32 } // namespace 33 34 class SyncableFileSystemOperation::QueueableTask 35 : public SyncableFileOperationRunner::Task { 36 public: 37 QueueableTask(base::WeakPtr<SyncableFileSystemOperation> operation, 38 const base::Closure& task) 39 : operation_(operation), 40 task_(task), 41 target_paths_(operation->target_paths_) {} 42 43 virtual ~QueueableTask() { 44 DCHECK(!operation_); 45 } 46 47 virtual void Run() OVERRIDE { 48 if (!operation_) 49 return; 50 DCHECK(!task_.is_null()); 51 task_.Run(); 52 operation_.reset(); 53 } 54 55 virtual void Cancel() OVERRIDE { 56 DCHECK(!task_.is_null()); 57 if (operation_) 58 operation_->OnCancelled(); 59 task_.Reset(); 60 operation_.reset(); 61 } 62 63 virtual const std::vector<FileSystemURL>& target_paths() const OVERRIDE { 64 return target_paths_; 65 } 66 67 private: 68 base::WeakPtr<SyncableFileSystemOperation> operation_; 69 base::Closure task_; 70 std::vector<FileSystemURL> target_paths_; 71 DISALLOW_COPY_AND_ASSIGN(QueueableTask); 72 }; 73 74 SyncableFileSystemOperation::~SyncableFileSystemOperation() {} 75 76 void SyncableFileSystemOperation::CreateFile( 77 const FileSystemURL& url, 78 bool exclusive, 79 const StatusCallback& callback) { 80 DCHECK(CalledOnValidThread()); 81 if (!operation_runner_.get()) { 82 callback.Run(base::File::FILE_ERROR_NOT_FOUND); 83 return; 84 } 85 DCHECK(operation_runner_.get()); 86 target_paths_.push_back(url); 87 completion_callback_ = callback; 88 scoped_ptr<SyncableFileOperationRunner::Task> task(new QueueableTask( 89 weak_factory_.GetWeakPtr(), 90 base::Bind(&FileSystemOperation::CreateFile, 91 base::Unretained(impl_.get()), 92 url, exclusive, 93 base::Bind(&self::DidFinish, weak_factory_.GetWeakPtr())))); 94 operation_runner_->PostOperationTask(task.Pass()); 95 } 96 97 void SyncableFileSystemOperation::CreateDirectory( 98 const FileSystemURL& url, 99 bool exclusive, 100 bool recursive, 101 const StatusCallback& callback) { 102 DCHECK(CalledOnValidThread()); 103 if (!operation_runner_.get()) { 104 callback.Run(base::File::FILE_ERROR_NOT_FOUND); 105 return; 106 } 107 DCHECK(operation_runner_.get()); 108 target_paths_.push_back(url); 109 completion_callback_ = callback; 110 scoped_ptr<SyncableFileOperationRunner::Task> task(new QueueableTask( 111 weak_factory_.GetWeakPtr(), 112 base::Bind(&FileSystemOperation::CreateDirectory, 113 base::Unretained(impl_.get()), 114 url, exclusive, recursive, 115 base::Bind(&self::DidFinish, weak_factory_.GetWeakPtr())))); 116 operation_runner_->PostOperationTask(task.Pass()); 117 } 118 119 void SyncableFileSystemOperation::Copy( 120 const FileSystemURL& src_url, 121 const FileSystemURL& dest_url, 122 CopyOrMoveOption option, 123 const CopyProgressCallback& progress_callback, 124 const StatusCallback& callback) { 125 DCHECK(CalledOnValidThread()); 126 if (!operation_runner_.get()) { 127 callback.Run(base::File::FILE_ERROR_NOT_FOUND); 128 return; 129 } 130 DCHECK(operation_runner_.get()); 131 target_paths_.push_back(dest_url); 132 completion_callback_ = callback; 133 scoped_ptr<SyncableFileOperationRunner::Task> task(new QueueableTask( 134 weak_factory_.GetWeakPtr(), 135 base::Bind(&FileSystemOperation::Copy, 136 base::Unretained(impl_.get()), 137 src_url, dest_url, option, progress_callback, 138 base::Bind(&self::DidFinish, weak_factory_.GetWeakPtr())))); 139 operation_runner_->PostOperationTask(task.Pass()); 140 } 141 142 void SyncableFileSystemOperation::Move( 143 const FileSystemURL& src_url, 144 const FileSystemURL& dest_url, 145 CopyOrMoveOption option, 146 const StatusCallback& callback) { 147 DCHECK(CalledOnValidThread()); 148 if (!operation_runner_.get()) { 149 callback.Run(base::File::FILE_ERROR_NOT_FOUND); 150 return; 151 } 152 DCHECK(operation_runner_.get()); 153 target_paths_.push_back(src_url); 154 target_paths_.push_back(dest_url); 155 completion_callback_ = callback; 156 scoped_ptr<SyncableFileOperationRunner::Task> task(new QueueableTask( 157 weak_factory_.GetWeakPtr(), 158 base::Bind(&FileSystemOperation::Move, 159 base::Unretained(impl_.get()), 160 src_url, dest_url, option, 161 base::Bind(&self::DidFinish, weak_factory_.GetWeakPtr())))); 162 operation_runner_->PostOperationTask(task.Pass()); 163 } 164 165 void SyncableFileSystemOperation::DirectoryExists( 166 const FileSystemURL& url, 167 const StatusCallback& callback) { 168 DCHECK(CalledOnValidThread()); 169 impl_->DirectoryExists(url, callback); 170 } 171 172 void SyncableFileSystemOperation::FileExists( 173 const FileSystemURL& url, 174 const StatusCallback& callback) { 175 DCHECK(CalledOnValidThread()); 176 impl_->FileExists(url, callback); 177 } 178 179 void SyncableFileSystemOperation::GetMetadata( 180 const FileSystemURL& url, 181 const GetMetadataCallback& callback) { 182 DCHECK(CalledOnValidThread()); 183 impl_->GetMetadata(url, callback); 184 } 185 186 void SyncableFileSystemOperation::ReadDirectory( 187 const FileSystemURL& url, 188 const ReadDirectoryCallback& callback) { 189 DCHECK(CalledOnValidThread()); 190 // This is a read operation and there'd be no hard to let it go even if 191 // directory operation is disabled. (And we should allow this if it's made 192 // on the root directory) 193 impl_->ReadDirectory(url, callback); 194 } 195 196 void SyncableFileSystemOperation::Remove( 197 const FileSystemURL& url, bool recursive, 198 const StatusCallback& callback) { 199 DCHECK(CalledOnValidThread()); 200 if (!operation_runner_.get()) { 201 callback.Run(base::File::FILE_ERROR_NOT_FOUND); 202 return; 203 } 204 DCHECK(operation_runner_.get()); 205 target_paths_.push_back(url); 206 completion_callback_ = callback; 207 scoped_ptr<SyncableFileOperationRunner::Task> task(new QueueableTask( 208 weak_factory_.GetWeakPtr(), 209 base::Bind(&FileSystemOperation::Remove, 210 base::Unretained(impl_.get()), 211 url, recursive, 212 base::Bind(&self::DidFinish, weak_factory_.GetWeakPtr())))); 213 operation_runner_->PostOperationTask(task.Pass()); 214 } 215 216 void SyncableFileSystemOperation::Write( 217 const FileSystemURL& url, 218 scoped_ptr<storage::FileWriterDelegate> writer_delegate, 219 scoped_ptr<net::URLRequest> blob_request, 220 const WriteCallback& callback) { 221 DCHECK(CalledOnValidThread()); 222 if (!operation_runner_.get()) { 223 callback.Run(base::File::FILE_ERROR_NOT_FOUND, 0, true); 224 return; 225 } 226 DCHECK(operation_runner_.get()); 227 target_paths_.push_back(url); 228 completion_callback_ = base::Bind(&WriteCallbackAdapter, callback); 229 scoped_ptr<SyncableFileOperationRunner::Task> task(new QueueableTask( 230 weak_factory_.GetWeakPtr(), 231 base::Bind(&FileSystemOperation::Write, 232 base::Unretained(impl_.get()), 233 url, 234 base::Passed(&writer_delegate), 235 base::Passed(&blob_request), 236 base::Bind(&self::DidWrite, weak_factory_.GetWeakPtr(), 237 callback)))); 238 operation_runner_->PostOperationTask(task.Pass()); 239 } 240 241 void SyncableFileSystemOperation::Truncate( 242 const FileSystemURL& url, int64 length, 243 const StatusCallback& callback) { 244 DCHECK(CalledOnValidThread()); 245 if (!operation_runner_.get()) { 246 callback.Run(base::File::FILE_ERROR_NOT_FOUND); 247 return; 248 } 249 DCHECK(operation_runner_.get()); 250 target_paths_.push_back(url); 251 completion_callback_ = callback; 252 scoped_ptr<SyncableFileOperationRunner::Task> task(new QueueableTask( 253 weak_factory_.GetWeakPtr(), 254 base::Bind(&FileSystemOperation::Truncate, 255 base::Unretained(impl_.get()), 256 url, length, 257 base::Bind(&self::DidFinish, weak_factory_.GetWeakPtr())))); 258 operation_runner_->PostOperationTask(task.Pass()); 259 } 260 261 void SyncableFileSystemOperation::TouchFile( 262 const FileSystemURL& url, 263 const base::Time& last_access_time, 264 const base::Time& last_modified_time, 265 const StatusCallback& callback) { 266 DCHECK(CalledOnValidThread()); 267 impl_->TouchFile(url, last_access_time, last_modified_time, callback); 268 } 269 270 void SyncableFileSystemOperation::OpenFile( 271 const FileSystemURL& url, 272 int file_flags, 273 const OpenFileCallback& callback) { 274 NOTREACHED(); 275 } 276 277 void SyncableFileSystemOperation::Cancel( 278 const StatusCallback& cancel_callback) { 279 DCHECK(CalledOnValidThread()); 280 impl_->Cancel(cancel_callback); 281 } 282 283 void SyncableFileSystemOperation::CreateSnapshotFile( 284 const FileSystemURL& path, 285 const SnapshotFileCallback& callback) { 286 DCHECK(CalledOnValidThread()); 287 impl_->CreateSnapshotFile(path, callback); 288 } 289 290 void SyncableFileSystemOperation::CopyInForeignFile( 291 const base::FilePath& src_local_disk_path, 292 const FileSystemURL& dest_url, 293 const StatusCallback& callback) { 294 DCHECK(CalledOnValidThread()); 295 if (!operation_runner_.get()) { 296 callback.Run(base::File::FILE_ERROR_NOT_FOUND); 297 return; 298 } 299 DCHECK(operation_runner_.get()); 300 target_paths_.push_back(dest_url); 301 completion_callback_ = callback; 302 scoped_ptr<SyncableFileOperationRunner::Task> task(new QueueableTask( 303 weak_factory_.GetWeakPtr(), 304 base::Bind(&FileSystemOperation::CopyInForeignFile, 305 base::Unretained(impl_.get()), 306 src_local_disk_path, dest_url, 307 base::Bind(&self::DidFinish, weak_factory_.GetWeakPtr())))); 308 operation_runner_->PostOperationTask(task.Pass()); 309 } 310 311 void SyncableFileSystemOperation::RemoveFile( 312 const FileSystemURL& url, 313 const StatusCallback& callback) { 314 DCHECK(CalledOnValidThread()); 315 impl_->RemoveFile(url, callback); 316 } 317 318 void SyncableFileSystemOperation::RemoveDirectory( 319 const FileSystemURL& url, 320 const StatusCallback& callback) { 321 DCHECK(CalledOnValidThread()); 322 impl_->RemoveDirectory(url, callback); 323 } 324 325 void SyncableFileSystemOperation::CopyFileLocal( 326 const FileSystemURL& src_url, 327 const FileSystemURL& dest_url, 328 CopyOrMoveOption option, 329 const CopyFileProgressCallback& progress_callback, 330 const StatusCallback& callback) { 331 DCHECK(CalledOnValidThread()); 332 impl_->CopyFileLocal(src_url, dest_url, option, progress_callback, callback); 333 } 334 335 void SyncableFileSystemOperation::MoveFileLocal( 336 const FileSystemURL& src_url, 337 const FileSystemURL& dest_url, 338 CopyOrMoveOption option, 339 const StatusCallback& callback) { 340 DCHECK(CalledOnValidThread()); 341 impl_->MoveFileLocal(src_url, dest_url, option, callback); 342 } 343 344 base::File::Error SyncableFileSystemOperation::SyncGetPlatformPath( 345 const FileSystemURL& url, 346 base::FilePath* platform_path) { 347 return impl_->SyncGetPlatformPath(url, platform_path); 348 } 349 350 SyncableFileSystemOperation::SyncableFileSystemOperation( 351 const FileSystemURL& url, 352 storage::FileSystemContext* file_system_context, 353 scoped_ptr<storage::FileSystemOperationContext> operation_context) 354 : url_(url), weak_factory_(this) { 355 DCHECK(file_system_context); 356 SyncFileSystemBackend* backend = 357 SyncFileSystemBackend::GetBackend(file_system_context); 358 DCHECK(backend); 359 if (!backend->sync_context()) { 360 // Syncable FileSystem is opened in a file system context which doesn't 361 // support (or is not initialized for) the API. 362 // Returning here to leave operation_runner_ as NULL. 363 return; 364 } 365 impl_.reset(storage::FileSystemOperation::Create( 366 url_, file_system_context, operation_context.Pass())); 367 operation_runner_ = backend->sync_context()->operation_runner(); 368 } 369 370 void SyncableFileSystemOperation::DidFinish(base::File::Error status) { 371 DCHECK(CalledOnValidThread()); 372 DCHECK(!completion_callback_.is_null()); 373 if (operation_runner_.get()) 374 operation_runner_->OnOperationCompleted(target_paths_); 375 completion_callback_.Run(status); 376 } 377 378 void SyncableFileSystemOperation::DidWrite( 379 const WriteCallback& callback, 380 base::File::Error result, 381 int64 bytes, 382 bool complete) { 383 DCHECK(CalledOnValidThread()); 384 if (!complete) { 385 callback.Run(result, bytes, complete); 386 return; 387 } 388 if (operation_runner_.get()) 389 operation_runner_->OnOperationCompleted(target_paths_); 390 callback.Run(result, bytes, complete); 391 } 392 393 void SyncableFileSystemOperation::OnCancelled() { 394 DCHECK(!completion_callback_.is_null()); 395 completion_callback_.Run(base::File::FILE_ERROR_ABORT); 396 } 397 398 } // namespace sync_file_system 399
