OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/media_galleries/fileapi/native_media_file_util.h" | 5 #include "chrome/browser/media_galleries/fileapi/native_media_file_util.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/file_util.h" | 8 #include "base/file_util.h" |
9 #include "base/string_util.h" | 9 #include "base/string_util.h" |
10 #include "base/task_runner_util.h" | 10 #include "base/task_runner_util.h" |
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
91 } | 91 } |
92 | 92 |
93 } // namespace | 93 } // namespace |
94 | 94 |
95 NativeMediaFileUtil::NativeMediaFileUtil() : weak_factory_(this) { | 95 NativeMediaFileUtil::NativeMediaFileUtil() : weak_factory_(this) { |
96 } | 96 } |
97 | 97 |
98 NativeMediaFileUtil::~NativeMediaFileUtil() { | 98 NativeMediaFileUtil::~NativeMediaFileUtil() { |
99 } | 99 } |
100 | 100 |
101 // static | |
vandebo (ex-Chrome)
2013/06/05 22:49:32
Same here - just reordering methods to be in the r
Lei Zhang
2013/06/06 03:48:47
Ok, maybe in a separate CL next time?
| |
102 base::PlatformFileError NativeMediaFileUtil::IsMediaFile( | |
103 const base::FilePath& path) { | |
104 base::PlatformFile file_handle; | |
105 const int flags = base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ; | |
106 base::PlatformFileError error = | |
107 fileapi::NativeFileUtil::CreateOrOpen(path, flags, &file_handle, NULL); | |
108 if (error != base::PLATFORM_FILE_OK) | |
109 return error; | |
110 | |
111 ScopedPlatformFile scoped_platform_file(&file_handle); | |
112 char buffer[net::kMaxBytesToSniff]; | |
113 | |
114 // Read as much as net::SniffMimeTypeFromLocalData() will bother looking at. | |
115 int64 len = | |
116 base::ReadPlatformFile(file_handle, 0, buffer, net::kMaxBytesToSniff); | |
117 if (len < 0) | |
118 return base::PLATFORM_FILE_ERROR_FAILED; | |
119 if (len == 0) | |
120 return base::PLATFORM_FILE_ERROR_SECURITY; | |
121 | |
122 std::string mime_type; | |
123 if (!net::SniffMimeTypeFromLocalData(buffer, len, &mime_type)) | |
124 return base::PLATFORM_FILE_ERROR_SECURITY; | |
125 | |
126 if (StartsWithASCII(mime_type, "image/", true) || | |
127 StartsWithASCII(mime_type, "audio/", true) || | |
128 StartsWithASCII(mime_type, "video/", true) || | |
129 mime_type == "application/x-shockwave-flash") { | |
130 return base::PLATFORM_FILE_OK; | |
131 } | |
132 return base::PLATFORM_FILE_ERROR_SECURITY; | |
133 } | |
134 | |
101 bool NativeMediaFileUtil::CreateOrOpen( | 135 bool NativeMediaFileUtil::CreateOrOpen( |
102 fileapi::FileSystemOperationContext* context, | 136 fileapi::FileSystemOperationContext* context, |
103 const fileapi::FileSystemURL& url, | 137 const fileapi::FileSystemURL& url, |
104 int file_flags, | 138 int file_flags, |
105 const CreateOrOpenCallback& callback) { | 139 const CreateOrOpenCallback& callback) { |
106 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); | 140 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); |
107 // Only called by NaCl, which should not have access to media file systems. | 141 // Only called by NaCl, which should not have access to media file systems. |
108 base::PlatformFile invalid_file(base::kInvalidPlatformFileValue); | 142 base::PlatformFile invalid_file(base::kInvalidPlatformFileValue); |
109 if (!callback.is_null()) { | 143 if (!callback.is_null()) { |
110 callback.Run(base::PLATFORM_FILE_ERROR_SECURITY, | 144 callback.Run(base::PLATFORM_FILE_ERROR_SECURITY, |
(...skipping 16 matching lines...) Expand all Loading... | |
127 bool NativeMediaFileUtil::CreateDirectory( | 161 bool NativeMediaFileUtil::CreateDirectory( |
128 fileapi::FileSystemOperationContext* context, | 162 fileapi::FileSystemOperationContext* context, |
129 const fileapi::FileSystemURL& url, | 163 const fileapi::FileSystemURL& url, |
130 bool exclusive, | 164 bool exclusive, |
131 bool recursive, | 165 bool recursive, |
132 const StatusCallback& callback) { | 166 const StatusCallback& callback) { |
133 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); | 167 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); |
134 return context->task_runner()->PostTask( | 168 return context->task_runner()->PostTask( |
135 FROM_HERE, | 169 FROM_HERE, |
136 base::Bind(&NativeMediaFileUtil::CreateDirectoryOnTaskRunnerThread, | 170 base::Bind(&NativeMediaFileUtil::CreateDirectoryOnTaskRunnerThread, |
137 weak_factory_.GetWeakPtr(), context, url, exclusive, | 171 weak_factory_.GetWeakPtr(), context, url, exclusive, recursive, |
138 recursive, callback)); | 172 callback)); |
139 } | 173 } |
140 | 174 |
141 bool NativeMediaFileUtil::GetFileInfo( | 175 bool NativeMediaFileUtil::GetFileInfo( |
142 fileapi::FileSystemOperationContext* context, | 176 fileapi::FileSystemOperationContext* context, |
143 const fileapi::FileSystemURL& url, | 177 const fileapi::FileSystemURL& url, |
144 const GetFileInfoCallback& callback) { | 178 const GetFileInfoCallback& callback) { |
145 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); | 179 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); |
146 return context->task_runner()->PostTask( | 180 return context->task_runner()->PostTask( |
147 FROM_HERE, | 181 FROM_HERE, |
148 base::Bind(&NativeMediaFileUtil::GetFileInfoOnTaskRunnerThread, | 182 base::Bind(&NativeMediaFileUtil::GetFileInfoOnTaskRunnerThread, |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
248 fileapi::FileSystemOperationContext* context, | 282 fileapi::FileSystemOperationContext* context, |
249 const fileapi::FileSystemURL& url, | 283 const fileapi::FileSystemURL& url, |
250 const CreateSnapshotFileCallback& callback) { | 284 const CreateSnapshotFileCallback& callback) { |
251 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); | 285 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); |
252 return context->task_runner()->PostTask( | 286 return context->task_runner()->PostTask( |
253 FROM_HERE, | 287 FROM_HERE, |
254 base::Bind(&NativeMediaFileUtil::CreateSnapshotFileOnTaskRunnerThread, | 288 base::Bind(&NativeMediaFileUtil::CreateSnapshotFileOnTaskRunnerThread, |
255 weak_factory_.GetWeakPtr(), context, url, callback)); | 289 weak_factory_.GetWeakPtr(), context, url, callback)); |
256 } | 290 } |
257 | 291 |
292 void NativeMediaFileUtil::CreateDirectoryOnTaskRunnerThread( | |
293 fileapi::FileSystemOperationContext* context, | |
294 const fileapi::FileSystemURL& url, | |
295 bool exclusive, | |
296 bool recursive, | |
297 const StatusCallback& callback) { | |
298 DCHECK(IsOnTaskRunnerThread(context)); | |
299 base::PlatformFileError error = | |
300 CreateDirectorySync(context, url, exclusive, recursive); | |
301 if (callback.is_null()) | |
302 return; | |
303 content::BrowserThread::PostTask( | |
304 content::BrowserThread::IO, | |
305 FROM_HERE, | |
306 base::Bind(callback, error)); | |
307 } | |
308 | |
309 void NativeMediaFileUtil::GetFileInfoOnTaskRunnerThread( | |
310 fileapi::FileSystemOperationContext* context, | |
311 const fileapi::FileSystemURL& url, | |
312 const GetFileInfoCallback& callback) { | |
313 DCHECK(IsOnTaskRunnerThread(context)); | |
314 base::PlatformFileInfo file_info; | |
315 base::FilePath platform_path; | |
316 base::PlatformFileError error = | |
317 GetFileInfoSync(context, url, &file_info, &platform_path); | |
318 if (callback.is_null()) | |
319 return; | |
320 content::BrowserThread::PostTask( | |
321 content::BrowserThread::IO, | |
322 FROM_HERE, | |
323 base::Bind(callback, error, file_info, platform_path)); | |
324 } | |
325 | |
326 void NativeMediaFileUtil::ReadDirectoryOnTaskRunnerThread( | |
327 fileapi::FileSystemOperationContext* context, | |
328 const fileapi::FileSystemURL& url, | |
329 const ReadDirectoryCallback& callback) { | |
330 DCHECK(IsOnTaskRunnerThread(context)); | |
331 EntryList entry_list; | |
332 base::PlatformFileError error = | |
333 ReadDirectorySync(context, url, &entry_list); | |
334 if (callback.is_null()) | |
335 return; | |
336 content::BrowserThread::PostTask( | |
337 content::BrowserThread::IO, | |
338 FROM_HERE, | |
339 base::Bind(callback, error, entry_list, false /* has_more */)); | |
340 } | |
341 | |
342 void NativeMediaFileUtil::CopyOrMoveFileLocalOnTaskRunnerThread( | |
343 fileapi::FileSystemOperationContext* context, | |
344 const fileapi::FileSystemURL& src_url, | |
345 const fileapi::FileSystemURL& dest_url, | |
346 bool copy, | |
347 const StatusCallback& callback) { | |
348 DCHECK(IsOnTaskRunnerThread(context)); | |
349 base::PlatformFileError error = | |
350 CopyOrMoveFileSync(context, src_url, dest_url, copy); | |
351 if (callback.is_null()) | |
352 return; | |
353 content::BrowserThread::PostTask( | |
354 content::BrowserThread::IO, | |
355 FROM_HERE, | |
356 base::Bind(callback, error)); | |
357 } | |
358 | |
359 void NativeMediaFileUtil::CopyInForeignFileOnTaskRunnerThread( | |
360 fileapi::FileSystemOperationContext* context, | |
361 const base::FilePath& src_file_path, | |
362 const fileapi::FileSystemURL& dest_url, | |
363 const StatusCallback& callback) { | |
364 DCHECK(IsOnTaskRunnerThread(context)); | |
365 base::PlatformFileError error = | |
366 CopyInForeignFileSync(context, src_file_path, dest_url); | |
367 if (callback.is_null()) | |
368 return; | |
369 content::BrowserThread::PostTask( | |
370 content::BrowserThread::IO, | |
371 FROM_HERE, | |
372 base::Bind(callback, error)); | |
373 } | |
374 | |
375 void NativeMediaFileUtil::DeleteDirectoryOnTaskRunnerThread( | |
376 fileapi::FileSystemOperationContext* context, | |
377 const fileapi::FileSystemURL& url, | |
378 const StatusCallback& callback) { | |
379 DCHECK(IsOnTaskRunnerThread(context)); | |
380 base::PlatformFileError error = DeleteDirectorySync(context, url); | |
381 if (callback.is_null()) | |
382 return; | |
383 content::BrowserThread::PostTask( | |
384 content::BrowserThread::IO, | |
385 FROM_HERE, | |
386 base::Bind(callback, error)); | |
387 } | |
388 | |
389 void NativeMediaFileUtil::CreateSnapshotFileOnTaskRunnerThread( | |
390 fileapi::FileSystemOperationContext* context, | |
391 const fileapi::FileSystemURL& url, | |
392 const CreateSnapshotFileCallback& callback) { | |
393 DCHECK(IsOnTaskRunnerThread(context)); | |
394 base::PlatformFileInfo file_info; | |
395 base::FilePath platform_path; | |
396 scoped_refptr<webkit_blob::ShareableFileReference> file_ref; | |
397 base::PlatformFileError error = | |
398 CreateSnapshotFileSync(context, url, &file_info, &platform_path, | |
399 &file_ref); | |
400 if (callback.is_null()) | |
401 return; | |
402 content::BrowserThread::PostTask( | |
403 content::BrowserThread::IO, | |
404 FROM_HERE, | |
405 base::Bind(callback, error, file_info, platform_path, file_ref)); | |
406 } | |
407 | |
258 base::PlatformFileError NativeMediaFileUtil::CreateDirectorySync( | 408 base::PlatformFileError NativeMediaFileUtil::CreateDirectorySync( |
259 fileapi::FileSystemOperationContext* context, | 409 fileapi::FileSystemOperationContext* context, |
260 const fileapi::FileSystemURL& url, | 410 const fileapi::FileSystemURL& url, |
261 bool exclusive, | 411 bool exclusive, |
262 bool recursive) { | 412 bool recursive) { |
263 base::FilePath file_path; | 413 base::FilePath file_path; |
264 base::PlatformFileError error = GetLocalFilePath(context, url, &file_path); | 414 base::PlatformFileError error = GetLocalFilePath(context, url, &file_path); |
265 if (error != base::PLATFORM_FILE_OK) | 415 if (error != base::PLATFORM_FILE_OK) |
266 return error; | 416 return error; |
267 return fileapi::NativeFileUtil::CreateDirectory(file_path, exclusive, | 417 return fileapi::NativeFileUtil::CreateDirectory(file_path, exclusive, |
268 recursive); | 418 recursive); |
269 } | 419 } |
270 | 420 |
271 base::PlatformFileError NativeMediaFileUtil::GetLocalFilePath( | |
272 fileapi::FileSystemOperationContext* context, | |
273 const fileapi::FileSystemURL& url, | |
274 base::FilePath* local_file_path) { | |
275 DCHECK(local_file_path); | |
276 DCHECK(url.is_valid()); | |
277 if (url.path().empty()) { | |
278 // Root direcory case, which should not be accessed. | |
279 return base::PLATFORM_FILE_ERROR_ACCESS_DENIED; | |
280 } | |
281 *local_file_path = url.path(); | |
282 return base::PLATFORM_FILE_OK; | |
283 } | |
284 | |
285 base::PlatformFileError NativeMediaFileUtil::ReadDirectorySync( | |
286 fileapi::FileSystemOperationContext* context, | |
287 const fileapi::FileSystemURL& url, | |
288 EntryList* file_list) { | |
289 DCHECK(IsOnTaskRunnerThread(context)); | |
290 DCHECK(file_list); | |
291 DCHECK(file_list->empty()); | |
292 base::PlatformFileInfo file_info; | |
293 base::FilePath platform_path; | |
294 base::PlatformFileError error = GetFileInfoSync(context, url, &file_info, | |
295 &platform_path); | |
296 | |
297 if (error != base::PLATFORM_FILE_OK) | |
298 return error; | |
299 | |
300 if (!file_info.is_directory) | |
301 return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY; | |
302 | |
303 file_util::FileEnumerator file_enum( | |
304 platform_path, | |
305 false /* recursive */, | |
306 file_util::FileEnumerator::FILES | | |
307 file_util::FileEnumerator::DIRECTORIES); | |
308 file_util::FileEnumerator::FindInfo file_util_info; | |
309 #if defined(OS_WIN) | |
310 memset(&file_util_info, 0, sizeof(file_util_info)); | |
311 #endif // defined(OS_WIN) | |
312 | |
313 for (base::FilePath platform_path = file_enum.Next(); | |
314 !platform_path.empty(); | |
315 platform_path = file_enum.Next()) { | |
316 // Skip symlinks. | |
317 if (file_util::IsLink(platform_path)) | |
318 continue; | |
319 | |
320 file_enum.GetFindInfo(&file_util_info); | |
321 | |
322 // NativeMediaFileUtil skip criteria. | |
323 if (ShouldSkip(platform_path)) | |
324 continue; | |
325 if (!file_util::FileEnumerator::IsDirectory(file_util_info) && | |
326 !GetMediaPathFilter(context)->Match(platform_path)) | |
327 continue; | |
328 | |
329 fileapi::DirectoryEntry entry; | |
330 entry.is_directory = file_util::FileEnumerator::IsDirectory(file_util_info); | |
331 entry.name = platform_path.BaseName().value(); | |
332 entry.size = file_util::FileEnumerator::GetFilesize(file_util_info); | |
333 entry.last_modified_time = | |
334 file_util::FileEnumerator::GetLastModifiedTime(file_util_info); | |
335 | |
336 file_list->push_back(entry); | |
337 } | |
338 | |
339 return base::PLATFORM_FILE_OK; | |
340 } | |
341 | |
342 base::PlatformFileError NativeMediaFileUtil::CopyOrMoveFileSync( | 421 base::PlatformFileError NativeMediaFileUtil::CopyOrMoveFileSync( |
343 fileapi::FileSystemOperationContext* context, | 422 fileapi::FileSystemOperationContext* context, |
344 const fileapi::FileSystemURL& src_url, | 423 const fileapi::FileSystemURL& src_url, |
345 const fileapi::FileSystemURL& dest_url, | 424 const fileapi::FileSystemURL& dest_url, |
346 bool copy) { | 425 bool copy) { |
347 DCHECK(IsOnTaskRunnerThread(context)); | 426 DCHECK(IsOnTaskRunnerThread(context)); |
348 base::FilePath src_file_path; | 427 base::FilePath src_file_path; |
349 base::PlatformFileError error = | 428 base::PlatformFileError error = |
350 GetFilteredLocalFilePathForExistingFileOrDirectory( | 429 GetFilteredLocalFilePathForExistingFileOrDirectory( |
351 context, src_url, | 430 context, src_url, |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
384 | 463 |
385 base::FilePath dest_file_path; | 464 base::FilePath dest_file_path; |
386 base::PlatformFileError error = | 465 base::PlatformFileError error = |
387 GetFilteredLocalFilePath(context, dest_url, &dest_file_path); | 466 GetFilteredLocalFilePath(context, dest_url, &dest_file_path); |
388 if (error != base::PLATFORM_FILE_OK) | 467 if (error != base::PLATFORM_FILE_OK) |
389 return error; | 468 return error; |
390 return fileapi::NativeFileUtil::CopyOrMoveFile(src_file_path, dest_file_path, | 469 return fileapi::NativeFileUtil::CopyOrMoveFile(src_file_path, dest_file_path, |
391 true); | 470 true); |
392 } | 471 } |
393 | 472 |
394 base::PlatformFileError NativeMediaFileUtil::GetFilteredLocalFilePath( | |
395 fileapi::FileSystemOperationContext* context, | |
396 const fileapi::FileSystemURL& file_system_url, | |
397 base::FilePath* local_file_path) { | |
398 DCHECK(IsOnTaskRunnerThread(context)); | |
399 base::FilePath file_path; | |
400 base::PlatformFileError error = | |
401 GetLocalFilePath(context, file_system_url, &file_path); | |
402 if (error != base::PLATFORM_FILE_OK) | |
403 return error; | |
404 if (!GetMediaPathFilter(context)->Match(file_path)) | |
405 return base::PLATFORM_FILE_ERROR_SECURITY; | |
406 | |
407 *local_file_path = file_path; | |
408 return base::PLATFORM_FILE_OK; | |
409 } | |
410 | |
411 base::PlatformFileError NativeMediaFileUtil::GetFileInfoSync( | 473 base::PlatformFileError NativeMediaFileUtil::GetFileInfoSync( |
412 fileapi::FileSystemOperationContext* context, | 474 fileapi::FileSystemOperationContext* context, |
413 const fileapi::FileSystemURL& url, | 475 const fileapi::FileSystemURL& url, |
414 base::PlatformFileInfo* file_info, | 476 base::PlatformFileInfo* file_info, |
415 base::FilePath* platform_path) { | 477 base::FilePath* platform_path) { |
416 DCHECK(IsOnTaskRunnerThread(context)); | 478 DCHECK(IsOnTaskRunnerThread(context)); |
417 DCHECK(context); | 479 DCHECK(context); |
418 DCHECK(file_info); | 480 DCHECK(file_info); |
419 DCHECK(GetMediaPathFilter(context)); | 481 DCHECK(GetMediaPathFilter(context)); |
420 | 482 |
421 base::FilePath file_path; | 483 base::FilePath file_path; |
422 base::PlatformFileError error = GetLocalFilePath(context, url, &file_path); | 484 base::PlatformFileError error = GetLocalFilePath(context, url, &file_path); |
423 if (error != base::PLATFORM_FILE_OK) | 485 if (error != base::PLATFORM_FILE_OK) |
424 return error; | 486 return error; |
425 if (file_util::IsLink(file_path)) | 487 if (file_util::IsLink(file_path)) |
426 return base::PLATFORM_FILE_ERROR_NOT_FOUND; | 488 return base::PLATFORM_FILE_ERROR_NOT_FOUND; |
427 error = fileapi::NativeFileUtil::GetFileInfo(file_path, file_info); | 489 error = fileapi::NativeFileUtil::GetFileInfo(file_path, file_info); |
428 if (error != base::PLATFORM_FILE_OK) | 490 if (error != base::PLATFORM_FILE_OK) |
429 return error; | 491 return error; |
430 | 492 |
431 if (platform_path) | 493 if (platform_path) |
432 *platform_path = file_path; | 494 *platform_path = file_path; |
433 if (file_info->is_directory || | 495 if (file_info->is_directory || |
434 GetMediaPathFilter(context)->Match(file_path)) { | 496 GetMediaPathFilter(context)->Match(file_path)) { |
435 return base::PLATFORM_FILE_OK; | 497 return base::PLATFORM_FILE_OK; |
436 } | 498 } |
437 return base::PLATFORM_FILE_ERROR_NOT_FOUND; | 499 return base::PLATFORM_FILE_ERROR_NOT_FOUND; |
438 } | 500 } |
439 | 501 |
440 base::PlatformFileError | 502 base::PlatformFileError NativeMediaFileUtil::GetLocalFilePath( |
441 NativeMediaFileUtil::GetFilteredLocalFilePathForExistingFileOrDirectory( | |
442 fileapi::FileSystemOperationContext* context, | 503 fileapi::FileSystemOperationContext* context, |
443 const fileapi::FileSystemURL& file_system_url, | 504 const fileapi::FileSystemURL& url, |
444 base::PlatformFileError failure_error, | |
445 base::FilePath* local_file_path) { | 505 base::FilePath* local_file_path) { |
506 DCHECK(local_file_path); | |
507 DCHECK(url.is_valid()); | |
508 if (url.path().empty()) { | |
509 // Root direcory case, which should not be accessed. | |
510 return base::PLATFORM_FILE_ERROR_ACCESS_DENIED; | |
511 } | |
512 *local_file_path = url.path(); | |
513 return base::PLATFORM_FILE_OK; | |
514 } | |
515 | |
516 base::PlatformFileError NativeMediaFileUtil::ReadDirectorySync( | |
517 fileapi::FileSystemOperationContext* context, | |
518 const fileapi::FileSystemURL& url, | |
519 EntryList* file_list) { | |
446 DCHECK(IsOnTaskRunnerThread(context)); | 520 DCHECK(IsOnTaskRunnerThread(context)); |
447 base::FilePath file_path; | 521 DCHECK(file_list); |
448 base::PlatformFileError error = | 522 DCHECK(file_list->empty()); |
449 GetLocalFilePath(context, file_system_url, &file_path); | 523 base::PlatformFileInfo file_info; |
524 base::FilePath platform_path; | |
525 base::PlatformFileError error = GetFileInfoSync(context, url, &file_info, | |
526 &platform_path); | |
527 | |
450 if (error != base::PLATFORM_FILE_OK) | 528 if (error != base::PLATFORM_FILE_OK) |
451 return error; | 529 return error; |
452 | 530 |
453 if (!file_util::PathExists(file_path)) | 531 if (!file_info.is_directory) |
454 return failure_error; | 532 return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY; |
455 base::PlatformFileInfo file_info; | |
456 if (!file_util::GetFileInfo(file_path, &file_info)) | |
457 return base::PLATFORM_FILE_ERROR_FAILED; | |
458 | 533 |
459 if (!file_info.is_directory && | 534 file_util::FileEnumerator file_enum( |
460 !GetMediaPathFilter(context)->Match(file_path)) { | 535 platform_path, |
461 return failure_error; | 536 false /* recursive */, |
537 file_util::FileEnumerator::FILES | | |
538 file_util::FileEnumerator::DIRECTORIES); | |
539 file_util::FileEnumerator::FindInfo file_util_info; | |
540 #if defined(OS_WIN) | |
541 memset(&file_util_info, 0, sizeof(file_util_info)); | |
542 #endif // defined(OS_WIN) | |
543 | |
544 for (base::FilePath platform_path = file_enum.Next(); | |
545 !platform_path.empty(); | |
546 platform_path = file_enum.Next()) { | |
547 // Skip symlinks. | |
548 if (file_util::IsLink(platform_path)) | |
549 continue; | |
550 | |
551 file_enum.GetFindInfo(&file_util_info); | |
552 | |
553 // NativeMediaFileUtil skip criteria. | |
554 if (ShouldSkip(platform_path)) | |
555 continue; | |
556 if (!file_util::FileEnumerator::IsDirectory(file_util_info) && | |
557 !GetMediaPathFilter(context)->Match(platform_path)) | |
558 continue; | |
559 | |
560 fileapi::DirectoryEntry entry; | |
561 entry.is_directory = file_util::FileEnumerator::IsDirectory(file_util_info); | |
562 entry.name = platform_path.BaseName().value(); | |
563 entry.size = file_util::FileEnumerator::GetFilesize(file_util_info); | |
564 entry.last_modified_time = | |
565 file_util::FileEnumerator::GetLastModifiedTime(file_util_info); | |
566 | |
567 file_list->push_back(entry); | |
462 } | 568 } |
463 | 569 |
464 *local_file_path = file_path; | |
465 return base::PLATFORM_FILE_OK; | 570 return base::PLATFORM_FILE_OK; |
466 } | 571 } |
467 | 572 |
468 base::PlatformFileError NativeMediaFileUtil::DeleteDirectorySync( | 573 base::PlatformFileError NativeMediaFileUtil::DeleteDirectorySync( |
469 fileapi::FileSystemOperationContext* context, | 574 fileapi::FileSystemOperationContext* context, |
470 const fileapi::FileSystemURL& url) { | 575 const fileapi::FileSystemURL& url) { |
471 DCHECK(IsOnTaskRunnerThread(context)); | 576 DCHECK(IsOnTaskRunnerThread(context)); |
472 base::FilePath file_path; | 577 base::FilePath file_path; |
473 base::PlatformFileError error = GetLocalFilePath(context, url, &file_path); | 578 base::PlatformFileError error = GetLocalFilePath(context, url, &file_path); |
474 if (error != base::PLATFORM_FILE_OK) | 579 if (error != base::PLATFORM_FILE_OK) |
(...skipping 14 matching lines...) Expand all Loading... | |
489 error = base::PLATFORM_FILE_ERROR_NOT_A_FILE; | 594 error = base::PLATFORM_FILE_ERROR_NOT_A_FILE; |
490 if (error == base::PLATFORM_FILE_OK) | 595 if (error == base::PLATFORM_FILE_OK) |
491 error = NativeMediaFileUtil::IsMediaFile(*platform_path); | 596 error = NativeMediaFileUtil::IsMediaFile(*platform_path); |
492 | 597 |
493 // We're just returning the local file information. | 598 // We're just returning the local file information. |
494 *file_ref = scoped_refptr<webkit_blob::ShareableFileReference>(); | 599 *file_ref = scoped_refptr<webkit_blob::ShareableFileReference>(); |
495 | 600 |
496 return error; | 601 return error; |
497 } | 602 } |
498 | 603 |
499 // static | 604 base::PlatformFileError NativeMediaFileUtil::GetFilteredLocalFilePath( |
500 base::PlatformFileError NativeMediaFileUtil::IsMediaFile( | 605 fileapi::FileSystemOperationContext* context, |
501 const base::FilePath& path) { | 606 const fileapi::FileSystemURL& file_system_url, |
502 base::PlatformFile file_handle; | 607 base::FilePath* local_file_path) { |
503 const int flags = base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ; | 608 DCHECK(IsOnTaskRunnerThread(context)); |
609 base::FilePath file_path; | |
504 base::PlatformFileError error = | 610 base::PlatformFileError error = |
505 fileapi::NativeFileUtil::CreateOrOpen(path, flags, &file_handle, NULL); | 611 GetLocalFilePath(context, file_system_url, &file_path); |
612 if (error != base::PLATFORM_FILE_OK) | |
613 return error; | |
614 if (!GetMediaPathFilter(context)->Match(file_path)) | |
615 return base::PLATFORM_FILE_ERROR_SECURITY; | |
616 | |
617 *local_file_path = file_path; | |
618 return base::PLATFORM_FILE_OK; | |
619 } | |
620 | |
621 base::PlatformFileError | |
622 NativeMediaFileUtil::GetFilteredLocalFilePathForExistingFileOrDirectory( | |
623 fileapi::FileSystemOperationContext* context, | |
624 const fileapi::FileSystemURL& file_system_url, | |
625 base::PlatformFileError failure_error, | |
626 base::FilePath* local_file_path) { | |
627 DCHECK(IsOnTaskRunnerThread(context)); | |
628 base::FilePath file_path; | |
629 base::PlatformFileError error = | |
630 GetLocalFilePath(context, file_system_url, &file_path); | |
506 if (error != base::PLATFORM_FILE_OK) | 631 if (error != base::PLATFORM_FILE_OK) |
507 return error; | 632 return error; |
508 | 633 |
509 ScopedPlatformFile scoped_platform_file(&file_handle); | 634 if (!file_util::PathExists(file_path)) |
510 char buffer[net::kMaxBytesToSniff]; | 635 return failure_error; |
636 base::PlatformFileInfo file_info; | |
637 if (!file_util::GetFileInfo(file_path, &file_info)) | |
638 return base::PLATFORM_FILE_ERROR_FAILED; | |
511 | 639 |
512 // Read as much as net::SniffMimeTypeFromLocalData() will bother looking at. | 640 if (!file_info.is_directory && |
513 int64 len = | 641 !GetMediaPathFilter(context)->Match(file_path)) { |
514 base::ReadPlatformFile(file_handle, 0, buffer, net::kMaxBytesToSniff); | 642 return failure_error; |
515 if (len < 0) | 643 } |
516 return base::PLATFORM_FILE_ERROR_FAILED; | |
517 if (len == 0) | |
518 return base::PLATFORM_FILE_ERROR_SECURITY; | |
519 | 644 |
520 std::string mime_type; | 645 *local_file_path = file_path; |
521 if (!net::SniffMimeTypeFromLocalData(buffer, len, &mime_type)) | 646 return base::PLATFORM_FILE_OK; |
522 return base::PLATFORM_FILE_ERROR_SECURITY; | |
523 | |
524 if (StartsWithASCII(mime_type, "image/", true) || | |
525 StartsWithASCII(mime_type, "audio/", true) || | |
526 StartsWithASCII(mime_type, "video/", true) || | |
527 mime_type == "application/x-shockwave-flash") { | |
528 return base::PLATFORM_FILE_OK; | |
529 } | |
530 return base::PLATFORM_FILE_ERROR_SECURITY; | |
531 } | |
532 | |
533 void NativeMediaFileUtil::CreateDirectoryOnTaskRunnerThread( | |
534 fileapi::FileSystemOperationContext* context, | |
535 const fileapi::FileSystemURL& url, | |
536 bool exclusive, | |
537 bool recursive, | |
538 const StatusCallback& callback) { | |
539 DCHECK(IsOnTaskRunnerThread(context)); | |
540 base::PlatformFileError error = | |
541 CreateDirectorySync(context, url, exclusive, recursive); | |
542 if (callback.is_null()) | |
543 return; | |
544 content::BrowserThread::PostTask( | |
545 content::BrowserThread::IO, | |
546 FROM_HERE, | |
547 base::Bind(callback, error)); | |
548 } | |
549 | |
550 void NativeMediaFileUtil::GetFileInfoOnTaskRunnerThread( | |
551 fileapi::FileSystemOperationContext* context, | |
552 const fileapi::FileSystemURL& url, | |
553 const GetFileInfoCallback& callback) { | |
554 DCHECK(IsOnTaskRunnerThread(context)); | |
555 base::PlatformFileInfo file_info; | |
556 base::FilePath platform_path; | |
557 base::PlatformFileError error = | |
558 GetFileInfoSync(context, url, &file_info, &platform_path); | |
559 if (callback.is_null()) | |
560 return; | |
561 content::BrowserThread::PostTask( | |
562 content::BrowserThread::IO, | |
563 FROM_HERE, | |
564 base::Bind(callback, error, file_info, platform_path)); | |
565 } | |
566 | |
567 void NativeMediaFileUtil::ReadDirectoryOnTaskRunnerThread( | |
568 fileapi::FileSystemOperationContext* context, | |
569 const fileapi::FileSystemURL& url, | |
570 const ReadDirectoryCallback& callback) { | |
571 DCHECK(IsOnTaskRunnerThread(context)); | |
572 EntryList entry_list; | |
573 base::PlatformFileError error = | |
574 ReadDirectorySync(context, url, &entry_list); | |
575 if (callback.is_null()) | |
576 return; | |
577 content::BrowserThread::PostTask( | |
578 content::BrowserThread::IO, | |
579 FROM_HERE, | |
580 base::Bind(callback, error, entry_list, false /* has_more */)); | |
581 } | |
582 | |
583 void NativeMediaFileUtil::CopyOrMoveFileLocalOnTaskRunnerThread( | |
584 fileapi::FileSystemOperationContext* context, | |
585 const fileapi::FileSystemURL& src_url, | |
586 const fileapi::FileSystemURL& dest_url, | |
587 bool copy, | |
588 const StatusCallback& callback) { | |
589 DCHECK(IsOnTaskRunnerThread(context)); | |
590 base::PlatformFileError error = | |
591 CopyOrMoveFileSync(context, src_url, dest_url, copy); | |
592 if (callback.is_null()) | |
593 return; | |
594 content::BrowserThread::PostTask( | |
595 content::BrowserThread::IO, | |
596 FROM_HERE, | |
597 base::Bind(callback, error)); | |
598 } | |
599 | |
600 void NativeMediaFileUtil::CopyInForeignFileOnTaskRunnerThread( | |
601 fileapi::FileSystemOperationContext* context, | |
602 const base::FilePath& src_file_path, | |
603 const fileapi::FileSystemURL& dest_url, | |
604 const StatusCallback& callback) { | |
605 DCHECK(IsOnTaskRunnerThread(context)); | |
606 base::PlatformFileError error = | |
607 CopyInForeignFileSync(context, src_file_path, dest_url); | |
608 if (callback.is_null()) | |
609 return; | |
610 content::BrowserThread::PostTask( | |
611 content::BrowserThread::IO, | |
612 FROM_HERE, | |
613 base::Bind(callback, error)); | |
614 } | |
615 | |
616 void NativeMediaFileUtil::DeleteDirectoryOnTaskRunnerThread( | |
617 fileapi::FileSystemOperationContext* context, | |
618 const fileapi::FileSystemURL& url, | |
619 const StatusCallback& callback) { | |
620 DCHECK(IsOnTaskRunnerThread(context)); | |
621 base::PlatformFileError error = DeleteDirectorySync(context, url); | |
622 if (callback.is_null()) | |
623 return; | |
624 content::BrowserThread::PostTask( | |
625 content::BrowserThread::IO, | |
626 FROM_HERE, | |
627 base::Bind(callback, error)); | |
628 } | |
629 | |
630 void NativeMediaFileUtil::CreateSnapshotFileOnTaskRunnerThread( | |
631 fileapi::FileSystemOperationContext* context, | |
632 const fileapi::FileSystemURL& url, | |
633 const CreateSnapshotFileCallback& callback) { | |
634 DCHECK(IsOnTaskRunnerThread(context)); | |
635 base::PlatformFileInfo file_info; | |
636 base::FilePath platform_path; | |
637 scoped_refptr<webkit_blob::ShareableFileReference> file_ref; | |
638 base::PlatformFileError error = | |
639 CreateSnapshotFileSync(context, url, &file_info, &platform_path, | |
640 &file_ref); | |
641 if (callback.is_null()) | |
642 return; | |
643 content::BrowserThread::PostTask( | |
644 content::BrowserThread::IO, | |
645 FROM_HERE, | |
646 base::Bind(callback, error, file_info, platform_path, file_ref)); | |
647 } | 647 } |
648 | 648 |
649 } // namespace chrome | 649 } // namespace chrome |
OLD | NEW |