Convert Media Galleries to use base::File

webkit/browser/fileapi/file_system_context.cc

 // Copyright (c) 2012 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_context.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
@@ skipping 29 matching lines @@
     FileSystemContext* context,
     bool is_incognito) {
   return new FileSystemQuotaClient(context, is_incognito);
 }
 
 
 void DidGetMetadataForResolveURL(
     const base::FilePath& path,
     const FileSystemContext::ResolveURLCallback& callback,
     const FileSystemInfo& info,
-    base::PlatformFileError error,
-    const base::PlatformFileInfo& file_info) {
-  if (error != base::PLATFORM_FILE_OK) {
+    base::File::Error error,
+    const base::File::Info& file_info) {
+  if (error != base::File::FILE_OK) {
     callback.Run(error, FileSystemInfo(), base::FilePath(), false);
     return;
   }
   callback.Run(error, info, path, file_info.is_directory);
 }
 
 }  // namespace
 
 // static
 int FileSystemContext::GetPermissionPolicy(FileSystemType type) {
@@ skipping 114 matching lines @@
 
   bool success = true;
   for (FileSystemBackendMap::iterator iter = backend_map_.begin();
        iter != backend_map_.end();
        ++iter) {
     FileSystemBackend* backend = iter->second;
     if (!backend->GetQuotaUtil())
       continue;
     if (backend->GetQuotaUtil()->DeleteOriginDataOnFileTaskRunner(
             this, quota_manager_proxy(), origin_url, iter->first)
-            != base::PLATFORM_FILE_OK) {
+            != base::File::FILE_OK) {
       // Continue the loop, but record the failure.
       success = false;
     }
   }
 
   return success;
 }
 
 scoped_refptr<QuotaReservation>
 FileSystemContext::CreateQuotaReservationOnFileTaskRunner(
@@ skipping 28 matching lines @@
 AsyncFileUtil* FileSystemContext::GetAsyncFileUtil(
     FileSystemType type) const {
   FileSystemBackend* backend = GetFileSystemBackend(type);
   if (!backend)
     return NULL;
   return backend->GetAsyncFileUtil(type);
 }
 
 CopyOrMoveFileValidatorFactory*
 FileSystemContext::GetCopyOrMoveFileValidatorFactory(
-    FileSystemType type, base::PlatformFileError* error_code) const {
+    FileSystemType type, base::File::Error* error_code) const {
   DCHECK(error_code);
-  *error_code = base::PLATFORM_FILE_OK;
+  *error_code = base::File::FILE_OK;
   FileSystemBackend* backend = GetFileSystemBackend(type);
   if (!backend)
     return NULL;
   return backend->GetCopyOrMoveFileValidatorFactory(
       type, error_code);
 }
 
 FileSystemBackend* FileSystemContext::GetFileSystemBackend(
     FileSystemType type) const {
   FileSystemBackendMap::const_iterator found = backend_map_.find(type);
@@ skipping 41 matching lines @@
 void FileSystemContext::OpenFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     OpenFileSystemMode mode,
     const OpenFileSystemCallback& callback) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!callback.is_null());
 
   if (!FileSystemContext::IsSandboxFileSystem(type)) {
     // Disallow opening a non-sandboxed filesystem.
-    callback.Run(GURL(), std::string(), base::PLATFORM_FILE_ERROR_SECURITY);
+    callback.Run(GURL(), std::string(), base::File::FILE_ERROR_SECURITY);
     return;
   }
 
   FileSystemBackend* backend = GetFileSystemBackend(type);
   if (!backend) {
-    callback.Run(GURL(), std::string(), base::PLATFORM_FILE_ERROR_SECURITY);
+    callback.Run(GURL(), std::string(), base::File::FILE_ERROR_SECURITY);
     return;
   }
 
   backend->OpenFileSystem(origin_url, type, mode, callback);
 }
 
 void FileSystemContext::ResolveURL(
     const FileSystemURL& url,
     const ResolveURLCallback& callback) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!callback.is_null());
 
   if (!FileSystemContext::IsSandboxFileSystem(url.type())) {
 #ifdef OS_CHROMEOS
     // Do not have to open a non-sandboxed filesystem.
     // TODO(nhiroki): For now we assume this path is called only on ChromeOS,
     // but this assumption may be broken in the future and we should handle
     // more generally. http://crbug.com/304062.
     FileSystemInfo info = GetFileSystemInfoForChromeOS(url.origin());
     DidOpenFileSystemForResolveURL(
-        url, callback, info.root_url, info.name, base::PLATFORM_FILE_OK);
+        url, callback, info.root_url, info.name, base::File::FILE_OK);
     return;
 #endif
-    callback.Run(base::PLATFORM_FILE_ERROR_SECURITY,
+    callback.Run(base::File::FILE_ERROR_SECURITY,
                  FileSystemInfo(), base::FilePath(), false);
     return;
   }
 
   FileSystemBackend* backend = GetFileSystemBackend(url.type());
   if (!backend) {
-    callback.Run(base::PLATFORM_FILE_ERROR_SECURITY,
+    callback.Run(base::File::FILE_ERROR_SECURITY,
                  FileSystemInfo(), base::FilePath(), false);
     return;
   }
 
   backend->OpenFileSystem(
       url.origin(), url.type(),
       OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
       base::Bind(&FileSystemContext::DidOpenFileSystemForResolveURL,
                  this, url, callback));
 }
 
 void FileSystemContext::DeleteFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     const StatusCallback& callback) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(origin_url == origin_url.GetOrigin());
   DCHECK(!callback.is_null());
 
   FileSystemBackend* backend = GetFileSystemBackend(type);
   if (!backend) {
-    callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
+    callback.Run(base::File::FILE_ERROR_SECURITY);
     return;
   }
   if (!backend->GetQuotaUtil()) {
-    callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
+    callback.Run(base::File::FILE_ERROR_INVALID_OPERATION);
     return;
   }
 
   base::PostTaskAndReplyWithResult(
       default_file_task_runner(),
       FROM_HERE,
       // It is safe to pass Unretained(quota_util) since context owns it.
       base::Bind(&FileSystemQuotaUtil::DeleteOriginDataOnFileTaskRunner,
                  base::Unretained(backend->GetQuotaUtil()),
                  make_scoped_refptr(this),
@@ skipping 80 matching lines @@
 
 void FileSystemContext::DeleteOnCorrectThread() const {
   if (!io_task_runner_->RunsTasksOnCurrentThread() &&
       io_task_runner_->DeleteSoon(FROM_HERE, this)) {
     return;
   }
   delete this;
 }
 
 FileSystemOperation* FileSystemContext::CreateFileSystemOperation(
-    const FileSystemURL& url, base::PlatformFileError* error_code) {
+    const FileSystemURL& url, base::File::Error* error_code) {
   if (!url.is_valid()) {
     if (error_code)
-      *error_code = base::PLATFORM_FILE_ERROR_INVALID_URL;
+      *error_code = base::File::FILE_ERROR_INVALID_URL;
     return NULL;
   }
 
   FileSystemBackend* backend = GetFileSystemBackend(url.type());
   if (!backend) {
     if (error_code)
-      *error_code = base::PLATFORM_FILE_ERROR_FAILED;
+      *error_code = base::File::FILE_ERROR_FAILED;
     return NULL;
   }
 
-  base::PlatformFileError fs_error = base::PLATFORM_FILE_OK;
+  base::File::Error fs_error = base::File::FILE_OK;
   FileSystemOperation* operation =
       backend->CreateFileSystemOperation(url, this, &fs_error);
 
   if (error_code)
     *error_code = fs_error;
   return operation;
 }
 
 FileSystemURL FileSystemContext::CrackFileSystemURL(
     const FileSystemURL& url) const {
@@ skipping 47 matching lines @@
       DCHECK(inserted);
     }
   }
 }
 
 void FileSystemContext::DidOpenFileSystemForResolveURL(
     const FileSystemURL& url,
     const FileSystemContext::ResolveURLCallback& callback,
     const GURL& filesystem_root,
     const std::string& filesystem_name,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
-  if (error != base::PLATFORM_FILE_OK) {
+  if (error != base::File::FILE_OK) {
     callback.Run(error, FileSystemInfo(), base::FilePath(), false);
     return;
   }
 
   fileapi::FileSystemInfo info(
       filesystem_name, filesystem_root, url.mount_type());
 
   // Extract the virtual path not containing a filesystem type part from |url|.
   base::FilePath parent = CrackURL(filesystem_root).virtual_path();
   base::FilePath child = url.virtual_path();
   base::FilePath path;
 
   if (parent.empty()) {
     path = child;
   } else if (parent != child) {
     bool result = parent.AppendRelativePath(child, &path);
     DCHECK(result);
   }
 
   operation_runner()->GetMetadata(
       url, base::Bind(&DidGetMetadataForResolveURL, path, callback, info));
 }
 
 }  // namespace fileapi