Convert Media Galleries to use base::File

webkit/browser/fileapi/plugin_private_file_system_backend.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/plugin_private_file_system_backend.h"
 
 #include <map>
 
 #include "base/stl_util.h"
 #include "base/synchronization/lock.h"
@@ skipping 48 matching lines @@
   Map map_;
 };
 
 namespace {
 
 const base::FilePath::CharType* kFileSystemDirectory =
     SandboxFileSystemBackendDelegate::kFileSystemDirectory;
 const base::FilePath::CharType* kPluginPrivateDirectory =
     FILE_PATH_LITERAL("Plugins");
 
-base::PlatformFileError OpenFileSystemOnFileTaskRunner(
+base::File::Error OpenFileSystemOnFileTaskRunner(
     ObfuscatedFileUtil* file_util,
     PluginPrivateFileSystemBackend::FileSystemIDToPluginMap* plugin_map,
     const GURL& origin_url,
     const std::string& filesystem_id,
     const std::string& plugin_id,
     OpenFileSystemMode mode) {
-  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error error = base::File::FILE_ERROR_FAILED;
   const bool create = (mode == OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT);
   file_util->GetDirectoryForOriginAndType(
       origin_url, plugin_id, create, &error);
-  if (error == base::PLATFORM_FILE_OK)
+  if (error == base::File::FILE_OK)
     plugin_map->RegisterFileSystem(filesystem_id, plugin_id);
   return error;
 }
 
 }  // namespace
 
 PluginPrivateFileSystemBackend::PluginPrivateFileSystemBackend(
     base::SequencedTaskRunner* file_task_runner,
     const base::FilePath& profile_path,
     quota::SpecialStoragePolicy* special_storage_policy,
@@ skipping 25 matching lines @@
 
 void PluginPrivateFileSystemBackend::OpenPrivateFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     const std::string& filesystem_id,
     const std::string& plugin_id,
     OpenFileSystemMode mode,
     const StatusCallback& callback) {
   if (!CanHandleType(type) || file_system_options_.is_incognito()) {
     base::MessageLoopProxy::current()->PostTask(
-        FROM_HERE, base::Bind(callback, base::PLATFORM_FILE_ERROR_SECURITY));
+        FROM_HERE, base::Bind(callback, base::File::FILE_ERROR_SECURITY));
     return;
   }
 
   PostTaskAndReplyWithResult(
       file_task_runner_.get(),
       FROM_HERE,
       base::Bind(&OpenFileSystemOnFileTaskRunner,
                  obfuscated_file_util(), plugin_map_,
                  origin_url, filesystem_id, plugin_id, mode),
       callback);
 }
 
 bool PluginPrivateFileSystemBackend::CanHandleType(FileSystemType type) const {
   return type == kFileSystemTypePluginPrivate;
 }
 
 void PluginPrivateFileSystemBackend::Initialize(FileSystemContext* context) {
 }
 
 void PluginPrivateFileSystemBackend::OpenFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     OpenFileSystemMode mode,
     const OpenFileSystemCallback& callback) {
   // We never allow opening a new plugin-private filesystem via usual
   // OpenFileSystem.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, GURL(), std::string(),
-                 base::PLATFORM_FILE_ERROR_SECURITY));
+                 base::File::FILE_ERROR_SECURITY));
 }
 
 AsyncFileUtil*
 PluginPrivateFileSystemBackend::GetAsyncFileUtil(FileSystemType type) {
   return file_util_.get();
 }
 
 CopyOrMoveFileValidatorFactory*
 PluginPrivateFileSystemBackend::GetCopyOrMoveFileValidatorFactory(
     FileSystemType type,
-    base::PlatformFileError* error_code) {
+    base::File::Error* error_code) {
   DCHECK(error_code);
-  *error_code = base::PLATFORM_FILE_OK;
+  *error_code = base::File::FILE_OK;
   return NULL;
 }
 
 FileSystemOperation* PluginPrivateFileSystemBackend::CreateFileSystemOperation(
     const FileSystemURL& url,
     FileSystemContext* context,
-    base::PlatformFileError* error_code) const {
+    base::File::Error* error_code) const {
   scoped_ptr<FileSystemOperationContext> operation_context(
       new FileSystemOperationContext(context));
   return FileSystemOperation::Create(url, context, operation_context.Pass());
 }
 
 scoped_ptr<webkit_blob::FileStreamReader>
 PluginPrivateFileSystemBackend::CreateFileStreamReader(
     const FileSystemURL& url,
     int64 offset,
     const base::Time& expected_modification_time,
     FileSystemContext* context) const {
   return scoped_ptr<webkit_blob::FileStreamReader>();
 }
 
 scoped_ptr<FileStreamWriter>
 PluginPrivateFileSystemBackend::CreateFileStreamWriter(
     const FileSystemURL& url,
     int64 offset,
     FileSystemContext* context) const {
   return scoped_ptr<FileStreamWriter>();
 }
 
 FileSystemQuotaUtil* PluginPrivateFileSystemBackend::GetQuotaUtil() {
   return this;
 }
 
-base::PlatformFileError
+base::File::Error
 PluginPrivateFileSystemBackend::DeleteOriginDataOnFileTaskRunner(
     FileSystemContext* context,
     quota::QuotaManagerProxy* proxy,
     const GURL& origin_url,
     FileSystemType type) {
   if (!CanHandleType(type))
-    return base::PLATFORM_FILE_ERROR_SECURITY;
+    return base::File::FILE_ERROR_SECURITY;
   bool result = obfuscated_file_util()->DeleteDirectoryForOriginAndType(
       origin_url, std::string());
   if (result)
-    return base::PLATFORM_FILE_OK;
-  return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_OK;
+  return base::File::FILE_ERROR_FAILED;
 }
 
 void PluginPrivateFileSystemBackend::GetOriginsForTypeOnFileTaskRunner(
     FileSystemType type,
     std::set<GURL>* origins) {
   if (!CanHandleType(type))
     return;
   scoped_ptr<ObfuscatedFileUtil::AbstractOriginEnumerator> enumerator(
       obfuscated_file_util()->CreateOriginEnumerator());
   GURL origin;
@@ skipping 62 matching lines @@
     FileSystemType type) const {
   return NULL;
 }
 
 ObfuscatedFileUtil* PluginPrivateFileSystemBackend::obfuscated_file_util() {
   return static_cast<ObfuscatedFileUtil*>(
       static_cast<AsyncFileUtilAdapter*>(file_util_.get())->sync_file_util());
 }
 
 }  // namespace fileapi