Convert Media Galleries to use base::File

webkit/browser/fileapi/file_system_context.h

 // 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.
 
 #ifndef WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_CONTEXT_H_
 #define WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_CONTEXT_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
+#include "base/files/file.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
-#include "base/platform_file.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/open_file_system_mode.h"
 #include "webkit/browser/fileapi/plugin_private_file_system_backend.h"
 #include "webkit/browser/fileapi/sandbox_file_system_backend_delegate.h"
 #include "webkit/browser/fileapi/task_runner_bound_observer_list.h"
 #include "webkit/browser/webkit_storage_browser_export.h"
 #include "webkit/common/fileapi/file_system_types.h"
 
 namespace base {
@@ skipping 100 matching lines @@
   // it is not a quota-managed storage.
   FileSystemQuotaUtil* GetQuotaUtil(FileSystemType type) const;
 
   // Returns the appropriate AsyncFileUtil instance for the given |type|.
   AsyncFileUtil* GetAsyncFileUtil(FileSystemType type) const;
 
   // Returns the appropriate CopyOrMoveFileValidatorFactory for the given
   // |type|.  If |error_code| is PLATFORM_FILE_OK and the result is NULL,
   // then no validator is required.
   CopyOrMoveFileValidatorFactory* GetCopyOrMoveFileValidatorFactory(
-      FileSystemType type, base::PlatformFileError* error_code) const;
+      FileSystemType type, base::File::Error* error_code) const;
 
   // Returns the file system backend instance for the given |type|.
   // This may return NULL if it is given an invalid or unsupported filesystem
   // type.
   FileSystemBackend* GetFileSystemBackend(
       FileSystemType type) const;
 
   // Returns true for sandboxed filesystems. Currently this does
   // the same as GetQuotaUtil(type) != NULL. (In an assumption that
   // all sandboxed filesystems must cooperate with QuotaManager so that
   // they can get deleted)
   bool IsSandboxFileSystem(FileSystemType type) const;
 
   // Returns observers for the given filesystem type.
   const UpdateObserverList* GetUpdateObservers(FileSystemType type) const;
   const AccessObserverList* GetAccessObservers(FileSystemType type) const;
 
   // Returns all registered filesystem types.
   void GetFileSystemTypes(std::vector<FileSystemType>* types) const;
 
   // Returns a FileSystemBackend instance for external filesystem
   // type, which is used only by chromeos for now.  This is equivalent to
   // calling GetFileSystemBackend(kFileSystemTypeExternal).
   ExternalFileSystemBackend* external_backend() const;
 
   // Used for OpenFileSystem.
   typedef base::Callback<void(const GURL& root,
                               const std::string& name,
-                              base::PlatformFileError result)>
+                              base::File::Error result)>
       OpenFileSystemCallback;
 
   // Used for ResolveURL.
-  typedef base::Callback<void(base::PlatformFileError result,
+  typedef base::Callback<void(base::File::Error result,
                               const FileSystemInfo& info,
                               const base::FilePath& file_path,
                               bool is_directory)> ResolveURLCallback;
 
   // Used for DeleteFileSystem and OpenPluginPrivateFileSystem.
-  typedef base::Callback<void(base::PlatformFileError result)> StatusCallback;
+  typedef base::Callback<void(base::File::Error result)> StatusCallback;
 
   // Opens the filesystem for the given |origin_url| and |type|, and dispatches
   // |callback| on completion.
   // If |create| is true this may actually set up a filesystem instance
   // (e.g. by creating the root directory or initializing the database
   // entry etc).
   void OpenFileSystem(
       const GURL& origin_url,
       FileSystemType type,
       OpenFileSystemMode mode,
@@ skipping 102 matching lines @@
 
   // Creates a new FileSystemOperation instance by getting an appropriate
   // FileSystemBackend for |url| and calling the backend's corresponding
   // CreateFileSystemOperation method.
   // The resolved FileSystemBackend could perform further specialization
   // depending on the filesystem type pointed by the |url|.
   //
   // Called by FileSystemOperationRunner.
   FileSystemOperation* CreateFileSystemOperation(
       const FileSystemURL& url,
-      base::PlatformFileError* error_code);
+      base::File::Error* error_code);
 
   // For non-cracked isolated and external mount points, returns a FileSystemURL
   // created by cracking |url|. The url is cracked using MountPoints registered
   // as |url_crackers_|. If the url cannot be cracked, returns invalid
   // FileSystemURL.
   //
   // If the original url does not point to an isolated or external filesystem,
   // returns the original url, without attempting to crack it.
   FileSystemURL CrackFileSystemURL(const FileSystemURL& url) const;
 
   // For initial backend_map construction. This must be called only from
   // the constructor.
   void RegisterBackend(FileSystemBackend* backend);
 
   void DidOpenFileSystemForResolveURL(
       const FileSystemURL& url,
       const ResolveURLCallback& callback,
       const GURL& filesystem_root,
       const std::string& filesystem_name,
-      base::PlatformFileError error);
+      base::File::Error error);
 
   // Returns a FileSystemBackend, used only by test code.
   SandboxFileSystemBackend* sandbox_backend() const {
     return sandbox_backend_.get();
   }
 
   // Used only by test code.
   PluginPrivateFileSystemBackend* plugin_private_backend() const {
     return plugin_private_backend_.get();
   }
@@ skipping 41 matching lines @@
 
 struct DefaultContextDeleter {
   static void Destruct(const FileSystemContext* context) {
     context->DeleteOnCorrectThread();
   }
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_CONTEXT_H_