Convert Media Galleries to use base::File

webkit/browser/fileapi/file_system_operation_impl.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/browser/fileapi/file_system_operation_impl.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
@@ skipping 32 matching lines @@
 }
 
 void FileSystemOperationImpl::CreateFile(const FileSystemURL& url,
                                          bool exclusive,
                                          const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCreateFile));
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&FileSystemOperationImpl::DoCreateFile,
                  weak_factory_.GetWeakPtr(), url, callback, exclusive),
-      base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
+      base::Bind(callback, base::File::FILE_ERROR_FAILED));
 }
 
 void FileSystemOperationImpl::CreateDirectory(const FileSystemURL& url,
                                               bool exclusive,
                                               bool recursive,
                                               const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCreateDirectory));
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&FileSystemOperationImpl::DoCreateDirectory,
                  weak_factory_.GetWeakPtr(), url, callback,
                  exclusive, recursive),
-      base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
+      base::Bind(callback, base::File::FILE_ERROR_FAILED));
 }
 
 void FileSystemOperationImpl::Copy(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const CopyProgressCallback& progress_callback,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCopy));
   DCHECK(!recursive_operation_delegate_);
@@ skipping 98 matching lines @@
                  weak_factory_.GetWeakPtr(), url, callback));
 }
 
 void FileSystemOperationImpl::Truncate(const FileSystemURL& url, int64 length,
                                        const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTruncate));
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&FileSystemOperationImpl::DoTruncate,
                  weak_factory_.GetWeakPtr(), url, callback, length),
-      base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
+      base::Bind(callback, base::File::FILE_ERROR_FAILED));
 }
 
 void FileSystemOperationImpl::TouchFile(const FileSystemURL& url,
                                         const base::Time& last_access_time,
                                         const base::Time& last_modified_time,
                                         const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTouchFile));
   async_file_util_->Touch(
       operation_context_.Pass(), url,
       last_access_time, last_modified_time,
       base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::OpenFile(const FileSystemURL& url,
                                        int file_flags,
                                        const OpenFileCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationOpenFile));
 
   if (file_flags &
       (base::PLATFORM_FILE_TEMPORARY | base::PLATFORM_FILE_HIDDEN)) {
-    callback.Run(base::PLATFORM_FILE_ERROR_FAILED,
+    callback.Run(base::File::FILE_ERROR_FAILED,
                  base::kInvalidPlatformFileValue,
                  base::Closure());
     return;
   }
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&FileSystemOperationImpl::DoOpenFile,
                  weak_factory_.GetWeakPtr(),
                  url, callback, file_flags),
-      base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED,
+      base::Bind(callback, base::File::FILE_ERROR_FAILED,
                  base::kInvalidPlatformFileValue,
                  base::Closure()));
 }
 
 // We can only get here on a write or truncate that's not yet completed.
 // We don't support cancelling any other operation at this time.
 void FileSystemOperationImpl::Cancel(const StatusCallback& cancel_callback) {
   DCHECK(cancel_callback_.is_null());
   cancel_callback_ = cancel_callback;
 
@@ skipping 22 matching lines @@
 void FileSystemOperationImpl::CopyInForeignFile(
     const base::FilePath& src_local_disk_file_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCopyInForeignFile));
   GetUsageAndQuotaThenRunTask(
       dest_url,
       base::Bind(&FileSystemOperationImpl::DoCopyInForeignFile,
                  weak_factory_.GetWeakPtr(), src_local_disk_file_path, dest_url,
                  callback),
-      base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
+      base::Bind(callback, base::File::FILE_ERROR_FAILED));
 }
 
 void FileSystemOperationImpl::RemoveFile(
     const FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationRemove));
   async_file_util_->DeleteFile(
       operation_context_.Pass(), url,
       base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                  weak_factory_.GetWeakPtr(), callback));
@@ skipping 16 matching lines @@
     const CopyFileProgressCallback& progress_callback,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCopy));
   DCHECK(src_url.IsInSameFileSystem(dest_url));
 
   GetUsageAndQuotaThenRunTask(
       dest_url,
       base::Bind(&FileSystemOperationImpl::DoCopyFileLocal,
                  weak_factory_.GetWeakPtr(), src_url, dest_url, option,
                  progress_callback, callback),
-      base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
+      base::Bind(callback, base::File::FILE_ERROR_FAILED));
 }
 
 void FileSystemOperationImpl::MoveFileLocal(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationMove));
   DCHECK(src_url.IsInSameFileSystem(dest_url));
   GetUsageAndQuotaThenRunTask(
       dest_url,
       base::Bind(&FileSystemOperationImpl::DoMoveFileLocal,
                  weak_factory_.GetWeakPtr(),
                  src_url, dest_url, option, callback),
-      base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
+      base::Bind(callback, base::File::FILE_ERROR_FAILED));
 }
 
-base::PlatformFileError FileSystemOperationImpl::SyncGetPlatformPath(
+base::File::Error FileSystemOperationImpl::SyncGetPlatformPath(
     const FileSystemURL& url,
     base::FilePath* platform_path) {
   DCHECK(SetPendingOperationType(kOperationGetLocalPath));
   if (!file_system_context()->IsSandboxFileSystem(url.type()))
-    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+    return base::File::FILE_ERROR_INVALID_OPERATION;
   FileSystemFileUtil* file_util =
       file_system_context()->sandbox_delegate()->sync_file_util();
   file_util->GetLocalFilePath(operation_context_.get(), url, platform_path);
-  return base::PLATFORM_FILE_OK;
+  return base::File::FILE_OK;
 }
 
 FileSystemOperationImpl::FileSystemOperationImpl(
     const FileSystemURL& url,
     FileSystemContext* file_system_context,
     scoped_ptr<FileSystemOperationContext> operation_context)
     : file_system_context_(file_system_context),
       operation_context_(operation_context.Pass()),
       async_file_util_(NULL),
       pending_operation_(kOperationNone),
@@ skipping 114 matching lines @@
                                          const OpenFileCallback& callback,
                                          int file_flags) {
   async_file_util_->CreateOrOpen(
       operation_context_.Pass(), url, file_flags,
       base::Bind(&FileSystemOperationImpl::DidOpenFile,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::DidEnsureFileExistsExclusive(
     const StatusCallback& callback,
-    base::PlatformFileError rv, bool created) {
-  if (rv == base::PLATFORM_FILE_OK && !created) {
-    callback.Run(base::PLATFORM_FILE_ERROR_EXISTS);
+    base::File::Error rv, bool created) {
+  if (rv == base::File::FILE_OK && !created) {
+    callback.Run(base::File::FILE_ERROR_EXISTS);
   } else {
     DidFinishOperation(callback, rv);
   }
 }
 
 void FileSystemOperationImpl::DidEnsureFileExistsNonExclusive(
     const StatusCallback& callback,
-    base::PlatformFileError rv, bool /* created */) {
+    base::File::Error rv, bool /* created */) {
   DidFinishOperation(callback, rv);
 }
 
 void FileSystemOperationImpl::DidFinishOperation(
     const StatusCallback& callback,
-    base::PlatformFileError rv) {
+    base::File::Error rv) {
   if (!cancel_callback_.is_null()) {
     StatusCallback cancel_callback = cancel_callback_;
     callback.Run(rv);
 
     // Return OK only if we succeeded to stop the operation.
-    cancel_callback.Run(rv == base::PLATFORM_FILE_ERROR_ABORT ?
-                        base::PLATFORM_FILE_OK :
-                        base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
+    cancel_callback.Run(rv == base::File::FILE_ERROR_ABORT ?
+                        base::File::FILE_OK :
+                        base::File::FILE_ERROR_INVALID_OPERATION);
   } else {
     callback.Run(rv);
   }
 }
 
 void FileSystemOperationImpl::DidDirectoryExists(
     const StatusCallback& callback,
-    base::PlatformFileError rv,
-    const base::PlatformFileInfo& file_info) {
-  if (rv == base::PLATFORM_FILE_OK && !file_info.is_directory)
-    rv = base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
+    base::File::Error rv,
+    const base::File::Info& file_info) {
+  if (rv == base::File::FILE_OK && !file_info.is_directory)
+    rv = base::File::FILE_ERROR_NOT_A_DIRECTORY;
   callback.Run(rv);
 }
 
 void FileSystemOperationImpl::DidFileExists(
     const StatusCallback& callback,
-    base::PlatformFileError rv,
-    const base::PlatformFileInfo& file_info) {
-  if (rv == base::PLATFORM_FILE_OK && file_info.is_directory)
-    rv = base::PLATFORM_FILE_ERROR_NOT_A_FILE;
+    base::File::Error rv,
+    const base::File::Info& file_info) {
+  if (rv == base::File::FILE_OK && file_info.is_directory)
+    rv = base::File::FILE_ERROR_NOT_A_FILE;
   callback.Run(rv);
 }
 
 void FileSystemOperationImpl::DidDeleteRecursively(
     const FileSystemURL& url,
     const StatusCallback& callback,
-    base::PlatformFileError rv) {
-  if (rv == base::PLATFORM_FILE_ERROR_INVALID_OPERATION) {
+    base::File::Error rv) {
+  if (rv == base::File::FILE_ERROR_INVALID_OPERATION) {
     // Recursive removal is not supported on this platform.
     DCHECK(!recursive_operation_delegate_);
     recursive_operation_delegate_.reset(
         new RemoveOperationDelegate(
             file_system_context(), url,
             base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                        weak_factory_.GetWeakPtr(), callback)));
     recursive_operation_delegate_->RunRecursively();
     return;
   }
 
   callback.Run(rv);
 }
 
 void FileSystemOperationImpl::DidWrite(
     const FileSystemURL& url,
     const WriteCallback& write_callback,
-    base::PlatformFileError rv,
+    base::File::Error rv,
     int64 bytes,
     FileWriterDelegate::WriteProgressStatus write_status) {
   const bool complete = (
       write_status != FileWriterDelegate::SUCCESS_IO_PENDING);
   if (complete && write_status != FileWriterDelegate::ERROR_WRITE_NOT_STARTED) {
     DCHECK(operation_context_);
     operation_context_->change_observers()->Notify(
         &FileChangeObserver::OnModifyFile, MakeTuple(url));
   }
 
   StatusCallback cancel_callback = cancel_callback_;
   write_callback.Run(rv, bytes, complete);
   if (!cancel_callback.is_null())
-    cancel_callback.Run(base::PLATFORM_FILE_OK);
+    cancel_callback.Run(base::File::FILE_OK);
 }
 
 void FileSystemOperationImpl::DidOpenFile(
     const OpenFileCallback& callback,
-    base::PlatformFileError rv,
+    base::File::Error rv,
     base::PassPlatformFile file,
     const base::Closure& on_close_callback) {
   callback.Run(rv, file.ReleaseValue(), on_close_callback);
 }
 
 bool FileSystemOperationImpl::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace fileapi