| OLD | NEW |
|---|
| (Empty) |
| 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/chromeos/drive/async_file_util.h" | |
| 6 | |
| 7 #include "base/callback.h" | |
| 8 #include "base/files/file_path.h" | |
| 9 #include "base/logging.h" | |
| 10 #include "base/platform_file.h" | |
| 11 #include "base/threading/sequenced_worker_pool.h" | |
| 12 #include "chrome/browser/chromeos/drive/file_system_util.h" | |
| 13 #include "chrome/browser/chromeos/drive/fileapi_worker.h" | |
| 14 #include "content/public/browser/browser_thread.h" | |
| 15 #include "google_apis/drive/task_util.h" | |
| 16 #include "webkit/browser/fileapi/file_system_operation_context.h" | |
| 17 #include "webkit/browser/fileapi/file_system_url.h" | |
| 18 #include "webkit/common/blob/shareable_file_reference.h" | |
| 19 | |
| 20 using content::BrowserThread; | |
| 21 | |
| 22 namespace drive { | |
| 23 namespace internal { | |
| 24 namespace { | |
| 25 | |
| 26 // Posts fileapi_internal::RunFileSystemCallback to UI thread. | |
| 27 // This function must be called on IO thread. | |
| 28 // The |on_error_callback| will be called (on error case) on IO thread. | |
| 29 void PostFileSystemCallback( | |
| 30 const fileapi_internal::FileSystemGetter& file_system_getter, | |
| 31 const base::Callback<void(FileSystemInterface*)>& function, | |
| 32 const base::Closure& on_error_callback) { | |
| 33 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 34 | |
| 35 BrowserThread::PostTask( | |
| 36 BrowserThread::UI, | |
| 37 FROM_HERE, | |
| 38 base::Bind(&fileapi_internal::RunFileSystemCallback, | |
| 39 file_system_getter, function, | |
| 40 on_error_callback.is_null() ? | |
| 41 base::Closure() : | |
| 42 base::Bind(&google_apis::RunTaskOnThread, | |
| 43 base::MessageLoopProxy::current(), | |
| 44 on_error_callback))); | |
| 45 } | |
| 46 | |
| 47 // Runs CreateOrOpenFile callback based on the given |error| and |file|. | |
| 48 void RunCreateOrOpenFileCallback( | |
| 49 const AsyncFileUtil::FileSystemGetter& file_system_getter, | |
| 50 const base::FilePath& file_path, | |
| 51 const AsyncFileUtil::CreateOrOpenCallback& callback, | |
| 52 base::File::Error error, | |
| 53 base::PlatformFile file, | |
| 54 const base::Closure& close_callback_on_ui_thread) { | |
| 55 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 56 | |
| 57 // It is necessary to make a closure, which runs on file closing here. | |
| 58 // It will be provided as a FileSystem::OpenFileCallback's argument later. | |
| 59 // (crbug.com/259184). | |
| 60 callback.Run( | |
| 61 error, base::PassPlatformFile(&file), | |
| 62 base::Bind(&google_apis::RunTaskOnThread, | |
| 63 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI), | |
| 64 close_callback_on_ui_thread)); | |
| 65 } | |
| 66 | |
| 67 // Runs CreateOrOpenFile when the error happens. | |
| 68 void RunCreateOrOpenFileCallbackOnError( | |
| 69 const AsyncFileUtil::CreateOrOpenCallback& callback, | |
| 70 base::File::Error error) { | |
| 71 // Because the |callback| takes PassPlatformFile as its argument, and | |
| 72 // it is necessary to guarantee the pointer passed to PassPlatformFile is | |
| 73 // alive during the |callback| invocation, here we prepare a thin adapter | |
| 74 // to have PlatformFile on stack frame. | |
| 75 base::PlatformFile file = base::kInvalidPlatformFileValue; | |
| 76 callback.Run(error, base::PassPlatformFile(&file), base::Closure()); | |
| 77 } | |
| 78 | |
| 79 // Runs EnsureFileExistsCallback based on the given |error|. | |
| 80 void RunEnsureFileExistsCallback( | |
| 81 const AsyncFileUtil::EnsureFileExistsCallback& callback, | |
| 82 base::File::Error error) { | |
| 83 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 84 | |
| 85 // Remember if the file is actually created or not. | |
| 86 bool created = (error == base::File::FILE_OK); | |
| 87 | |
| 88 // File::FILE_ERROR_EXISTS is not an actual error here. | |
| 89 if (error == base::File::FILE_ERROR_EXISTS) | |
| 90 error = base::File::FILE_OK; | |
| 91 | |
| 92 callback.Run(error, created); | |
| 93 } | |
| 94 | |
| 95 // Runs |callback| with the arguments based on the given arguments. | |
| 96 void RunCreateSnapshotFileCallback( | |
| 97 const AsyncFileUtil::CreateSnapshotFileCallback& callback, | |
| 98 base::File::Error error, | |
| 99 const base::File::Info& file_info, | |
| 100 const base::FilePath& local_path, | |
| 101 webkit_blob::ScopedFile::ScopeOutPolicy scope_out_policy) { | |
| 102 // ShareableFileReference is thread *unsafe* class. So it is necessary to | |
| 103 // create the instance (by invoking GetOrCreate) on IO thread, though | |
| 104 // most drive file system related operations run on UI thread. | |
| 105 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 106 | |
| 107 scoped_refptr<webkit_blob::ShareableFileReference> file_reference = | |
| 108 webkit_blob::ShareableFileReference::GetOrCreate(webkit_blob::ScopedFile( | |
| 109 local_path, | |
| 110 scope_out_policy, | |
| 111 BrowserThread::GetBlockingPool())); | |
| 112 callback.Run(error, file_info, local_path, file_reference); | |
| 113 } | |
| 114 | |
| 115 } // namespace | |
| 116 | |
| 117 AsyncFileUtil::AsyncFileUtil(const FileSystemGetter& file_system_getter) | |
| 118 : file_system_getter_(file_system_getter) { | |
| 119 } | |
| 120 | |
| 121 AsyncFileUtil::~AsyncFileUtil() { | |
| 122 } | |
| 123 | |
| 124 void AsyncFileUtil::CreateOrOpen( | |
| 125 scoped_ptr<fileapi::FileSystemOperationContext> context, | |
| 126 const fileapi::FileSystemURL& url, | |
| 127 int file_flags, | |
| 128 const CreateOrOpenCallback& callback) { | |
| 129 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 130 | |
| 131 base::FilePath file_path = util::ExtractDrivePathFromFileSystemUrl(url); | |
| 132 if (file_path.empty()) { | |
| 133 base::PlatformFile platform_file = base::kInvalidPlatformFileValue; | |
| 134 callback.Run(base::File::FILE_ERROR_NOT_FOUND, | |
| 135 base::PassPlatformFile(&platform_file), | |
| 136 base::Closure()); | |
| 137 return; | |
| 138 } | |
| 139 | |
| 140 PostFileSystemCallback( | |
| 141 file_system_getter_, | |
| 142 base::Bind(&fileapi_internal::OpenFile, | |
| 143 file_path, file_flags, | |
| 144 google_apis::CreateRelayCallback( | |
| 145 base::Bind(&RunCreateOrOpenFileCallback, | |
| 146 file_system_getter_, file_path, callback))), | |
| 147 base::Bind(&RunCreateOrOpenFileCallbackOnError, | |
| 148 callback, base::File::FILE_ERROR_FAILED)); | |
| 149 } | |
| 150 | |
| 151 void AsyncFileUtil::EnsureFileExists( | |
| 152 scoped_ptr<fileapi::FileSystemOperationContext> context, | |
| 153 const fileapi::FileSystemURL& url, | |
| 154 const EnsureFileExistsCallback& callback) { | |
| 155 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 156 | |
| 157 base::FilePath file_path = util::ExtractDrivePathFromFileSystemUrl(url); | |
| 158 if (file_path.empty()) { | |
| 159 callback.Run(base::File::FILE_ERROR_NOT_FOUND, false); | |
| 160 return; | |
| 161 } | |
| 162 | |
| 163 PostFileSystemCallback( | |
| 164 file_system_getter_, | |
| 165 base::Bind(&fileapi_internal::CreateFile, | |
| 166 file_path, true /* is_exlusive */, | |
| 167 google_apis::CreateRelayCallback( | |
| 168 base::Bind(&RunEnsureFileExistsCallback, callback))), | |
| 169 base::Bind(callback, base::File::FILE_ERROR_FAILED, false)); | |
| 170 } | |
| 171 | |
| 172 void AsyncFileUtil::CreateDirectory( | |
| 173 scoped_ptr<fileapi::FileSystemOperationContext> context, | |
| 174 const fileapi::FileSystemURL& url, | |
| 175 bool exclusive, | |
| 176 bool recursive, | |
| 177 const StatusCallback& callback) { | |
| 178 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 179 | |
| 180 base::FilePath file_path = util::ExtractDrivePathFromFileSystemUrl(url); | |
| 181 if (file_path.empty()) { | |
| 182 callback.Run(base::File::FILE_ERROR_NOT_FOUND); | |
| 183 return; | |
| 184 } | |
| 185 | |
| 186 PostFileSystemCallback( | |
| 187 file_system_getter_, | |
| 188 base::Bind(&fileapi_internal::CreateDirectory, | |
| 189 file_path, exclusive, recursive, | |
| 190 google_apis::CreateRelayCallback(callback)), | |
| 191 base::Bind(callback, base::File::FILE_ERROR_FAILED)); | |
| 192 } | |
| 193 | |
| 194 void AsyncFileUtil::GetFileInfo( | |
| 195 scoped_ptr<fileapi::FileSystemOperationContext> context, | |
| 196 const fileapi::FileSystemURL& url, | |
| 197 const GetFileInfoCallback& callback) { | |
| 198 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 199 | |
| 200 base::FilePath file_path = util::ExtractDrivePathFromFileSystemUrl(url); | |
| 201 if (file_path.empty()) { | |
| 202 callback.Run(base::File::FILE_ERROR_NOT_FOUND, base::File::Info()); | |
| 203 return; | |
| 204 } | |
| 205 | |
| 206 PostFileSystemCallback( | |
| 207 file_system_getter_, | |
| 208 base::Bind(&fileapi_internal::GetFileInfo, | |
| 209 file_path, google_apis::CreateRelayCallback(callback)), | |
| 210 base::Bind(callback, base::File::FILE_ERROR_FAILED, | |
| 211 base::File::Info())); | |
| 212 } | |
| 213 | |
| 214 void AsyncFileUtil::ReadDirectory( | |
| 215 scoped_ptr<fileapi::FileSystemOperationContext> context, | |
| 216 const fileapi::FileSystemURL& url, | |
| 217 const ReadDirectoryCallback& callback) { | |
| 218 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 219 | |
| 220 base::FilePath file_path = util::ExtractDrivePathFromFileSystemUrl(url); | |
| 221 if (file_path.empty()) { | |
| 222 callback.Run(base::File::FILE_ERROR_NOT_FOUND, EntryList(), false); | |
| 223 return; | |
| 224 } | |
| 225 | |
| 226 PostFileSystemCallback( | |
| 227 file_system_getter_, | |
| 228 base::Bind(&fileapi_internal::ReadDirectory, | |
| 229 file_path, google_apis::CreateRelayCallback(callback)), | |
| 230 base::Bind(callback, base::File::FILE_ERROR_FAILED, | |
| 231 EntryList(), false)); | |
| 232 } | |
| 233 | |
| 234 void AsyncFileUtil::Touch( | |
| 235 scoped_ptr<fileapi::FileSystemOperationContext> context, | |
| 236 const fileapi::FileSystemURL& url, | |
| 237 const base::Time& last_access_time, | |
| 238 const base::Time& last_modified_time, | |
| 239 const StatusCallback& callback) { | |
| 240 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 241 | |
| 242 base::FilePath file_path = util::ExtractDrivePathFromFileSystemUrl(url); | |
| 243 if (file_path.empty()) { | |
| 244 callback.Run(base::File::FILE_ERROR_NOT_FOUND); | |
| 245 return; | |
| 246 } | |
| 247 | |
| 248 PostFileSystemCallback( | |
| 249 file_system_getter_, | |
| 250 base::Bind(&fileapi_internal::TouchFile, | |
| 251 file_path, last_access_time, last_modified_time, | |
| 252 google_apis::CreateRelayCallback(callback)), | |
| 253 base::Bind(callback, base::File::FILE_ERROR_FAILED)); | |
| 254 } | |
| 255 | |
| 256 void AsyncFileUtil::Truncate( | |
| 257 scoped_ptr<fileapi::FileSystemOperationContext> context, | |
| 258 const fileapi::FileSystemURL& url, | |
| 259 int64 length, | |
| 260 const StatusCallback& callback) { | |
| 261 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 262 | |
| 263 base::FilePath file_path = util::ExtractDrivePathFromFileSystemUrl(url); | |
| 264 if (file_path.empty()) { | |
| 265 callback.Run(base::File::FILE_ERROR_NOT_FOUND); | |
| 266 return; | |
| 267 } | |
| 268 | |
| 269 PostFileSystemCallback( | |
| 270 file_system_getter_, | |
| 271 base::Bind(&fileapi_internal::Truncate, | |
| 272 file_path, length, google_apis::CreateRelayCallback(callback)), | |
| 273 base::Bind(callback, base::File::FILE_ERROR_FAILED)); | |
| 274 } | |
| 275 | |
| 276 void AsyncFileUtil::CopyFileLocal( | |
| 277 scoped_ptr<fileapi::FileSystemOperationContext> context, | |
| 278 const fileapi::FileSystemURL& src_url, | |
| 279 const fileapi::FileSystemURL& dest_url, | |
| 280 CopyOrMoveOption option, | |
| 281 const CopyFileProgressCallback& progress_callback, | |
| 282 const StatusCallback& callback) { | |
| 283 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 284 | |
| 285 base::FilePath src_path = util::ExtractDrivePathFromFileSystemUrl(src_url); | |
| 286 base::FilePath dest_path = util::ExtractDrivePathFromFileSystemUrl(dest_url); | |
| 287 if (src_path.empty() || dest_path.empty()) { | |
| 288 callback.Run(base::File::FILE_ERROR_NOT_FOUND); | |
| 289 return; | |
| 290 } | |
| 291 | |
| 292 PostFileSystemCallback( | |
| 293 file_system_getter_, | |
| 294 base::Bind( | |
| 295 &fileapi_internal::Copy, | |
| 296 src_path, dest_path, | |
| 297 option == fileapi::FileSystemOperation::OPTION_PRESERVE_LAST_MODIFIED, | |
| 298 google_apis::CreateRelayCallback(callback)), | |
| 299 base::Bind(callback, base::File::FILE_ERROR_FAILED)); | |
| 300 } | |
| 301 | |
| 302 void AsyncFileUtil::MoveFileLocal( | |
| 303 scoped_ptr<fileapi::FileSystemOperationContext> context, | |
| 304 const fileapi::FileSystemURL& src_url, | |
| 305 const fileapi::FileSystemURL& dest_url, | |
| 306 CopyOrMoveOption option, | |
| 307 const StatusCallback& callback) { | |
| 308 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 309 | |
| 310 base::FilePath src_path = util::ExtractDrivePathFromFileSystemUrl(src_url); | |
| 311 base::FilePath dest_path = util::ExtractDrivePathFromFileSystemUrl(dest_url); | |
| 312 if (src_path.empty() || dest_path.empty()) { | |
| 313 callback.Run(base::File::FILE_ERROR_NOT_FOUND); | |
| 314 return; | |
| 315 } | |
| 316 | |
| 317 PostFileSystemCallback( | |
| 318 file_system_getter_, | |
| 319 base::Bind( | |
| 320 &fileapi_internal::Move, | |
| 321 src_path, dest_path, | |
| 322 option == fileapi::FileSystemOperation::OPTION_PRESERVE_LAST_MODIFIED, | |
| 323 google_apis::CreateRelayCallback(callback)), | |
| 324 base::Bind(callback, base::File::FILE_ERROR_FAILED)); | |
| 325 } | |
| 326 | |
| 327 void AsyncFileUtil::CopyInForeignFile( | |
| 328 scoped_ptr<fileapi::FileSystemOperationContext> context, | |
| 329 const base::FilePath& src_file_path, | |
| 330 const fileapi::FileSystemURL& dest_url, | |
| 331 const StatusCallback& callback) { | |
| 332 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 333 | |
| 334 base::FilePath dest_path = util::ExtractDrivePathFromFileSystemUrl(dest_url); | |
| 335 if (dest_path.empty()) { | |
| 336 callback.Run(base::File::FILE_ERROR_NOT_FOUND); | |
| 337 return; | |
| 338 } | |
| 339 | |
| 340 PostFileSystemCallback( | |
| 341 file_system_getter_, | |
| 342 base::Bind(&fileapi_internal::CopyInForeignFile, | |
| 343 src_file_path, dest_path, | |
| 344 google_apis::CreateRelayCallback(callback)), | |
| 345 base::Bind(callback, base::File::FILE_ERROR_FAILED)); | |
| 346 } | |
| 347 | |
| 348 void AsyncFileUtil::DeleteFile( | |
| 349 scoped_ptr<fileapi::FileSystemOperationContext> context, | |
| 350 const fileapi::FileSystemURL& url, | |
| 351 const StatusCallback& callback) { | |
| 352 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 353 | |
| 354 base::FilePath file_path = util::ExtractDrivePathFromFileSystemUrl(url); | |
| 355 if (file_path.empty()) { | |
| 356 callback.Run(base::File::FILE_ERROR_NOT_FOUND); | |
| 357 return; | |
| 358 } | |
| 359 | |
| 360 PostFileSystemCallback( | |
| 361 file_system_getter_, | |
| 362 base::Bind(&fileapi_internal::Remove, | |
| 363 file_path, false /* not recursive */, | |
| 364 google_apis::CreateRelayCallback(callback)), | |
| 365 base::Bind(callback, base::File::FILE_ERROR_FAILED)); | |
| 366 } | |
| 367 | |
| 368 void AsyncFileUtil::DeleteDirectory( | |
| 369 scoped_ptr<fileapi::FileSystemOperationContext> context, | |
| 370 const fileapi::FileSystemURL& url, | |
| 371 const StatusCallback& callback) { | |
| 372 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 373 | |
| 374 base::FilePath file_path = util::ExtractDrivePathFromFileSystemUrl(url); | |
| 375 if (file_path.empty()) { | |
| 376 callback.Run(base::File::FILE_ERROR_NOT_FOUND); | |
| 377 return; | |
| 378 } | |
| 379 | |
| 380 PostFileSystemCallback( | |
| 381 file_system_getter_, | |
| 382 base::Bind(&fileapi_internal::Remove, | |
| 383 file_path, false /* not recursive */, | |
| 384 google_apis::CreateRelayCallback(callback)), | |
| 385 base::Bind(callback, base::File::FILE_ERROR_FAILED)); | |
| 386 } | |
| 387 | |
| 388 void AsyncFileUtil::DeleteRecursively( | |
| 389 scoped_ptr<fileapi::FileSystemOperationContext> context, | |
| 390 const fileapi::FileSystemURL& url, | |
| 391 const StatusCallback& callback) { | |
| 392 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 393 | |
| 394 base::FilePath file_path = util::ExtractDrivePathFromFileSystemUrl(url); | |
| 395 if (file_path.empty()) { | |
| 396 callback.Run(base::File::FILE_ERROR_NOT_FOUND); | |
| 397 return; | |
| 398 } | |
| 399 | |
| 400 PostFileSystemCallback( | |
| 401 file_system_getter_, | |
| 402 base::Bind(&fileapi_internal::Remove, | |
| 403 file_path, true /* recursive */, | |
| 404 google_apis::CreateRelayCallback(callback)), | |
| 405 base::Bind(callback, base::File::FILE_ERROR_FAILED)); | |
| 406 } | |
| 407 | |
| 408 void AsyncFileUtil::CreateSnapshotFile( | |
| 409 scoped_ptr<fileapi::FileSystemOperationContext> context, | |
| 410 const fileapi::FileSystemURL& url, | |
| 411 const CreateSnapshotFileCallback& callback) { | |
| 412 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 413 | |
| 414 base::FilePath file_path = util::ExtractDrivePathFromFileSystemUrl(url); | |
| 415 if (file_path.empty()) { | |
| 416 callback.Run(base::File::FILE_ERROR_NOT_FOUND, | |
| 417 base::File::Info(), | |
| 418 base::FilePath(), | |
| 419 scoped_refptr<webkit_blob::ShareableFileReference>()); | |
| 420 return; | |
| 421 } | |
| 422 | |
| 423 PostFileSystemCallback( | |
| 424 file_system_getter_, | |
| 425 base::Bind(&fileapi_internal::CreateSnapshotFile, | |
| 426 file_path, | |
| 427 google_apis::CreateRelayCallback( | |
| 428 base::Bind(&RunCreateSnapshotFileCallback, callback))), | |
| 429 base::Bind(callback, | |
| 430 base::File::FILE_ERROR_FAILED, | |
| 431 base::File::Info(), | |
| 432 base::FilePath(), | |
| 433 scoped_refptr<webkit_blob::ShareableFileReference>())); | |
| 434 } | |
| 435 | |
| 436 } // namespace internal | |
| 437 } // namespace drive | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 148913005:
Create fileapi/ subdirectory under c/b/cros/drive. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src