Convert Media Galleries to use base::File

Unfortunately, this brings in changes to webkit/browser/fileapi, and once
that changes, a lot of files have to be updated.

The bright side is that most of the collateral changes are just trivial
renaming of PlatformFileError -> File::Error and PlatformFileInfo ->
File::Info

BUG=322664

Review URL: https://codereview.chromium.org/145303002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@247301 0039d316-1c4b-4281-b951-d872f2087c98

64 files changed, 1011 insertions, 1030 deletions

diff --git a/webkit/browser/fileapi/async_file_test_helper.cc b/webkit/browser/fileapi/async_file_test_helper.cc
index 50fd7cd..0e88298 100644
--- a/webkit/browser/fileapi/async_file_test_helper.cc
+++ b/webkit/browser/fileapi/async_file_test_helper.cc
@@ -22,23 +22,23 @@ namespace {
 typedef FileSystemOperation::FileEntryList FileEntryList;
 
 void AssignAndQuit(base::RunLoop* run_loop,
-                   base::PlatformFileError* result_out,
-                   base::PlatformFileError result) {
+                   base::File::Error* result_out,
+                   base::File::Error result) {
   *result_out = result;
   run_loop->Quit();
 }
 
-base::Callback<void(base::PlatformFileError)>
+base::Callback<void(base::File::Error)>
 AssignAndQuitCallback(base::RunLoop* run_loop,
-                      base::PlatformFileError* result) {
+                      base::File::Error* result) {
   return base::Bind(&AssignAndQuit, run_loop, base::Unretained(result));
 }
 
 void GetMetadataCallback(base::RunLoop* run_loop,
-                         base::PlatformFileError* result_out,
-                         base::PlatformFileInfo* file_info_out,
-                         base::PlatformFileError result,
-                         const base::PlatformFileInfo& file_info) {
+                         base::File::Error* result_out,
+                         base::File::Info* file_info_out,
+                         base::File::Error result,
+                         const base::File::Info& file_info) {
   *result_out = result;
   if (file_info_out)
     *file_info_out = file_info;
@@ -47,10 +47,10 @@ void GetMetadataCallback(base::RunLoop* run_loop,
 
 void CreateSnapshotFileCallback(
     base::RunLoop* run_loop,
-    base::PlatformFileError* result_out,
+    base::File::Error* result_out,
     base::FilePath* platform_path_out,
-    base::PlatformFileError result,
-    const base::PlatformFileInfo& file_info,
+    base::File::Error result,
+    const base::File::Info& file_info,
     const base::FilePath& platform_path,
     const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
   DCHECK(!file_ref.get());
@@ -61,14 +61,14 @@ void CreateSnapshotFileCallback(
 }
 
 void ReadDirectoryCallback(base::RunLoop* run_loop,
-                           base::PlatformFileError* result_out,
+                           base::File::Error* result_out,
                            FileEntryList* entries_out,
-                           base::PlatformFileError result,
+                           base::File::Error result,
                            const FileEntryList& entries,
                            bool has_more) {
   *result_out = result;
   *entries_out = entries;
-  if (result != base::PLATFORM_FILE_OK || !has_more)
+  if (result != base::File::FILE_OK || !has_more)
     run_loop->Quit();
 }
 
@@ -90,19 +90,19 @@ void DidGetUsageAndQuota(quota::QuotaStatusCode* status_out,
 
 const int64 AsyncFileTestHelper::kDontCheckSize = -1;
 
-base::PlatformFileError AsyncFileTestHelper::Copy(
+base::File::Error AsyncFileTestHelper::Copy(
     FileSystemContext* context,
     const FileSystemURL& src,
     const FileSystemURL& dest) {
   return CopyWithProgress(context, src, dest, CopyProgressCallback());
 }
 
-base::PlatformFileError AsyncFileTestHelper::CopyWithProgress(
+base::File::Error AsyncFileTestHelper::CopyWithProgress(
     FileSystemContext* context,
     const FileSystemURL& src,
     const FileSystemURL& dest,
     const CopyProgressCallback& progress_callback) {
-  base::PlatformFileError result = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error result = base::File::FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   context->operation_runner()->Copy(
       src, dest, FileSystemOperation::OPTION_NONE, progress_callback,
@@ -111,11 +111,11 @@ base::PlatformFileError AsyncFileTestHelper::CopyWithProgress(
   return result;
 }
 
-base::PlatformFileError AsyncFileTestHelper::Move(
+base::File::Error AsyncFileTestHelper::Move(
     FileSystemContext* context,
     const FileSystemURL& src,
     const FileSystemURL& dest) {
-  base::PlatformFileError result = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error result = base::File::FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   context->operation_runner()->Move(
       src, dest, FileSystemOperation::OPTION_NONE,
@@ -124,11 +124,11 @@ base::PlatformFileError AsyncFileTestHelper::Move(
   return result;
 }
 
-base::PlatformFileError AsyncFileTestHelper::Remove(
+base::File::Error AsyncFileTestHelper::Remove(
     FileSystemContext* context,
     const FileSystemURL& url,
     bool recursive) {
-  base::PlatformFileError result = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error result = base::File::FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   context->operation_runner()->Remove(
       url, recursive, AssignAndQuitCallback(&run_loop, &result));
@@ -136,11 +136,11 @@ base::PlatformFileError AsyncFileTestHelper::Remove(
   return result;
 }
 
-base::PlatformFileError AsyncFileTestHelper::ReadDirectory(
+base::File::Error AsyncFileTestHelper::ReadDirectory(
     FileSystemContext* context,
     const FileSystemURL& url,
     FileEntryList* entries) {
-  base::PlatformFileError result = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error result = base::File::FILE_ERROR_FAILED;
   DCHECK(entries);
   entries->clear();
   base::RunLoop run_loop;
@@ -150,10 +150,10 @@ base::PlatformFileError AsyncFileTestHelper::ReadDirectory(
   return result;
 }
 
-base::PlatformFileError AsyncFileTestHelper::CreateDirectory(
+base::File::Error AsyncFileTestHelper::CreateDirectory(
     FileSystemContext* context,
     const FileSystemURL& url) {
-  base::PlatformFileError result = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error result = base::File::FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   context->operation_runner()->CreateDirectory(
       url,
@@ -164,10 +164,10 @@ base::PlatformFileError AsyncFileTestHelper::CreateDirectory(
   return result;
 }
 
-base::PlatformFileError AsyncFileTestHelper::CreateFile(
+base::File::Error AsyncFileTestHelper::CreateFile(
     FileSystemContext* context,
     const FileSystemURL& url) {
-  base::PlatformFileError result = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error result = base::File::FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   context->operation_runner()->CreateFile(
       url, false /* exclusive */,
@@ -176,18 +176,18 @@ base::PlatformFileError AsyncFileTestHelper::CreateFile(
   return result;
 }
 
-base::PlatformFileError AsyncFileTestHelper::CreateFileWithData(
+base::File::Error AsyncFileTestHelper::CreateFileWithData(
     FileSystemContext* context,
     const FileSystemURL& url,
     const char* buf,
     int buf_size) {
   base::ScopedTempDir dir;
   if (!dir.CreateUniqueTempDir())
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
   base::FilePath local_path = dir.path().AppendASCII("tmp");
   if (buf_size != file_util::WriteFile(local_path, buf, buf_size))
-    return base::PLATFORM_FILE_ERROR_FAILED;
-  base::PlatformFileError result = base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
+  base::File::Error result = base::File::FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   context->operation_runner()->CopyInForeignFile(
       local_path, url, AssignAndQuitCallback(&run_loop, &result));
@@ -195,23 +195,23 @@ base::PlatformFileError AsyncFileTestHelper::CreateFileWithData(
   return result;
 }
 
-base::PlatformFileError AsyncFileTestHelper::TruncateFile(
+base::File::Error AsyncFileTestHelper::TruncateFile(
     FileSystemContext* context,
     const FileSystemURL& url,
     size_t size) {
   base::RunLoop run_loop;
-  base::PlatformFileError result = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error result = base::File::FILE_ERROR_FAILED;
   context->operation_runner()->Truncate(
       url, size, AssignAndQuitCallback(&run_loop, &result));
   run_loop.Run();
   return result;
 }
 
-base::PlatformFileError AsyncFileTestHelper::GetMetadata(
+base::File::Error AsyncFileTestHelper::GetMetadata(
     FileSystemContext* context,
     const FileSystemURL& url,
-    base::PlatformFileInfo* file_info) {
-  base::PlatformFileError result = base::PLATFORM_FILE_ERROR_FAILED;
+    base::File::Info* file_info) {
+  base::File::Error result = base::File::FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   context->operation_runner()->GetMetadata(
       url, base::Bind(&GetMetadataCallback, &run_loop, &result,
@@ -220,11 +220,11 @@ base::PlatformFileError AsyncFileTestHelper::GetMetadata(
   return result;
 }
 
-base::PlatformFileError AsyncFileTestHelper::GetPlatformPath(
+base::File::Error AsyncFileTestHelper::GetPlatformPath(
     FileSystemContext* context,
     const FileSystemURL& url,
     base::FilePath* platform_path) {
-  base::PlatformFileError result = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error result = base::File::FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   context->operation_runner()->CreateSnapshotFile(
       url, base::Bind(&CreateSnapshotFileCallback, &run_loop, &result,
@@ -237,9 +237,9 @@ bool AsyncFileTestHelper::FileExists(
     FileSystemContext* context,
     const FileSystemURL& url,
     int64 expected_size) {
-  base::PlatformFileInfo file_info;
-  base::PlatformFileError result = GetMetadata(context, url, &file_info);
-  if (result != base::PLATFORM_FILE_OK || file_info.is_directory)
+  base::File::Info file_info;
+  base::File::Error result = GetMetadata(context, url, &file_info);
+  if (result != base::File::FILE_OK || file_info.is_directory)
     return false;
   return expected_size == kDontCheckSize || file_info.size == expected_size;
 }
@@ -247,9 +247,9 @@ bool AsyncFileTestHelper::FileExists(
 bool AsyncFileTestHelper::DirectoryExists(
     FileSystemContext* context,
     const FileSystemURL& url) {
-  base::PlatformFileInfo file_info;
-  base::PlatformFileError result = GetMetadata(context, url, &file_info);
-  return (result == base::PLATFORM_FILE_OK) && file_info.is_directory;
+  base::File::Info file_info;
+  base::File::Error result = GetMetadata(context, url, &file_info);
+  return (result == base::File::FILE_OK) && file_info.is_directory;
 }
 
 quota::QuotaStatusCode AsyncFileTestHelper::GetUsageAndQuota(
diff --git a/webkit/browser/fileapi/async_file_test_helper.h b/webkit/browser/fileapi/async_file_test_helper.h
index 168400f..fc2c95e 100644
--- a/webkit/browser/fileapi/async_file_test_helper.h
+++ b/webkit/browser/fileapi/async_file_test_helper.h
@@ -28,61 +28,61 @@ class AsyncFileTestHelper {
   static const int64 kDontCheckSize;
 
   // Performs Copy from |src| to |dest| and returns the status code.
-  static base::PlatformFileError Copy(FileSystemContext* context,
-                                      const FileSystemURL& src,
-                                      const FileSystemURL& dest);
+  static base::File::Error Copy(FileSystemContext* context,
+                                const FileSystemURL& src,
+                                const FileSystemURL& dest);
 
   // Same as Copy, but this supports |progress_callback|.
-  static base::PlatformFileError CopyWithProgress(
+  static base::File::Error CopyWithProgress(
       FileSystemContext* context,
       const FileSystemURL& src,
       const FileSystemURL& dest,
       const CopyProgressCallback& progress_callback);
 
   // Performs Move from |src| to |dest| and returns the status code.
-  static base::PlatformFileError Move(FileSystemContext* context,
-                                      const FileSystemURL& src,
-                                      const FileSystemURL& dest);
+  static base::File::Error Move(FileSystemContext* context,
+                                const FileSystemURL& src,
+                                const FileSystemURL& dest);
 
   // Removes the given |url|.
-  static base::PlatformFileError Remove(FileSystemContext* context,
-                                        const FileSystemURL& url,
+  static base::File::Error Remove(FileSystemContext* context,
+                                  const FileSystemURL& url,
                                         bool recursive);
 
   // Performs ReadDirectory on |url|.
-  static base::PlatformFileError ReadDirectory(FileSystemContext* context,
-                                               const FileSystemURL& url,
-                                               FileEntryList* entries);
+  static base::File::Error ReadDirectory(FileSystemContext* context,
+                                         const FileSystemURL& url,
+                                         FileEntryList* entries);
 
   // Creates a directory at |url|.
-  static base::PlatformFileError CreateDirectory(FileSystemContext* context,
-                                                 const FileSystemURL& url);
+  static base::File::Error CreateDirectory(FileSystemContext* context,
+                                           const FileSystemURL& url);
 
   // Creates a file at |url|.
-  static base::PlatformFileError CreateFile(FileSystemContext* context,
-                                            const FileSystemURL& url);
+  static base::File::Error CreateFile(FileSystemContext* context,
+                                      const FileSystemURL& url);
 
   // Creates a file at |url| and fills with |buf|.
-  static base::PlatformFileError CreateFileWithData(
+  static base::File::Error CreateFileWithData(
       FileSystemContext* context,
       const FileSystemURL& url,
       const char* buf,
       int buf_size);
 
   // Truncates the file |url| to |size|.
-  static base::PlatformFileError TruncateFile(FileSystemContext* context,
-                                              const FileSystemURL& url,
-                                              size_t size);
+  static base::File::Error TruncateFile(FileSystemContext* context,
+                                        const FileSystemURL& url,
+                                        size_t size);
 
-  // Retrieves PlatformFileInfo for |url| and populates |file_info|.
-  static base::PlatformFileError GetMetadata(FileSystemContext* context,
-                                             const FileSystemURL& url,
-                                             base::PlatformFileInfo* file_info);
+  // Retrieves File::Info for |url| and populates |file_info|.
+  static base::File::Error GetMetadata(FileSystemContext* context,
+                                       const FileSystemURL& url,
+                                       base::File::Info* file_info);
 
   // Retrieves FilePath for |url| and populates |platform_path|.
-  static base::PlatformFileError GetPlatformPath(FileSystemContext* context,
-                                                 const FileSystemURL& url,
-                                                 base::FilePath* platform_path);
+  static base::File::Error GetPlatformPath(FileSystemContext* context,
+                                           const FileSystemURL& url,
+                                           base::FilePath* platform_path);
 
   // Returns true if a file exists at |url| with |size|. If |size| is
   // kDontCheckSize it doesn't check the file size (but just check its
diff --git a/webkit/browser/fileapi/async_file_util.h b/webkit/browser/fileapi/async_file_util.h
index c1e6d1e..0e91341 100644
--- a/webkit/browser/fileapi/async_file_util.h
+++ b/webkit/browser/fileapi/async_file_util.h
@@ -9,6 +9,7 @@
 
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
+#include "base/files/file.h"
 #include "base/files/file_util_proxy.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
@@ -47,34 +48,33 @@ class FileSystemURL;
 //
 class AsyncFileUtil {
  public:
-  typedef base::Callback<
-      void(base::PlatformFileError result)> StatusCallback;
+  typedef base::Callback<void(base::File::Error result)> StatusCallback;
 
   // |on_close_callback| will be called after the |file| is closed in the
   // child process. |on_close_callback|.is_null() can be true, if no operation
   // is needed on closing the file.
   typedef base::Callback<
-      void(base::PlatformFileError result,
+      void(base::File::Error result,
            base::PassPlatformFile file,
            const base::Closure& on_close_callback)> CreateOrOpenCallback;
 
   typedef base::Callback<
-      void(base::PlatformFileError result,
+      void(base::File::Error result,
            bool created)> EnsureFileExistsCallback;
 
   typedef base::Callback<
-      void(base::PlatformFileError result,
-           const base::PlatformFileInfo& file_info)> GetFileInfoCallback;
+      void(base::File::Error result,
+           const base::File::Info& file_info)> GetFileInfoCallback;
 
   typedef std::vector<DirectoryEntry> EntryList;
   typedef base::Callback<
-      void(base::PlatformFileError result,
+      void(base::File::Error result,
            const EntryList& file_list,
            bool has_more)> ReadDirectoryCallback;
 
   typedef base::Callback<
-      void(base::PlatformFileError result,
-           const base::PlatformFileInfo& file_info,
+      void(base::File::Error result,
+           const base::File::Info& file_info,
            const base::FilePath& platform_path,
            const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref)>
       CreateSnapshotFileCallback;
diff --git a/webkit/browser/fileapi/async_file_util_adapter.cc b/webkit/browser/fileapi/async_file_util_adapter.cc
index b25ddf2..6950002 100644
--- a/webkit/browser/fileapi/async_file_util_adapter.cc
+++ b/webkit/browser/fileapi/async_file_util_adapter.cc
@@ -19,7 +19,6 @@
 using base::Bind;
 using base::Callback;
 using base::Owned;
-using base::PlatformFileError;
 using base::Unretained;
 using webkit_blob::ShareableFileReference;
 
@@ -29,7 +28,7 @@ namespace {
 
 class EnsureFileExistsHelper {
  public:
-  EnsureFileExistsHelper() : error_(base::PLATFORM_FILE_OK), created_(false) {}
+  EnsureFileExistsHelper() : error_(base::File::FILE_OK), created_(false) {}
 
   void RunWork(FileSystemFileUtil* file_util,
                FileSystemOperationContext* context,
@@ -42,7 +41,7 @@ class EnsureFileExistsHelper {
   }
 
  private:
-  base::PlatformFileError error_;
+  base::File::Error error_;
   bool created_;
   DISALLOW_COPY_AND_ASSIGN(EnsureFileExistsHelper);
 };
@@ -50,7 +49,7 @@ class EnsureFileExistsHelper {
 class GetFileInfoHelper {
  public:
   GetFileInfoHelper()
-      : error_(base::PLATFORM_FILE_OK) {}
+      : error_(base::File::FILE_OK) {}
 
   void GetFileInfo(FileSystemFileUtil* file_util,
                    FileSystemOperationContext* context,
@@ -76,8 +75,8 @@ class GetFileInfoHelper {
   }
 
  private:
-  base::PlatformFileError error_;
-  base::PlatformFileInfo file_info_;
+  base::File::Error error_;
+  base::File::Info file_info_;
   base::FilePath platform_path_;
   webkit_blob::ScopedFile scoped_file_;
   DISALLOW_COPY_AND_ASSIGN(GetFileInfoHelper);
@@ -85,21 +84,21 @@ class GetFileInfoHelper {
 
 class ReadDirectoryHelper {
  public:
-  ReadDirectoryHelper() : error_(base::PLATFORM_FILE_OK) {}
+  ReadDirectoryHelper() : error_(base::File::FILE_OK) {}
 
   void RunWork(FileSystemFileUtil* file_util,
                FileSystemOperationContext* context,
                const FileSystemURL& url) {
-    base::PlatformFileInfo file_info;
+    base::File::Info file_info;
     base::FilePath platform_path;
-    PlatformFileError error = file_util->GetFileInfo(
+    base::File::Error error = file_util->GetFileInfo(
         context, url, &file_info, &platform_path);
-    if (error != base::PLATFORM_FILE_OK) {
+    if (error != base::File::FILE_OK) {
       error_ = error;
       return;
     }
     if (!file_info.is_directory) {
-      error_ = base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
+      error_ = base::File::FILE_ERROR_NOT_A_DIRECTORY;
       return;
     }
 
@@ -115,7 +114,7 @@ class ReadDirectoryHelper {
       entry.last_modified_time = file_enum->LastModifiedTime();
       entries_.push_back(entry);
     }
-    error_ = base::PLATFORM_FILE_OK;
+    error_ = base::File::FILE_OK;
   }
 
   void Reply(const AsyncFileUtil::ReadDirectoryCallback& callback) {
@@ -123,14 +122,14 @@ class ReadDirectoryHelper {
   }
 
  private:
-  base::PlatformFileError error_;
+  base::File::Error error_;
   std::vector<DirectoryEntry> entries_;
   DISALLOW_COPY_AND_ASSIGN(ReadDirectoryHelper);
 };
 
 void RunCreateOrOpenCallback(
     const AsyncFileUtil::CreateOrOpenCallback& callback,
-    base::PlatformFileError result,
+    base::File::Error result,
     base::PassPlatformFile file,
     bool created) {
   callback.Run(result, file, base::Closure());
@@ -332,7 +331,7 @@ void AsyncFileUtilAdapter::DeleteRecursively(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const StatusCallback& callback) {
-  callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
+  callback.Run(base::File::FILE_ERROR_INVALID_OPERATION);
 }
 
 void AsyncFileUtilAdapter::CreateSnapshotFile(
diff --git a/webkit/browser/fileapi/copy_or_move_file_validator.h b/webkit/browser/fileapi/copy_or_move_file_validator.h
index 2bd4df1..d497409 100644
--- a/webkit/browser/fileapi/copy_or_move_file_validator.h
+++ b/webkit/browser/fileapi/copy_or_move_file_validator.h
@@ -6,7 +6,7 @@
 #define WEBKIT_BROWSER_FILEAPI_COPY_OR_MOVE_FILE_VALIDATOR_H_
 
 #include "base/callback.h"
-#include "base/platform_file.h"
+#include "base/files/file.h"
 #include "webkit/browser/webkit_storage_browser_export.h"
 
 namespace base {
@@ -21,7 +21,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT CopyOrMoveFileValidator {
  public:
   // Callback that is invoked when validation completes. A result of
   // base::PLATFORM_FILE_OK means the file validated.
-  typedef base::Callback<void(base::PlatformFileError result)> ResultCallback;
+  typedef base::Callback<void(base::File::Error result)> ResultCallback;
 
   virtual ~CopyOrMoveFileValidator() {}
 
diff --git a/webkit/browser/fileapi/copy_or_move_operation_delegate.cc b/webkit/browser/fileapi/copy_or_move_operation_delegate.cc
index 66f32fd..699e3e3 100644
--- a/webkit/browser/fileapi/copy_or_move_operation_delegate.cc
+++ b/webkit/browser/fileapi/copy_or_move_operation_delegate.cc
@@ -128,14 +128,14 @@ class SnapshotCopyOrMoveImpl
  private:
   void RunAfterCreateSnapshot(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
-      base::PlatformFileError error,
-      const base::PlatformFileInfo& file_info,
+      base::File::Error error,
+      const base::File::Info& file_info,
       const base::FilePath& platform_path,
       const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
     if (cancel_requested_)
-      error = base::PLATFORM_FILE_ERROR_ABORT;
+      error = base::File::FILE_ERROR_ABORT;
 
-    if (error != base::PLATFORM_FILE_OK) {
+    if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
@@ -147,7 +147,7 @@ class SnapshotCopyOrMoveImpl
     if (!validator_factory_) {
       // No validation is needed.
       RunAfterPreWriteValidation(platform_path, file_info, file_ref, callback,
-                                 base::PLATFORM_FILE_OK);
+                                 base::File::FILE_OK);
       return;
     }
 
@@ -161,14 +161,14 @@ class SnapshotCopyOrMoveImpl
 
   void RunAfterPreWriteValidation(
       const base::FilePath& platform_path,
-      const base::PlatformFileInfo& file_info,
+      const base::File::Info& file_info,
       const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref,
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
-      base::PlatformFileError error) {
+      base::File::Error error) {
     if (cancel_requested_)
-      error = base::PLATFORM_FILE_ERROR_ABORT;
+      error = base::File::FILE_ERROR_ABORT;
 
-    if (error != base::PLATFORM_FILE_OK) {
+    if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
@@ -182,14 +182,14 @@ class SnapshotCopyOrMoveImpl
   }
 
   void RunAfterCopyInForeignFile(
-      const base::PlatformFileInfo& file_info,
+      const base::File::Info& file_info,
       const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref,
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
-      base::PlatformFileError error) {
+      base::File::Error error) {
     if (cancel_requested_)
-      error = base::PLATFORM_FILE_ERROR_ABORT;
+      error = base::File::FILE_ERROR_ABORT;
 
-    if (error != base::PLATFORM_FILE_OK) {
+    if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
@@ -197,7 +197,7 @@ class SnapshotCopyOrMoveImpl
     file_progress_callback_.Run(file_info.size);
 
     if (option_ == FileSystemOperation::OPTION_NONE) {
-      RunAfterTouchFile(callback, base::PLATFORM_FILE_OK);
+      RunAfterTouchFile(callback, base::File::FILE_OK);
       return;
     }
 
@@ -210,11 +210,11 @@ class SnapshotCopyOrMoveImpl
 
   void RunAfterTouchFile(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
-      base::PlatformFileError error) {
+      base::File::Error error) {
     // Even if TouchFile is failed, just ignore it.
 
     if (cancel_requested_) {
-      callback.Run(base::PLATFORM_FILE_ERROR_ABORT);
+      callback.Run(base::File::FILE_ERROR_ABORT);
       return;
     }
 
@@ -222,7 +222,7 @@ class SnapshotCopyOrMoveImpl
     // validation.
     if (!validator_) {
       // No validation is needed.
-      RunAfterPostWriteValidation(callback, base::PLATFORM_FILE_OK);
+      RunAfterPostWriteValidation(callback, base::File::FILE_OK);
       return;
     }
 
@@ -233,13 +233,13 @@ class SnapshotCopyOrMoveImpl
 
   void RunAfterPostWriteValidation(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
-      base::PlatformFileError error) {
+      base::File::Error error) {
     if (cancel_requested_) {
-      callback.Run(base::PLATFORM_FILE_ERROR_ABORT);
+      callback.Run(base::File::FILE_ERROR_ABORT);
       return;
     }
 
-    if (error != base::PLATFORM_FILE_OK) {
+    if (error != base::File::FILE_OK) {
       // Failed to validate. Remove the destination file.
       operation_runner_->Remove(
           dest_url_, true /* recursive */,
@@ -249,7 +249,7 @@ class SnapshotCopyOrMoveImpl
     }
 
     if (operation_type_ == CopyOrMoveOperationDelegate::OPERATION_COPY) {
-      callback.Run(base::PLATFORM_FILE_OK);
+      callback.Run(base::File::FILE_OK);
       return;
     }
 
@@ -264,20 +264,20 @@ class SnapshotCopyOrMoveImpl
 
   void RunAfterRemoveSourceForMove(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
-      base::PlatformFileError error) {
+      base::File::Error error) {
     if (cancel_requested_)
-      error = base::PLATFORM_FILE_ERROR_ABORT;
+      error = base::File::FILE_ERROR_ABORT;
 
-    if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND)
-      error = base::PLATFORM_FILE_OK;
+    if (error == base::File::FILE_ERROR_NOT_FOUND)
+      error = base::File::FILE_OK;
     callback.Run(error);
   }
 
   void DidRemoveDestForError(
-      base::PlatformFileError prior_error,
+      base::File::Error prior_error,
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
-      base::PlatformFileError error) {
-    if (error != base::PLATFORM_FILE_OK) {
+      base::File::Error error) {
+    if (error != base::File::FILE_OK) {
       VLOG(1) << "Error removing destination file after validation error: "
               << error;
     }
@@ -307,14 +307,14 @@ class SnapshotCopyOrMoveImpl
 
   void PostWriteValidationAfterCreateSnapshotFile(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
-      base::PlatformFileError error,
-      const base::PlatformFileInfo& file_info,
+      base::File::Error error,
+      const base::File::Info& file_info,
       const base::FilePath& platform_path,
       const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
     if (cancel_requested_)
-      error = base::PLATFORM_FILE_ERROR_ABORT;
+      error = base::File::FILE_ERROR_ABORT;
 
-    if (error != base::PLATFORM_FILE_OK) {
+    if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
@@ -333,7 +333,7 @@ class SnapshotCopyOrMoveImpl
   void DidPostWriteValidation(
       const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref,
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
-      base::PlatformFileError error) {
+      base::File::Error error) {
     callback.Run(error);
   }
 
@@ -406,19 +406,19 @@ class StreamCopyOrMoveImpl
  private:
   void RunAfterGetMetadataForSource(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
-      base::PlatformFileError error,
-      const base::PlatformFileInfo& file_info) {
+      base::File::Error error,
+      const base::File::Info& file_info) {
     if (cancel_requested_)
-      error = base::PLATFORM_FILE_ERROR_ABORT;
+      error = base::File::FILE_ERROR_ABORT;
 
-    if (error != base::PLATFORM_FILE_OK) {
+    if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
 
     if (file_info.is_directory) {
       // If not a directory, failed with appropriate error code.
-      callback.Run(base::PLATFORM_FILE_ERROR_NOT_A_FILE);
+      callback.Run(base::File::FILE_ERROR_NOT_A_FILE);
       return;
     }
 
@@ -433,11 +433,11 @@ class StreamCopyOrMoveImpl
   void RunAfterCreateFileForDestination(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
       const base::Time& last_modified,
-      base::PlatformFileError error) {
+      base::File::Error error) {
     if (cancel_requested_)
-      error = base::PLATFORM_FILE_ERROR_ABORT;
+      error = base::File::FILE_ERROR_ABORT;
 
-    if (error != base::PLATFORM_FILE_OK) {
+    if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
@@ -462,17 +462,17 @@ class StreamCopyOrMoveImpl
   void RunAfterStreamCopy(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
       const base::Time& last_modified,
-      base::PlatformFileError error) {
+      base::File::Error error) {
     if (cancel_requested_)
-      error = base::PLATFORM_FILE_ERROR_ABORT;
+      error = base::File::FILE_ERROR_ABORT;
 
-    if (error != base::PLATFORM_FILE_OK) {
+    if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
 
     if (option_ == FileSystemOperation::OPTION_NONE) {
-      RunAfterTouchFile(callback, base::PLATFORM_FILE_OK);
+      RunAfterTouchFile(callback, base::File::FILE_OK);
       return;
     }
 
@@ -484,15 +484,15 @@ class StreamCopyOrMoveImpl
 
   void RunAfterTouchFile(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
-      base::PlatformFileError error) {
+      base::File::Error error) {
     // Even if TouchFile is failed, just ignore it.
     if (cancel_requested_) {
-      callback.Run(base::PLATFORM_FILE_ERROR_ABORT);
+      callback.Run(base::File::FILE_ERROR_ABORT);
       return;
     }
 
     if (operation_type_ == CopyOrMoveOperationDelegate::OPERATION_COPY) {
-      callback.Run(base::PLATFORM_FILE_OK);
+      callback.Run(base::File::FILE_OK);
       return;
     }
 
@@ -507,11 +507,11 @@ class StreamCopyOrMoveImpl
 
   void RunAfterRemoveForMove(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
-      base::PlatformFileError error) {
+      base::File::Error error) {
     if (cancel_requested_)
-      error = base::PLATFORM_FILE_ERROR_ABORT;
-    if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND)
-      error = base::PLATFORM_FILE_OK;
+      error = base::File::FILE_ERROR_ABORT;
+    if (error == base::File::FILE_ERROR_NOT_FOUND)
+      error = base::File::FILE_OK;
     callback.Run(error);
   }
 
@@ -579,12 +579,12 @@ void CopyOrMoveOperationDelegate::StreamCopyHelper::Read(
 void CopyOrMoveOperationDelegate::StreamCopyHelper::DidRead(
     const StatusCallback& callback, int result) {
   if (cancel_requested_) {
-    callback.Run(base::PLATFORM_FILE_ERROR_ABORT);
+    callback.Run(base::File::FILE_ERROR_ABORT);
     return;
   }
 
   if (result < 0) {
-    callback.Run(NetErrorToPlatformFileError(result));
+    callback.Run(NetErrorToFileError(result));
     return;
   }
 
@@ -593,7 +593,7 @@ void CopyOrMoveOperationDelegate::StreamCopyHelper::DidRead(
     if (need_flush_)
       Flush(callback, true /* is_eof */);
     else
-      callback.Run(base::PLATFORM_FILE_OK);
+      callback.Run(base::File::FILE_OK);
     return;
   }
 
@@ -618,12 +618,12 @@ void CopyOrMoveOperationDelegate::StreamCopyHelper::DidWrite(
     scoped_refptr<net::DrainableIOBuffer> buffer,
     int result) {
   if (cancel_requested_) {
-    callback.Run(base::PLATFORM_FILE_ERROR_ABORT);
+    callback.Run(base::File::FILE_ERROR_ABORT);
     return;
   }
 
   if (result < 0) {
-    callback.Run(NetErrorToPlatformFileError(result));
+    callback.Run(NetErrorToFileError(result));
     return;
   }
 
@@ -663,13 +663,13 @@ void CopyOrMoveOperationDelegate::StreamCopyHelper::Flush(
 void CopyOrMoveOperationDelegate::StreamCopyHelper::DidFlush(
     const StatusCallback& callback, bool is_eof, int result) {
   if (cancel_requested_) {
-    callback.Run(base::PLATFORM_FILE_ERROR_ABORT);
+    callback.Run(base::File::FILE_ERROR_ABORT);
     return;
   }
 
   previous_flush_offset_ = num_copied_bytes_;
   if (is_eof)
-    callback.Run(NetErrorToPlatformFileError(result));
+    callback.Run(NetErrorToFileError(result));
   else
     Read(callback);
 }
@@ -707,7 +707,7 @@ void CopyOrMoveOperationDelegate::RunRecursively() {
 
   // It is an error to try to copy/move an entry into its child.
   if (same_file_system_ && src_root_.path().IsParent(dest_root_.path())) {
-    callback_.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
+    callback_.Run(base::File::FILE_ERROR_INVALID_OPERATION);
     return;
   }
 
@@ -715,7 +715,7 @@ void CopyOrMoveOperationDelegate::RunRecursively() {
     // In JS API this should return error, but we return success because Pepper
     // wants to return success and we have a code path that returns error in
     // Blink for JS (http://crbug.com/329517).
-    callback_.Run(base::PLATFORM_FILE_OK);
+    callback_.Run(base::File::FILE_OK);
     return;
   }
 
@@ -743,11 +743,11 @@ void CopyOrMoveOperationDelegate::ProcessFile(
                    weak_factory_.GetWeakPtr(), src_url));
   } else {
     // Cross filesystem case.
-    base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+    base::File::Error error = base::File::FILE_ERROR_FAILED;
     CopyOrMoveFileValidatorFactory* validator_factory =
         file_system_context()->GetCopyOrMoveFileValidatorFactory(
             dest_root_.type(), &error);
-    if (error != base::PLATFORM_FILE_OK) {
+    if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
@@ -812,7 +812,7 @@ void CopyOrMoveOperationDelegate::PostProcessDirectory(
     const StatusCallback& callback) {
   if (option_ == FileSystemOperation::OPTION_NONE) {
     PostProcessDirectoryAfterTouchFile(
-        src_url, callback, base::PLATFORM_FILE_OK);
+        src_url, callback, base::File::FILE_OK);
     return;
   }
 
@@ -835,11 +835,11 @@ void CopyOrMoveOperationDelegate::DidCopyOrMoveFile(
     const FileSystemURL& dest_url,
     const StatusCallback& callback,
     CopyOrMoveImpl* impl,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   running_copy_set_.erase(impl);
   delete impl;
 
-  if (!progress_callback_.is_null() && error == base::PLATFORM_FILE_OK) {
+  if (!progress_callback_.is_null() && error == base::File::FILE_OK) {
     progress_callback_.Run(
         FileSystemOperation::END_COPY_ENTRY, src_url, dest_url, 0);
   }
@@ -849,13 +849,13 @@ void CopyOrMoveOperationDelegate::DidCopyOrMoveFile(
 
 void CopyOrMoveOperationDelegate::DidTryRemoveDestRoot(
     const StatusCallback& callback,
-    base::PlatformFileError error) {
-  if (error == base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY) {
-    callback_.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
+    base::File::Error error) {
+  if (error == base::File::FILE_ERROR_NOT_A_DIRECTORY) {
+    callback_.Run(base::File::FILE_ERROR_INVALID_OPERATION);
     return;
   }
-  if (error != base::PLATFORM_FILE_OK &&
-      error != base::PLATFORM_FILE_ERROR_NOT_FOUND) {
+  if (error != base::File::FILE_OK &&
+      error != base::File::FILE_ERROR_NOT_FOUND) {
     callback_.Run(error);
     return;
   }
@@ -881,8 +881,8 @@ void CopyOrMoveOperationDelegate::DidCreateDirectory(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     const StatusCallback& callback,
-    base::PlatformFileError error) {
-  if (!progress_callback_.is_null() && error == base::PLATFORM_FILE_OK) {
+    base::File::Error error) {
+  if (!progress_callback_.is_null() && error == base::File::FILE_OK) {
     progress_callback_.Run(
         FileSystemOperation::END_COPY_ENTRY, src_url, dest_url, 0);
   }
@@ -893,12 +893,12 @@ void CopyOrMoveOperationDelegate::DidCreateDirectory(
 void CopyOrMoveOperationDelegate::PostProcessDirectoryAfterGetMetadata(
     const FileSystemURL& src_url,
     const StatusCallback& callback,
-    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) {
     // Ignore the error, and run post process which should run after TouchFile.
     PostProcessDirectoryAfterTouchFile(
-        src_url, callback, base::PLATFORM_FILE_OK);
+        src_url, callback, base::File::FILE_OK);
     return;
   }
 
@@ -913,11 +913,11 @@ void CopyOrMoveOperationDelegate::PostProcessDirectoryAfterGetMetadata(
 void CopyOrMoveOperationDelegate::PostProcessDirectoryAfterTouchFile(
     const FileSystemURL& src_url,
     const StatusCallback& callback,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   // Even if the TouchFile is failed, just ignore it.
 
   if (operation_type_ == OPERATION_COPY) {
-    callback.Run(base::PLATFORM_FILE_OK);
+    callback.Run(base::File::FILE_OK);
     return;
   }
 
@@ -933,9 +933,9 @@ void CopyOrMoveOperationDelegate::PostProcessDirectoryAfterTouchFile(
 
 void CopyOrMoveOperationDelegate::DidRemoveSourceForMove(
     const StatusCallback& callback,
-    base::PlatformFileError error) {
-  if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND)
-    error = base::PLATFORM_FILE_OK;
+    base::File::Error error) {
+  if (error == base::File::FILE_ERROR_NOT_FOUND)
+    error = base::File::FILE_OK;
   callback.Run(error);
 }
 
diff --git a/webkit/browser/fileapi/copy_or_move_operation_delegate.h b/webkit/browser/fileapi/copy_or_move_operation_delegate.h
index 2247c87..bb0c1f9 100644
--- a/webkit/browser/fileapi/copy_or_move_operation_delegate.h
+++ b/webkit/browser/fileapi/copy_or_move_operation_delegate.h
@@ -119,26 +119,26 @@ class CopyOrMoveOperationDelegate
                          const FileSystemURL& dest_url,
                          const StatusCallback& callback,
                          CopyOrMoveImpl* impl,
-                         base::PlatformFileError error);
+                         base::File::Error error);
   void DidTryRemoveDestRoot(const StatusCallback& callback,
-                            base::PlatformFileError error);
+                            base::File::Error error);
   void ProcessDirectoryInternal(const FileSystemURL& src_url,
                                 const FileSystemURL& dest_url,
                                 const StatusCallback& callback);
   void DidCreateDirectory(const FileSystemURL& src_url,
                           const FileSystemURL& dest_url,
                           const StatusCallback& callback,
-                          base::PlatformFileError error);
+                          base::File::Error error);
   void PostProcessDirectoryAfterGetMetadata(
       const FileSystemURL& src_url,
       const StatusCallback& callback,
-      base::PlatformFileError error,
-      const base::PlatformFileInfo& file_info);
+      base::File::Error error,
+      const base::File::Info& file_info);
   void PostProcessDirectoryAfterTouchFile(const FileSystemURL& src_url,
                                           const StatusCallback& callback,
-                                          base::PlatformFileError error);
+                                          base::File::Error error);
   void DidRemoveSourceForMove(const StatusCallback& callback,
-                              base::PlatformFileError error);
+                              base::File::Error error);
 
   void OnCopyFileProgress(const FileSystemURL& src_url, int64 size);
   FileSystemURL CreateDestURL(const FileSystemURL& src_url) const;
diff --git a/webkit/browser/fileapi/dragged_file_util.cc b/webkit/browser/fileapi/dragged_file_util.cc
index 3e81242..0243b3d 100644
--- a/webkit/browser/fileapi/dragged_file_util.cc
+++ b/webkit/browser/fileapi/dragged_file_util.cc
@@ -15,9 +15,6 @@
 #include "webkit/browser/fileapi/native_file_util.h"
 #include "webkit/common/blob/shareable_file_reference.h"
 
-using base::PlatformFileError;
-using base::PlatformFileInfo;
-
 namespace fileapi {
 
 typedef IsolatedContext::MountPointInfo FileInfo;
@@ -51,7 +48,7 @@ class SetFileEnumerator : public FileSystemFileUtil::AbstractFileEnumerator {
  private:
   std::vector<FileInfo> files_;
   std::vector<FileInfo>::const_iterator file_iter_;
-  base::PlatformFileInfo file_info_;
+  base::File::Info file_info_;
 };
 
 }  // namespace
@@ -60,10 +57,10 @@ class SetFileEnumerator : public FileSystemFileUtil::AbstractFileEnumerator {
 
 DraggedFileUtil::DraggedFileUtil() {}
 
-PlatformFileError DraggedFileUtil::GetFileInfo(
+base::File::Error DraggedFileUtil::GetFileInfo(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
-    PlatformFileInfo* file_info,
+    base::File::Info* file_info,
     base::FilePath* platform_path) {
   DCHECK(file_info);
   std::string filesystem_id;
@@ -77,15 +74,15 @@ PlatformFileError DraggedFileUtil::GetFileInfo(
     file_info->is_directory = true;
     file_info->is_symbolic_link = false;
     file_info->size = 0;
-    return base::PLATFORM_FILE_OK;
+    return base::File::FILE_OK;
   }
-  base::PlatformFileError error =
+  base::File::Error error =
       NativeFileUtil::GetFileInfo(url.path(), file_info);
   if (base::IsLink(url.path()) && !base::FilePath().IsParent(url.path())) {
     // Don't follow symlinks unless it's the one that are selected by the user.
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
   }
-  if (error == base::PLATFORM_FILE_OK)
+  if (error == base::File::FILE_OK)
     *platform_path = url.path();
   return error;
 }
diff --git a/webkit/browser/fileapi/dragged_file_util.h b/webkit/browser/fileapi/dragged_file_util.h
index 22c538e..8807fc1 100644
--- a/webkit/browser/fileapi/dragged_file_util.h
+++ b/webkit/browser/fileapi/dragged_file_util.h
@@ -23,10 +23,10 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE DraggedFileUtil
   virtual ~DraggedFileUtil() {}
 
   // FileSystemFileUtil overrides.
-  virtual base::PlatformFileError GetFileInfo(
+  virtual base::File::Error GetFileInfo(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
-      base::PlatformFileInfo* file_info,
+      base::File::Info* file_info,
       base::FilePath* platform_path) OVERRIDE;
   virtual scoped_ptr<AbstractFileEnumerator> CreateFileEnumerator(
       FileSystemOperationContext* context,
diff --git a/webkit/browser/fileapi/file_system_backend.h b/webkit/browser/fileapi/file_system_backend.h
index 048c86d..e475a20 100644
--- a/webkit/browser/fileapi/file_system_backend.h
+++ b/webkit/browser/fileapi/file_system_backend.h
@@ -9,9 +9,9 @@
 #include <vector>
 
 #include "base/callback_forward.h"
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/platform_file.h"
 #include "webkit/browser/fileapi/file_permission_policy.h"
 #include "webkit/browser/fileapi/open_file_system_mode.h"
 #include "webkit/browser/webkit_storage_browser_export.h"
@@ -44,7 +44,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemBackend {
   // Callback for InitializeFileSystem.
   typedef base::Callback<void(const GURL& root_url,
                               const std::string& name,
-                              base::PlatformFileError error)>
+                              base::File::Error error)>
       OpenFileSystemCallback;
   virtual ~FileSystemBackend() {}
 
@@ -76,7 +76,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemBackend {
   // and |type|.  If |error_code| is PLATFORM_FILE_OK and the result is NULL,
   // then no validator is required.
   virtual CopyOrMoveFileValidatorFactory* GetCopyOrMoveFileValidatorFactory(
-      FileSystemType type, base::PlatformFileError* error_code) = 0;
+      FileSystemType type, base::File::Error* error_code) = 0;
 
   // Returns a new instance of the specialized FileSystemOperation for this
   // backend based on the given triplet of |origin_url|, |file_system_type|
@@ -87,7 +87,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemBackend {
   virtual FileSystemOperation* CreateFileSystemOperation(
       const FileSystemURL& url,
       FileSystemContext* context,
-      base::PlatformFileError* error_code) const = 0;
+      base::File::Error* error_code) const = 0;
 
   // Creates a new file stream reader for a given filesystem URL |url| with an
   // offset |offset|. |expected_modification_time| specifies the expected last
diff --git a/webkit/browser/fileapi/file_system_context.cc b/webkit/browser/fileapi/file_system_context.cc
index 49d00a5..444ef46 100644
--- a/webkit/browser/fileapi/file_system_context.cc
+++ b/webkit/browser/fileapi/file_system_context.cc
@@ -47,9 +47,9 @@ 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;
   }
@@ -184,7 +184,7 @@ bool FileSystemContext::DeleteDataForOriginOnFileTaskRunner(
       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;
     }
@@ -233,9 +233,9 @@ AsyncFileUtil* FileSystemContext::GetAsyncFileUtil(
 
 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;
@@ -297,13 +297,13 @@ void FileSystemContext::OpenFileSystem(
 
   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;
   }
 
@@ -324,17 +324,17 @@ void FileSystemContext::ResolveURL(
     // 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;
   }
@@ -356,11 +356,11 @@ void FileSystemContext::DeleteFileSystem(
 
   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;
   }
 
@@ -461,21 +461,21 @@ void FileSystemContext::DeleteOnCorrectThread() const {
 }
 
 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);
 
@@ -543,10 +543,10 @@ void FileSystemContext::DidOpenFileSystemForResolveURL(
     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;
   }
diff --git a/webkit/browser/fileapi/file_system_context.h b/webkit/browser/fileapi/file_system_context.h
index 9f81bba..04c9fa6 100644
--- a/webkit/browser/fileapi/file_system_context.h
+++ b/webkit/browser/fileapi/file_system_context.h
@@ -10,10 +10,10 @@
 #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"
@@ -134,7 +134,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemContext
   // |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
@@ -163,17 +163,17 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemContext
   // 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.
@@ -296,7 +296,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemContext
   // 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
@@ -316,7 +316,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemContext
       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 {
diff --git a/webkit/browser/fileapi/file_system_dir_url_request_job.cc b/webkit/browser/fileapi/file_system_dir_url_request_job.cc
index 7589b37..07c5d58 100644
--- a/webkit/browser/fileapi/file_system_dir_url_request_job.cc
+++ b/webkit/browser/fileapi/file_system_dir_url_request_job.cc
@@ -85,7 +85,7 @@ void FileSystemDirURLRequestJob::StartAsync() {
     // In incognito mode the API is not usable and there should be no data.
     if (url_.is_valid() && VirtualPath::IsRootPath(url_.virtual_path())) {
       // Return an empty directory if the filesystem root is queried.
-      DidReadDirectory(base::PLATFORM_FILE_OK,
+      DidReadDirectory(base::File::FILE_OK,
                        std::vector<DirectoryEntry>(),
                        false);
       return;
@@ -100,12 +100,12 @@ void FileSystemDirURLRequestJob::StartAsync() {
 }
 
 void FileSystemDirURLRequestJob::DidReadDirectory(
-    base::PlatformFileError result,
+    base::File::Error result,
     const std::vector<DirectoryEntry>& entries,
     bool has_more) {
-  if (result != base::PLATFORM_FILE_OK) {
+  if (result != base::File::FILE_OK) {
     int rv = net::ERR_FILE_NOT_FOUND;
-    if (result == base::PLATFORM_FILE_ERROR_INVALID_URL)
+    if (result == base::File::FILE_ERROR_INVALID_URL)
       rv = net::ERR_INVALID_URL;
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
     return;
diff --git a/webkit/browser/fileapi/file_system_dir_url_request_job.h b/webkit/browser/fileapi/file_system_dir_url_request_job.h
index 933550e..7346225 100644
--- a/webkit/browser/fileapi/file_system_dir_url_request_job.h
+++ b/webkit/browser/fileapi/file_system_dir_url_request_job.h
@@ -8,10 +8,10 @@
 #include <string>
 #include <vector>
 
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
-#include "base/platform_file.h"
 #include "net/url_request/url_request_job.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/webkit_storage_browser_export.h"
@@ -49,7 +49,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE FileSystemDirURLRequestJob
   virtual ~FileSystemDirURLRequestJob();
 
   void StartAsync();
-  void DidReadDirectory(base::PlatformFileError result,
+  void DidReadDirectory(base::File::Error result,
                         const std::vector<DirectoryEntry>& entries,
                         bool has_more);
 
diff --git a/webkit/browser/fileapi/file_system_file_stream_reader.cc b/webkit/browser/fileapi/file_system_file_stream_reader.cc
index f5427b7..5624565 100644
--- a/webkit/browser/fileapi/file_system_file_stream_reader.cc
+++ b/webkit/browser/fileapi/file_system_file_stream_reader.cc
@@ -117,16 +117,16 @@ int FileSystemFileStreamReader::CreateSnapshot(
 void FileSystemFileStreamReader::DidCreateSnapshot(
     const base::Closure& callback,
     const net::CompletionCallback& error_callback,
-    base::PlatformFileError file_error,
-    const base::PlatformFileInfo& file_info,
+    base::File::Error file_error,
+    const base::File::Info& file_info,
     const base::FilePath& platform_path,
     const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
   DCHECK(has_pending_create_snapshot_);
   DCHECK(!local_file_reader_.get());
   has_pending_create_snapshot_ = false;
 
-  if (file_error != base::PLATFORM_FILE_OK) {
-    error_callback.Run(net::PlatformFileErrorToNetError(file_error));
+  if (file_error != base::File::FILE_OK) {
+    error_callback.Run(net::FileErrorToNetError(file_error));
     return;
   }
 
diff --git a/webkit/browser/fileapi/file_system_file_stream_reader.h b/webkit/browser/fileapi/file_system_file_stream_reader.h
index 4d36c42..3615022 100644
--- a/webkit/browser/fileapi/file_system_file_stream_reader.h
+++ b/webkit/browser/fileapi/file_system_file_stream_reader.h
@@ -6,8 +6,8 @@
 #define WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_FILE_STREAM_READER_H_
 
 #include "base/bind.h"
+#include "base/files/file.h"
 #include "base/memory/ref_counted.h"
-#include "base/platform_file.h"
 #include "base/time/time.h"
 #include "webkit/browser/blob/file_stream_reader.h"
 #include "webkit/browser/fileapi/file_system_url.h"
@@ -57,8 +57,8 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE FileSystemFileStreamReader
   void DidCreateSnapshot(
       const base::Closure& callback,
       const net::CompletionCallback& error_callback,
-      base::PlatformFileError file_error,
-      const base::PlatformFileInfo& file_info,
+      base::File::Error file_error,
+      const base::File::Info& file_info,
       const base::FilePath& platform_path,
       const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref);
 
diff --git a/webkit/browser/fileapi/file_system_file_util.h b/webkit/browser/fileapi/file_system_file_util.h
index 5a4d730..a9ee035 100644
--- a/webkit/browser/fileapi/file_system_file_util.h
+++ b/webkit/browser/fileapi/file_system_file_util.h
@@ -5,6 +5,7 @@
 #ifndef WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_FILE_UTIL_H_
 #define WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_FILE_UTIL_H_
 
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
@@ -60,7 +61,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemFileUtil {
   // Creates or opens a file with the given flags.
   // See header comments for AsyncFileUtil::CreateOrOpen() for more details.
   // This is used only by Pepper/NaCl File API.
-  virtual base::PlatformFileError CreateOrOpen(
+  virtual base::File::Error CreateOrOpen(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       int file_flags,
@@ -69,20 +70,20 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemFileUtil {
 
   // Closes the given file handle.
   // This is used only for Pepper/NaCl File API.
-  virtual base::PlatformFileError Close(
+  virtual base::File::Error Close(
       FileSystemOperationContext* context,
       base::PlatformFile file) = 0;
 
   // Ensures that the given |url| exist.  This creates a empty new file
   // at |url| if the |url| does not exist.
   // See header comments for AsyncFileUtil::EnsureFileExists() for more details.
-  virtual base::PlatformFileError EnsureFileExists(
+  virtual base::File::Error EnsureFileExists(
       FileSystemOperationContext* context,
       const FileSystemURL& url, bool* created) = 0;
 
   // Creates directory at given url.
   // See header comments for AsyncFileUtil::CreateDirectory() for more details.
-  virtual base::PlatformFileError CreateDirectory(
+  virtual base::File::Error CreateDirectory(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       bool exclusive,
@@ -90,10 +91,10 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemFileUtil {
 
   // Retrieves the information about a file.
   // See header comments for AsyncFileUtil::GetFileInfo() for more details.
-  virtual base::PlatformFileError GetFileInfo(
+  virtual base::File::Error GetFileInfo(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
-      base::PlatformFileInfo* file_info,
+      base::File::Info* file_info,
       base::FilePath* platform_path) = 0;
 
   // Returns a pointer to a new instance of AbstractFileEnumerator which is
@@ -110,14 +111,14 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemFileUtil {
   // Maps |file_system_url| given |context| into |local_file_path|
   // which represents physical file location on the host OS.
   // This may not always make sense for all subclasses.
-  virtual base::PlatformFileError GetLocalFilePath(
+  virtual base::File::Error GetLocalFilePath(
       FileSystemOperationContext* context,
       const FileSystemURL& file_system_url,
       base::FilePath* local_file_path) = 0;
 
   // Updates the file metadata information.
   // See header comments for AsyncFileUtil::Touch() for more details.
-  virtual base::PlatformFileError Touch(
+  virtual base::File::Error Touch(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       const base::Time& last_access_time,
@@ -125,7 +126,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemFileUtil {
 
   // Truncates a file to the given length.
   // See header comments for AsyncFileUtil::Truncate() for more details.
-  virtual base::PlatformFileError Truncate(
+  virtual base::File::Error Truncate(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       int64 length) = 0;
@@ -143,7 +144,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemFileUtil {
   // - PLATFORM_FILE_ERROR_FAILED if |dest_url| does not exist and
   //   its parent path is a file.
   //
-  virtual base::PlatformFileError CopyOrMoveFile(
+  virtual base::File::Error CopyOrMoveFile(
       FileSystemOperationContext* context,
       const FileSystemURL& src_url,
       const FileSystemURL& dest_url,
@@ -153,20 +154,20 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemFileUtil {
   // Copies in a single file from a different filesystem.
   // See header comments for AsyncFileUtil::CopyInForeignFile() for
   // more details.
-  virtual base::PlatformFileError CopyInForeignFile(
+  virtual base::File::Error CopyInForeignFile(
         FileSystemOperationContext* context,
         const base::FilePath& src_file_path,
         const FileSystemURL& dest_url) = 0;
 
   // Deletes a single file.
   // See header comments for AsyncFileUtil::DeleteFile() for more details.
-  virtual base::PlatformFileError DeleteFile(
+  virtual base::File::Error DeleteFile(
       FileSystemOperationContext* context,
       const FileSystemURL& url) = 0;
 
   // Deletes a single empty directory.
   // See header comments for AsyncFileUtil::DeleteDirectory() for more details.
-  virtual base::PlatformFileError DeleteDirectory(
+  virtual base::File::Error DeleteDirectory(
       FileSystemOperationContext* context,
       const FileSystemURL& url) = 0;
 
@@ -178,8 +179,8 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemFileUtil {
   virtual webkit_blob::ScopedFile CreateSnapshotFile(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
-      base::PlatformFileError* error,
-      base::PlatformFileInfo* file_info,
+      base::File::Error* error,
+      base::File::Info* file_info,
       base::FilePath* platform_path) = 0;
 
  protected:
diff --git a/webkit/browser/fileapi/file_system_operation.h b/webkit/browser/fileapi/file_system_operation.h
index ded87f7..cc35be4 100644
--- a/webkit/browser/fileapi/file_system_operation.h
+++ b/webkit/browser/fileapi/file_system_operation.h
@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "base/callback.h"
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/platform_file.h"
 #include "base/process/process.h"
@@ -66,19 +67,19 @@ class FileSystemOperation {
   virtual ~FileSystemOperation() {}
 
   // Used for CreateFile(), etc. |result| is the return code of the operation.
-  typedef base::Callback<void(base::PlatformFileError result)> StatusCallback;
+  typedef base::Callback<void(base::File::Error result)> StatusCallback;
 
   // Used for GetMetadata(). |result| is the return code of the operation,
   // |file_info| is the obtained file info.
   typedef base::Callback<
-      void(base::PlatformFileError result,
-           const base::PlatformFileInfo& file_info)> GetMetadataCallback;
+      void(base::File::Error result,
+           const base::File::Info& file_info)> GetMetadataCallback;
 
   // Used for OpenFile(). |result| is the return code of the operation.
   // |on_close_callback| will be called after the file is closed in the child
   // process. It can be null, if no operation is needed on closing a file.
   typedef base::Callback<
-      void(base::PlatformFileError result,
+      void(base::File::Error result,
            base::PlatformFile file,
            const base::Closure& on_close_callback)> OpenFileCallback;
 
@@ -89,7 +90,7 @@ class FileSystemOperation {
   // |file_list| is the list of files read, and |has_more| is true if some files
   // are yet to be read.
   typedef base::Callback<
-      void(base::PlatformFileError result,
+      void(base::File::Error result,
            const FileEntryList& file_list,
            bool has_more)> ReadDirectoryCallback;
 
@@ -115,8 +116,8 @@ class FileSystemOperation {
   // Please see the comment for ShareableFileReference for details.
   //
   typedef base::Callback<
-      void(base::PlatformFileError result,
-           const base::PlatformFileInfo& file_info,
+      void(base::File::Error result,
+           const base::File::Info& file_info,
            const base::FilePath& platform_path,
            const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref)>
           SnapshotFileCallback;
@@ -221,7 +222,7 @@ class FileSystemOperation {
   };
 
   // Used for Write().
-  typedef base::Callback<void(base::PlatformFileError result,
+  typedef base::Callback<void(base::File::Error result,
                               int64 bytes,
                               bool complete)> WriteCallback;
 
@@ -452,7 +453,7 @@ class FileSystemOperation {
   // temporary nor persistent.
   // In such a case, base::PLATFORM_FILE_ERROR_INVALID_OPERATION will be
   // returned.
-  virtual base::PlatformFileError SyncGetPlatformPath(
+  virtual base::File::Error SyncGetPlatformPath(
       const FileSystemURL& url,
       base::FilePath* platform_path) = 0;
 
diff --git a/webkit/browser/fileapi/file_system_operation_impl.cc b/webkit/browser/fileapi/file_system_operation_impl.cc
index af6e1ca..5cee4a1 100644
--- a/webkit/browser/fileapi/file_system_operation_impl.cc
+++ b/webkit/browser/fileapi/file_system_operation_impl.cc
@@ -50,7 +50,7 @@ void FileSystemOperationImpl::CreateFile(const FileSystemURL& url,
       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,
@@ -63,7 +63,7 @@ void FileSystemOperationImpl::CreateDirectory(const FileSystemURL& 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(
@@ -182,7 +182,7 @@ void FileSystemOperationImpl::Truncate(const FileSystemURL& url, int64 length,
       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,
@@ -204,7 +204,7 @@ void FileSystemOperationImpl::OpenFile(const FileSystemURL& url,
 
   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;
@@ -214,7 +214,7 @@ void FileSystemOperationImpl::OpenFile(const FileSystemURL& 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()));
 }
@@ -257,7 +257,7 @@ void FileSystemOperationImpl::CopyInForeignFile(
       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(
@@ -294,7 +294,7 @@ void FileSystemOperationImpl::CopyFileLocal(
       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(
@@ -309,19 +309,19 @@ void FileSystemOperationImpl::MoveFileLocal(
       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(
@@ -456,9 +456,9 @@ void FileSystemOperationImpl::DoOpenFile(const FileSystemURL& url,
 
 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);
   }
@@ -466,21 +466,21 @@ void FileSystemOperationImpl::DidEnsureFileExistsExclusive(
 
 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);
   }
@@ -488,27 +488,27 @@ void FileSystemOperationImpl::DidFinishOperation(
 
 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(
@@ -526,7 +526,7 @@ void FileSystemOperationImpl::DidDeleteRecursively(
 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 = (
@@ -540,12 +540,12 @@ void FileSystemOperationImpl::DidWrite(
   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);
diff --git a/webkit/browser/fileapi/file_system_operation_impl.h b/webkit/browser/fileapi/file_system_operation_impl.h
index 0625995..36e1bb8 100644
--- a/webkit/browser/fileapi/file_system_operation_impl.h
+++ b/webkit/browser/fileapi/file_system_operation_impl.h
@@ -90,7 +90,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemOperationImpl
                              const FileSystemURL& dest_url,
                              CopyOrMoveOption option,
                              const StatusCallback& callback) OVERRIDE;
-  virtual base::PlatformFileError SyncGetPlatformPath(
+  virtual base::File::Error SyncGetPlatformPath(
       const FileSystemURL& url,
       base::FilePath* platform_path) OVERRIDE;
 
@@ -151,32 +151,32 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemOperationImpl
 
   // Callback for CreateFile for |exclusive|=true cases.
   void DidEnsureFileExistsExclusive(const StatusCallback& callback,
-                                    base::PlatformFileError rv,
+                                    base::File::Error rv,
                                     bool created);
 
   // Callback for CreateFile for |exclusive|=false cases.
   void DidEnsureFileExistsNonExclusive(const StatusCallback& callback,
-                                       base::PlatformFileError rv,
+                                       base::File::Error rv,
                                        bool created);
 
   void DidFinishOperation(const StatusCallback& callback,
-                          base::PlatformFileError rv);
+                          base::File::Error rv);
   void DidDirectoryExists(const StatusCallback& callback,
-                          base::PlatformFileError rv,
-                          const base::PlatformFileInfo& file_info);
+                          base::File::Error rv,
+                          const base::File::Info& file_info);
   void DidFileExists(const StatusCallback& callback,
-                     base::PlatformFileError rv,
-                     const base::PlatformFileInfo& file_info);
+                     base::File::Error rv,
+                     const base::File::Info& file_info);
   void DidDeleteRecursively(const FileSystemURL& url,
                             const StatusCallback& callback,
-                            base::PlatformFileError rv);
+                            base::File::Error rv);
   void DidWrite(const FileSystemURL& url,
                 const WriteCallback& callback,
-                base::PlatformFileError rv,
+                base::File::Error rv,
                 int64 bytes,
                 FileWriterDelegate::WriteProgressStatus write_status);
   void DidOpenFile(const OpenFileCallback& callback,
-                   base::PlatformFileError rv,
+                   base::File::Error rv,
                    base::PassPlatformFile file,
                    const base::Closure& on_close_callback);
 
diff --git a/webkit/browser/fileapi/file_system_operation_runner.cc b/webkit/browser/fileapi/file_system_operation_runner.cc
index d552a78..aa4c435 100644
--- a/webkit/browser/fileapi/file_system_operation_runner.cc
+++ b/webkit/browser/fileapi/file_system_operation_runner.cc
@@ -43,7 +43,7 @@ OperationID FileSystemOperationRunner::CreateFile(
     const FileSystemURL& url,
     bool exclusive,
     const StatusCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
 
@@ -66,7 +66,7 @@ OperationID FileSystemOperationRunner::CreateDirectory(
     bool exclusive,
     bool recursive,
     const StatusCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
   BeginOperationScoper scope;
@@ -89,7 +89,7 @@ OperationID FileSystemOperationRunner::Copy(
     CopyOrMoveOption option,
     const CopyProgressCallback& progress_callback,
     const StatusCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(dest_url, &error);
   BeginOperationScoper scope;
@@ -116,7 +116,7 @@ OperationID FileSystemOperationRunner::Move(
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const StatusCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(dest_url, &error);
   BeginOperationScoper scope;
@@ -137,7 +137,7 @@ OperationID FileSystemOperationRunner::Move(
 OperationID FileSystemOperationRunner::DirectoryExists(
     const FileSystemURL& url,
     const StatusCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
   BeginOperationScoper scope;
@@ -157,7 +157,7 @@ OperationID FileSystemOperationRunner::DirectoryExists(
 OperationID FileSystemOperationRunner::FileExists(
     const FileSystemURL& url,
     const StatusCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
   BeginOperationScoper scope;
@@ -177,13 +177,13 @@ OperationID FileSystemOperationRunner::FileExists(
 OperationID FileSystemOperationRunner::GetMetadata(
     const FileSystemURL& url,
     const GetMetadataCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
   BeginOperationScoper scope;
   OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
   if (!operation) {
-    DidGetMetadata(handle, callback, error, base::PlatformFileInfo());
+    DidGetMetadata(handle, callback, error, base::File::Info());
     return handle.id;
   }
   PrepareForRead(handle.id, url);
@@ -197,7 +197,7 @@ OperationID FileSystemOperationRunner::GetMetadata(
 OperationID FileSystemOperationRunner::ReadDirectory(
     const FileSystemURL& url,
     const ReadDirectoryCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
   BeginOperationScoper scope;
@@ -218,7 +218,7 @@ OperationID FileSystemOperationRunner::ReadDirectory(
 OperationID FileSystemOperationRunner::Remove(
     const FileSystemURL& url, bool recursive,
     const StatusCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
   BeginOperationScoper scope;
@@ -241,7 +241,7 @@ OperationID FileSystemOperationRunner::Write(
     scoped_ptr<webkit_blob::BlobDataHandle> blob,
     int64 offset,
     const WriteCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
 
@@ -256,7 +256,7 @@ OperationID FileSystemOperationRunner::Write(
       file_system_context_->CreateFileStreamWriter(url, offset));
   if (!writer) {
     // Write is not supported.
-    DidWrite(handle, callback, base::PLATFORM_FILE_ERROR_SECURITY, 0, true);
+    DidWrite(handle, callback, base::File::FILE_ERROR_SECURITY, 0, true);
     return handle.id;
   }
 
@@ -280,7 +280,7 @@ OperationID FileSystemOperationRunner::Write(
 OperationID FileSystemOperationRunner::Truncate(
     const FileSystemURL& url, int64 length,
     const StatusCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
   BeginOperationScoper scope;
@@ -308,7 +308,7 @@ void FileSystemOperationRunner::Cancel(
   FileSystemOperation* operation = operations_.Lookup(id);
   if (!operation) {
     // There is no operation with |id|.
-    callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
+    callback.Run(base::File::FILE_ERROR_INVALID_OPERATION);
     return;
   }
   operation->Cancel(callback);
@@ -319,7 +319,7 @@ OperationID FileSystemOperationRunner::TouchFile(
     const base::Time& last_access_time,
     const base::Time& last_modified_time,
     const StatusCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
   BeginOperationScoper scope;
@@ -340,7 +340,7 @@ OperationID FileSystemOperationRunner::OpenFile(
     const FileSystemURL& url,
     int file_flags,
     const OpenFileCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
   BeginOperationScoper scope;
@@ -370,13 +370,13 @@ OperationID FileSystemOperationRunner::OpenFile(
 OperationID FileSystemOperationRunner::CreateSnapshotFile(
     const FileSystemURL& url,
     const SnapshotFileCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
   BeginOperationScoper scope;
   OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
   if (!operation) {
-    DidCreateSnapshot(handle, callback, error, base::PlatformFileInfo(),
+    DidCreateSnapshot(handle, callback, error, base::File::Info(),
                       base::FilePath(), NULL);
     return handle.id;
   }
@@ -392,7 +392,7 @@ OperationID FileSystemOperationRunner::CopyInForeignFile(
     const base::FilePath& src_local_disk_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(dest_url, &error);
   BeginOperationScoper scope;
@@ -411,7 +411,7 @@ OperationID FileSystemOperationRunner::CopyInForeignFile(
 OperationID FileSystemOperationRunner::RemoveFile(
     const FileSystemURL& url,
     const StatusCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
   BeginOperationScoper scope;
@@ -430,7 +430,7 @@ OperationID FileSystemOperationRunner::RemoveFile(
 OperationID FileSystemOperationRunner::RemoveDirectory(
     const FileSystemURL& url,
     const StatusCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
   BeginOperationScoper scope;
@@ -452,7 +452,7 @@ OperationID FileSystemOperationRunner::CopyFileLocal(
     CopyOrMoveOption option,
     const CopyFileProgressCallback& progress_callback,
     const StatusCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(src_url, &error);
   BeginOperationScoper scope;
@@ -473,7 +473,7 @@ OperationID FileSystemOperationRunner::MoveFileLocal(
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const StatusCallback& callback) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(src_url, &error);
   BeginOperationScoper scope;
@@ -489,10 +489,10 @@ OperationID FileSystemOperationRunner::MoveFileLocal(
   return handle.id;
 }
 
-base::PlatformFileError FileSystemOperationRunner::SyncGetPlatformPath(
+base::File::Error FileSystemOperationRunner::SyncGetPlatformPath(
     const FileSystemURL& url,
     base::FilePath* platform_path) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   scoped_ptr<FileSystemOperation> operation(
       file_system_context_->CreateFileSystemOperation(url, &error));
   if (!operation.get())
@@ -507,7 +507,7 @@ FileSystemOperationRunner::FileSystemOperationRunner(
 void FileSystemOperationRunner::DidFinish(
     const OperationHandle& handle,
     const StatusCallback& callback,
-    base::PlatformFileError rv) {
+    base::File::Error rv) {
   if (handle.scope) {
     finished_operations_.insert(handle.id);
     base::MessageLoopProxy::current()->PostTask(
@@ -522,8 +522,8 @@ void FileSystemOperationRunner::DidFinish(
 void FileSystemOperationRunner::DidGetMetadata(
     const OperationHandle& handle,
     const GetMetadataCallback& callback,
-    base::PlatformFileError rv,
-    const base::PlatformFileInfo& file_info) {
+    base::File::Error rv,
+    const base::File::Info& file_info) {
   if (handle.scope) {
     finished_operations_.insert(handle.id);
     base::MessageLoopProxy::current()->PostTask(
@@ -538,7 +538,7 @@ void FileSystemOperationRunner::DidGetMetadata(
 void FileSystemOperationRunner::DidReadDirectory(
     const OperationHandle& handle,
     const ReadDirectoryCallback& callback,
-    base::PlatformFileError rv,
+    base::File::Error rv,
     const std::vector<DirectoryEntry>& entries,
     bool has_more) {
   if (handle.scope) {
@@ -550,14 +550,14 @@ void FileSystemOperationRunner::DidReadDirectory(
     return;
   }
   callback.Run(rv, entries, has_more);
-  if (rv != base::PLATFORM_FILE_OK || !has_more)
+  if (rv != base::File::FILE_OK || !has_more)
     FinishOperation(handle.id);
 }
 
 void FileSystemOperationRunner::DidWrite(
     const OperationHandle& handle,
     const WriteCallback& callback,
-    base::PlatformFileError rv,
+    base::File::Error rv,
     int64 bytes,
     bool complete) {
   if (handle.scope) {
@@ -568,14 +568,14 @@ void FileSystemOperationRunner::DidWrite(
     return;
   }
   callback.Run(rv, bytes, complete);
-  if (rv != base::PLATFORM_FILE_OK || complete)
+  if (rv != base::File::FILE_OK || complete)
     FinishOperation(handle.id);
 }
 
 void FileSystemOperationRunner::DidOpenFile(
     const OperationHandle& handle,
     const OpenFileCallback& callback,
-    base::PlatformFileError rv,
+    base::File::Error rv,
     base::PlatformFile file,
     const base::Closure& on_close_callback) {
   if (handle.scope) {
@@ -593,8 +593,8 @@ void FileSystemOperationRunner::DidOpenFile(
 void FileSystemOperationRunner::DidCreateSnapshot(
     const OperationHandle& handle,
     const SnapshotFileCallback& callback,
-    base::PlatformFileError rv,
-    const base::PlatformFileInfo& file_info,
+    base::File::Error rv,
+    const base::File::Info& file_info,
     const base::FilePath& platform_path,
     const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
   if (handle.scope) {
@@ -679,7 +679,7 @@ void FileSystemOperationRunner::FinishOperation(OperationID id) {
   if (found_cancel != stray_cancel_callbacks_.end()) {
     // This cancel has been requested after the operation has finished,
     // so report that we failed to stop it.
-    found_cancel->second.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
+    found_cancel->second.Run(base::File::FILE_ERROR_INVALID_OPERATION);
     stray_cancel_callbacks_.erase(found_cancel);
   }
 }
diff --git a/webkit/browser/fileapi/file_system_operation_runner.h b/webkit/browser/fileapi/file_system_operation_runner.h
index fba6b1c..1a5314c 100644
--- a/webkit/browser/fileapi/file_system_operation_runner.h
+++ b/webkit/browser/fileapi/file_system_operation_runner.h
@@ -234,8 +234,8 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemOperationRunner
   // This is called only by pepper plugin as of writing to synchronously get
   // the underlying platform path to upload a file in the sandboxed filesystem
   // (e.g. TEMPORARY or PERSISTENT).
-  base::PlatformFileError SyncGetPlatformPath(const FileSystemURL& url,
-                                              base::FilePath* platform_path);
+  base::File::Error SyncGetPlatformPath(const FileSystemURL& url,
+                                        base::FilePath* platform_path);
 
  private:
   class BeginOperationScoper;
@@ -253,32 +253,32 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemOperationRunner
 
   void DidFinish(const OperationHandle& handle,
                  const StatusCallback& callback,
-                 base::PlatformFileError rv);
+                 base::File::Error rv);
   void DidGetMetadata(const OperationHandle& handle,
                       const GetMetadataCallback& callback,
-                      base::PlatformFileError rv,
-                      const base::PlatformFileInfo& file_info);
+                      base::File::Error rv,
+                      const base::File::Info& file_info);
   void DidReadDirectory(const OperationHandle& handle,
                         const ReadDirectoryCallback& callback,
-                        base::PlatformFileError rv,
+                        base::File::Error rv,
                         const std::vector<DirectoryEntry>& entries,
                         bool has_more);
   void DidWrite(const OperationHandle& handle,
                 const WriteCallback& callback,
-                base::PlatformFileError rv,
+                base::File::Error rv,
                 int64 bytes,
                 bool complete);
   void DidOpenFile(
       const OperationHandle& handle,
       const OpenFileCallback& callback,
-      base::PlatformFileError rv,
+      base::File::Error rv,
       base::PlatformFile file,
       const base::Closure& on_close_callback);
   void DidCreateSnapshot(
       const OperationHandle& handle,
       const SnapshotFileCallback& callback,
-      base::PlatformFileError rv,
-      const base::PlatformFileInfo& file_info,
+      base::File::Error rv,
+      const base::File::Info& file_info,
       const base::FilePath& platform_path,
       const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref);
 
diff --git a/webkit/browser/fileapi/file_system_quota_client.cc b/webkit/browser/fileapi/file_system_quota_client.cc
index 6fd0ef5..3dce218 100644
--- a/webkit/browser/fileapi/file_system_quota_client.cc
+++ b/webkit/browser/fileapi/file_system_quota_client.cc
@@ -70,10 +70,10 @@ quota::QuotaStatusCode DeleteOriginOnFileTaskRunner(
   FileSystemBackend* provider = context->GetFileSystemBackend(type);
   if (!provider || !provider->GetQuotaUtil())
     return quota::kQuotaErrorNotSupported;
-  base::PlatformFileError result =
+  base::File::Error result =
       provider->GetQuotaUtil()->DeleteOriginDataOnFileTaskRunner(
           context, context->quota_manager_proxy(), origin, type);
-  if (result == base::PLATFORM_FILE_OK)
+  if (result == base::File::FILE_OK)
     return quota::kQuotaStatusOk;
   return quota::kQuotaErrorInvalidModification;
 }
diff --git a/webkit/browser/fileapi/file_system_quota_util.h b/webkit/browser/fileapi/file_system_quota_util.h
index 2005927..7e6badf 100644
--- a/webkit/browser/fileapi/file_system_quota_util.h
+++ b/webkit/browser/fileapi/file_system_quota_util.h
@@ -9,7 +9,7 @@
 #include <string>
 
 #include "base/basictypes.h"
-#include "base/platform_file.h"
+#include "base/files/file.h"
 #include "url/gurl.h"
 #include "webkit/browser/fileapi/task_runner_bound_observer_list.h"
 #include "webkit/browser/webkit_storage_browser_export.h"
@@ -38,7 +38,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemQuotaUtil {
 
   // Deletes the data on the origin and reports the amount of deleted data
   // to the quota manager via |proxy|.
-  virtual base::PlatformFileError DeleteOriginDataOnFileTaskRunner(
+  virtual base::File::Error DeleteOriginDataOnFileTaskRunner(
       FileSystemContext* context,
       quota::QuotaManagerProxy* proxy,
       const GURL& origin_url,
diff --git a/webkit/browser/fileapi/file_system_url_request_job.cc b/webkit/browser/fileapi/file_system_url_request_job.cc
index 57db300..fe445649 100644
--- a/webkit/browser/fileapi/file_system_url_request_job.cc
+++ b/webkit/browser/fileapi/file_system_url_request_job.cc
@@ -169,10 +169,10 @@ void FileSystemURLRequestJob::StartAsync() {
 }
 
 void FileSystemURLRequestJob::DidGetMetadata(
-    base::PlatformFileError error_code,
-    const base::PlatformFileInfo& file_info) {
-  if (error_code != base::PLATFORM_FILE_OK) {
-    NotifyFailed(error_code == base::PLATFORM_FILE_ERROR_INVALID_URL ?
+    base::File::Error error_code,
+    const base::File::Info& file_info) {
+  if (error_code != base::File::FILE_OK) {
+    NotifyFailed(error_code == base::File::FILE_ERROR_INVALID_URL ?
                  net::ERR_INVALID_URL : net::ERR_FILE_NOT_FOUND);
     return;
   }
diff --git a/webkit/browser/fileapi/file_system_url_request_job.h b/webkit/browser/fileapi/file_system_url_request_job.h
index a784d62..8fa766c 100644
--- a/webkit/browser/fileapi/file_system_url_request_job.h
+++ b/webkit/browser/fileapi/file_system_url_request_job.h
@@ -7,10 +7,10 @@
 
 #include <string>
 
+#include "base/files/file.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
-#include "base/platform_file.h"
 #include "net/http/http_byte_range.h"
 #include "net/url_request/url_request_job.h"
 #include "webkit/browser/fileapi/file_system_url.h"
@@ -61,8 +61,8 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE FileSystemURLRequestJob
 
   void StartAsync();
   void DidGetMetadata(
-      base::PlatformFileError error_code,
-      const base::PlatformFileInfo& file_info);
+      base::File::Error error_code,
+      const base::File::Info& file_info);
   void DidRead(int result);
   void NotifyFailed(int rv);
 
diff --git a/webkit/browser/fileapi/file_writer_delegate.cc b/webkit/browser/fileapi/file_writer_delegate.cc
index 295cd64..c1ec7eb 100644
--- a/webkit/browser/fileapi/file_writer_delegate.cc
+++ b/webkit/browser/fileapi/file_writer_delegate.cc
@@ -54,7 +54,7 @@ void FileWriterDelegate::Cancel() {
   // Return true to finish immediately if we have no pending writes.
   // Otherwise we'll do the final cleanup in the Cancel callback.
   if (status != net::ERR_IO_PENDING) {
-    write_callback_.Run(base::PLATFORM_FILE_ERROR_ABORT, 0,
+    write_callback_.Run(base::File::FILE_ERROR_ABORT, 0,
                         GetCompletionStatusOnError());
   }
 }
@@ -63,33 +63,33 @@ void FileWriterDelegate::OnReceivedRedirect(net::URLRequest* request,
                                             const GURL& new_url,
                                             bool* defer_redirect) {
   NOTREACHED();
-  OnError(base::PLATFORM_FILE_ERROR_SECURITY);
+  OnError(base::File::FILE_ERROR_SECURITY);
 }
 
 void FileWriterDelegate::OnAuthRequired(net::URLRequest* request,
                                         net::AuthChallengeInfo* auth_info) {
   NOTREACHED();
-  OnError(base::PLATFORM_FILE_ERROR_SECURITY);
+  OnError(base::File::FILE_ERROR_SECURITY);
 }
 
 void FileWriterDelegate::OnCertificateRequested(
     net::URLRequest* request,
     net::SSLCertRequestInfo* cert_request_info) {
   NOTREACHED();
-  OnError(base::PLATFORM_FILE_ERROR_SECURITY);
+  OnError(base::File::FILE_ERROR_SECURITY);
 }
 
 void FileWriterDelegate::OnSSLCertificateError(net::URLRequest* request,
                                                const net::SSLInfo& ssl_info,
                                                bool fatal) {
   NOTREACHED();
-  OnError(base::PLATFORM_FILE_ERROR_SECURITY);
+  OnError(base::File::FILE_ERROR_SECURITY);
 }
 
 void FileWriterDelegate::OnResponseStarted(net::URLRequest* request) {
   DCHECK_EQ(request_.get(), request);
   if (!request->status().is_success() || request->GetResponseCode() != 200) {
-    OnError(base::PLATFORM_FILE_ERROR_FAILED);
+    OnError(base::File::FILE_ERROR_FAILED);
     return;
   }
   Read();
@@ -99,7 +99,7 @@ void FileWriterDelegate::OnReadCompleted(net::URLRequest* request,
                                          int bytes_read) {
   DCHECK_EQ(request_.get(), request);
   if (!request->status().is_success()) {
-    OnError(base::PLATFORM_FILE_ERROR_FAILED);
+    OnError(base::File::FILE_ERROR_FAILED);
     return;
   }
   OnDataReceived(bytes_read);
@@ -114,7 +114,7 @@ void FileWriterDelegate::Read() {
         base::Bind(&FileWriterDelegate::OnDataReceived,
                    weak_factory_.GetWeakPtr(), bytes_read_));
   } else if (!request_->status().is_io_pending()) {
-    OnError(base::PLATFORM_FILE_ERROR_FAILED);
+    OnError(base::File::FILE_ERROR_FAILED);
   }
 }
 
@@ -145,7 +145,7 @@ void FileWriterDelegate::Write() {
         base::Bind(&FileWriterDelegate::OnDataWritten,
                    weak_factory_.GetWeakPtr(), write_response));
   } else if (net::ERR_IO_PENDING != write_response) {
-    OnError(NetErrorToPlatformFileError(write_response));
+    OnError(NetErrorToFileError(write_response));
   }
 }
 
@@ -159,7 +159,7 @@ void FileWriterDelegate::OnDataWritten(int write_response) {
     else
       Write();
   } else {
-    OnError(NetErrorToPlatformFileError(write_response));
+    OnError(NetErrorToFileError(write_response));
   }
 }
 
@@ -168,7 +168,7 @@ FileWriterDelegate::GetCompletionStatusOnError() const {
   return writing_started_ ? ERROR_WRITE_STARTED : ERROR_WRITE_NOT_STARTED;
 }
 
-void FileWriterDelegate::OnError(base::PlatformFileError error) {
+void FileWriterDelegate::OnError(base::File::Error error) {
   if (request_) {
     request_->set_delegate(NULL);
     request_->Cancel();
@@ -192,10 +192,10 @@ void FileWriterDelegate::OnProgress(int bytes_written, bool done) {
     bytes_written_backlog_ = 0;
 
     if (done) {
-      FlushForCompletion(base::PLATFORM_FILE_OK, bytes_written,
+      FlushForCompletion(base::File::FILE_OK, bytes_written,
                          SUCCESS_COMPLETED);
     } else {
-      write_callback_.Run(base::PLATFORM_FILE_OK, bytes_written,
+      write_callback_.Run(base::File::FILE_OK, bytes_written,
                           SUCCESS_IO_PENDING);
     }
     return;
@@ -204,12 +204,12 @@ void FileWriterDelegate::OnProgress(int bytes_written, bool done) {
 }
 
 void FileWriterDelegate::OnWriteCancelled(int status) {
-  write_callback_.Run(base::PLATFORM_FILE_ERROR_ABORT, 0,
+  write_callback_.Run(base::File::FILE_ERROR_ABORT, 0,
                       GetCompletionStatusOnError());
 }
 
 void FileWriterDelegate::FlushForCompletion(
-    base::PlatformFileError error,
+    base::File::Error error,
     int bytes_written,
     WriteProgressStatus progress_status) {
   int flush_error = file_stream_writer_->Flush(
@@ -219,14 +219,14 @@ void FileWriterDelegate::FlushForCompletion(
     OnFlushed(error, bytes_written, progress_status, flush_error);
 }
 
-void FileWriterDelegate::OnFlushed(base::PlatformFileError error,
+void FileWriterDelegate::OnFlushed(base::File::Error error,
                                    int bytes_written,
                                    WriteProgressStatus progress_status,
                                    int flush_error) {
-  if (error == base::PLATFORM_FILE_OK && flush_error != net::OK) {
+  if (error == base::File::FILE_OK && flush_error != net::OK) {
     // If the Flush introduced an error, overwrite the status.
     // Otherwise, keep the original error status.
-    error = NetErrorToPlatformFileError(flush_error);
+    error = NetErrorToFileError(flush_error);
     progress_status = GetCompletionStatusOnError();
   }
   write_callback_.Run(error, bytes_written, progress_status);
diff --git a/webkit/browser/fileapi/file_writer_delegate.h b/webkit/browser/fileapi/file_writer_delegate.h
index f7ce16d..a5dcb57 100644
--- a/webkit/browser/fileapi/file_writer_delegate.h
+++ b/webkit/browser/fileapi/file_writer_delegate.h
@@ -5,10 +5,10 @@
 #ifndef WEBKIT_BROWSER_FILEAPI_FILE_WRITER_DELEGATE_H_
 #define WEBKIT_BROWSER_FILEAPI_FILE_WRITER_DELEGATE_H_
 
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
-#include "base/platform_file.h"
 #include "base/time/time.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
@@ -29,7 +29,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE FileWriterDelegate
     ERROR_WRITE_NOT_STARTED,
   };
 
-  typedef base::Callback<void(base::PlatformFileError result,
+  typedef base::Callback<void(base::File::Error result,
                               int64 bytes,
                               WriteProgressStatus write_status)>
       DelegateWriteCallback;
@@ -63,19 +63,19 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE FileWriterDelegate
  private:
   void OnGetFileInfoAndStartRequest(
       scoped_ptr<net::URLRequest> request,
-      base::PlatformFileError error,
-      const base::PlatformFileInfo& file_info);
+      base::File::Error error,
+      const base::File::Info& file_info);
   void Read();
   void OnDataReceived(int bytes_read);
   void Write();
   void OnDataWritten(int write_response);
-  void OnError(base::PlatformFileError error);
+  void OnError(base::File::Error error);
   void OnProgress(int bytes_read, bool done);
   void OnWriteCancelled(int status);
-  void FlushForCompletion(base::PlatformFileError error,
+  void FlushForCompletion(base::File::Error error,
                           int bytes_written,
                           WriteProgressStatus progress_status);
-  void OnFlushed(base::PlatformFileError error,
+  void OnFlushed(base::File::Error error,
                  int bytes_written,
                  WriteProgressStatus progress_status,
                  int flush_error);
diff --git a/webkit/browser/fileapi/isolated_file_system_backend.cc b/webkit/browser/fileapi/isolated_file_system_backend.cc
index f83ae15..cf70885 100644
--- a/webkit/browser/fileapi/isolated_file_system_backend.cc
+++ b/webkit/browser/fileapi/isolated_file_system_backend.cc
@@ -68,7 +68,7 @@ void IsolatedFileSystemBackend::OpenFileSystem(
       base::Bind(callback,
                  GetFileSystemRootURI(origin_url, type),
                  GetFileSystemName(origin_url, type),
-                 base::PLATFORM_FILE_ERROR_SECURITY));
+                 base::File::FILE_ERROR_SECURITY));
 }
 
 AsyncFileUtil* IsolatedFileSystemBackend::GetAsyncFileUtil(
@@ -88,16 +88,16 @@ AsyncFileUtil* IsolatedFileSystemBackend::GetAsyncFileUtil(
 
 CopyOrMoveFileValidatorFactory*
 IsolatedFileSystemBackend::GetCopyOrMoveFileValidatorFactory(
-    FileSystemType type, base::PlatformFileError* error_code) {
+    FileSystemType type, base::File::Error* error_code) {
   DCHECK(error_code);
-  *error_code = base::PLATFORM_FILE_OK;
+  *error_code = base::File::FILE_OK;
   return NULL;
 }
 
 FileSystemOperation* IsolatedFileSystemBackend::CreateFileSystemOperation(
     const FileSystemURL& url,
     FileSystemContext* context,
-    base::PlatformFileError* error_code) const {
+    base::File::Error* error_code) const {
   return FileSystemOperation::Create(
       url, context, make_scoped_ptr(new FileSystemOperationContext(context)));
 }
diff --git a/webkit/browser/fileapi/isolated_file_system_backend.h b/webkit/browser/fileapi/isolated_file_system_backend.h
index aa03844..a7284a3d 100644
--- a/webkit/browser/fileapi/isolated_file_system_backend.h
+++ b/webkit/browser/fileapi/isolated_file_system_backend.h
@@ -28,11 +28,11 @@ class IsolatedFileSystemBackend : public FileSystemBackend {
   virtual AsyncFileUtil* GetAsyncFileUtil(FileSystemType type) OVERRIDE;
   virtual CopyOrMoveFileValidatorFactory* GetCopyOrMoveFileValidatorFactory(
       FileSystemType type,
-      base::PlatformFileError* error_code) OVERRIDE;
+      base::File::Error* error_code) OVERRIDE;
   virtual FileSystemOperation* CreateFileSystemOperation(
       const FileSystemURL& url,
       FileSystemContext* context,
-      base::PlatformFileError* error_code) const OVERRIDE;
+      base::File::Error* error_code) const OVERRIDE;
   virtual scoped_ptr<webkit_blob::FileStreamReader> CreateFileStreamReader(
       const FileSystemURL& url,
       int64 offset,
diff --git a/webkit/browser/fileapi/local_file_util.cc b/webkit/browser/fileapi/local_file_util.cc
index 8f47859..032244f 100644
--- a/webkit/browser/fileapi/local_file_util.cc
+++ b/webkit/browser/fileapi/local_file_util.cc
@@ -22,8 +22,6 @@ AsyncFileUtil* AsyncFileUtil::CreateForLocalFileSystem() {
   return new AsyncFileUtilAdapter(new LocalFileUtil());
 }
 
-using base::PlatformFileError;
-
 class LocalFileEnumerator : public FileSystemFileUtil::AbstractFileEnumerator {
  public:
   LocalFileEnumerator(const base::FilePath& platform_root_path,
@@ -78,64 +76,66 @@ LocalFileUtil::LocalFileUtil() {}
 
 LocalFileUtil::~LocalFileUtil() {}
 
-PlatformFileError LocalFileUtil::CreateOrOpen(
+base::File::Error LocalFileUtil::CreateOrOpen(
     FileSystemOperationContext* context,
     const FileSystemURL& url, int file_flags,
     base::PlatformFile* file_handle, bool* created) {
   *created = false;
   base::FilePath file_path;
-  PlatformFileError error = GetLocalFilePath(context, url, &file_path);
-  if (error != base::PLATFORM_FILE_OK)
+  base::File::Error error = GetLocalFilePath(context, url, &file_path);
+  if (error != base::File::FILE_OK)
     return error;
   // Disallow opening files in symlinked paths.
   if (base::IsLink(file_path))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  return NativeFileUtil::CreateOrOpen(
-      file_path, file_flags, file_handle, created);
+    return base::File::FILE_ERROR_NOT_FOUND;
+
+  return NativeFileUtil::CreateOrOpen(file_path, file_flags, file_handle,
+                                      created);
 }
 
-PlatformFileError LocalFileUtil::Close(FileSystemOperationContext* context,
+base::File::Error LocalFileUtil::Close(FileSystemOperationContext* context,
                                        base::PlatformFile file) {
   return NativeFileUtil::Close(file);
 }
 
-PlatformFileError LocalFileUtil::EnsureFileExists(
+base::File::Error LocalFileUtil::EnsureFileExists(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     bool* created) {
   base::FilePath file_path;
-  PlatformFileError error = GetLocalFilePath(context, url, &file_path);
-  if (error != base::PLATFORM_FILE_OK)
+  base::File::Error error = GetLocalFilePath(context, url, &file_path);
+  if (error != base::File::FILE_OK)
     return error;
   return NativeFileUtil::EnsureFileExists(file_path, created);
 }
 
-PlatformFileError LocalFileUtil::CreateDirectory(
+base::File::Error LocalFileUtil::CreateDirectory(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     bool exclusive,
     bool recursive) {
   base::FilePath file_path;
-  PlatformFileError error = GetLocalFilePath(context, url, &file_path);
-  if (error != base::PLATFORM_FILE_OK)
+  base::File::Error error = GetLocalFilePath(context, url, &file_path);
+  if (error != base::File::FILE_OK)
     return error;
   return NativeFileUtil::CreateDirectory(file_path, exclusive, recursive);
 }
 
-PlatformFileError LocalFileUtil::GetFileInfo(
+base::File::Error LocalFileUtil::GetFileInfo(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
-    base::PlatformFileInfo* file_info,
+    base::File::Info* file_info,
     base::FilePath* platform_file_path) {
   base::FilePath file_path;
-  PlatformFileError error = GetLocalFilePath(context, url, &file_path);
-  if (error != base::PLATFORM_FILE_OK)
+  base::File::Error error = GetLocalFilePath(context, url, &file_path);
+  if (error != base::File::FILE_OK)
     return error;
   // We should not follow symbolic links in sandboxed file system.
   if (base::IsLink(file_path))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
+
   error = NativeFileUtil::GetFileInfo(file_path, file_info);
-  if (error == base::PLATFORM_FILE_OK)
+  if (error == base::File::FILE_OK)
     *platform_file_path = file_path;
   return error;
 }
@@ -146,7 +146,7 @@ scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> LocalFileUtil::
         const FileSystemURL& root_url) {
   base::FilePath file_path;
   if (GetLocalFilePath(context, root_url, &file_path) !=
-      base::PLATFORM_FILE_OK) {
+      base::File::FILE_OK) {
     return make_scoped_ptr(new EmptyFileEnumerator)
         .PassAs<FileSystemFileUtil::AbstractFileEnumerator>();
   }
@@ -156,7 +156,7 @@ scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> LocalFileUtil::
       .PassAs<FileSystemFileUtil::AbstractFileEnumerator>();
 }
 
-PlatformFileError LocalFileUtil::GetLocalFilePath(
+base::File::Error LocalFileUtil::GetLocalFilePath(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     base::FilePath* local_file_path) {
@@ -164,49 +164,49 @@ PlatformFileError LocalFileUtil::GetLocalFilePath(
   DCHECK(url.is_valid());
   if (url.path().empty()) {
     // Root direcory case, which should not be accessed.
-    return base::PLATFORM_FILE_ERROR_ACCESS_DENIED;
+    return base::File::FILE_ERROR_ACCESS_DENIED;
   }
   *local_file_path = url.path();
-  return base::PLATFORM_FILE_OK;
+  return base::File::FILE_OK;
 }
 
-PlatformFileError LocalFileUtil::Touch(
+base::File::Error LocalFileUtil::Touch(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time) {
   base::FilePath file_path;
-  PlatformFileError error = GetLocalFilePath(context, url, &file_path);
-  if (error != base::PLATFORM_FILE_OK)
+  base::File::Error error = GetLocalFilePath(context, url, &file_path);
+  if (error != base::File::FILE_OK)
     return error;
   return NativeFileUtil::Touch(file_path, last_access_time, last_modified_time);
 }
 
-PlatformFileError LocalFileUtil::Truncate(
+base::File::Error LocalFileUtil::Truncate(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     int64 length) {
   base::FilePath file_path;
-  PlatformFileError error = GetLocalFilePath(context, url, &file_path);
-  if (error != base::PLATFORM_FILE_OK)
+  base::File::Error error = GetLocalFilePath(context, url, &file_path);
+  if (error != base::File::FILE_OK)
     return error;
   return NativeFileUtil::Truncate(file_path, length);
 }
 
-PlatformFileError LocalFileUtil::CopyOrMoveFile(
+base::File::Error LocalFileUtil::CopyOrMoveFile(
     FileSystemOperationContext* context,
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     bool copy) {
   base::FilePath src_file_path;
-  PlatformFileError error = GetLocalFilePath(context, src_url, &src_file_path);
-  if (error != base::PLATFORM_FILE_OK)
+  base::File::Error error = GetLocalFilePath(context, src_url, &src_file_path);
+  if (error != base::File::FILE_OK)
     return error;
 
   base::FilePath dest_file_path;
   error = GetLocalFilePath(context, dest_url, &dest_file_path);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return error;
 
   return NativeFileUtil::CopyOrMoveFile(
@@ -214,17 +214,17 @@ PlatformFileError LocalFileUtil::CopyOrMoveFile(
       fileapi::NativeFileUtil::CopyOrMoveModeForDestination(dest_url, copy));
 }
 
-PlatformFileError LocalFileUtil::CopyInForeignFile(
+base::File::Error LocalFileUtil::CopyInForeignFile(
     FileSystemOperationContext* context,
     const base::FilePath& src_file_path,
     const FileSystemURL& dest_url) {
   if (src_file_path.empty())
-    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+    return base::File::FILE_ERROR_INVALID_OPERATION;
 
   base::FilePath dest_file_path;
-  PlatformFileError error =
+  base::File::Error error =
       GetLocalFilePath(context, dest_url, &dest_file_path);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return error;
   return NativeFileUtil::CopyOrMoveFile(
       src_file_path, dest_file_path, FileSystemOperation::OPTION_NONE,
@@ -232,22 +232,22 @@ PlatformFileError LocalFileUtil::CopyInForeignFile(
                                                             true /* copy */));
 }
 
-PlatformFileError LocalFileUtil::DeleteFile(
+base::File::Error LocalFileUtil::DeleteFile(
     FileSystemOperationContext* context,
     const FileSystemURL& url) {
   base::FilePath file_path;
-  PlatformFileError error = GetLocalFilePath(context, url, &file_path);
-  if (error != base::PLATFORM_FILE_OK)
+  base::File::Error error = GetLocalFilePath(context, url, &file_path);
+  if (error != base::File::FILE_OK)
     return error;
   return NativeFileUtil::DeleteFile(file_path);
 }
 
-PlatformFileError LocalFileUtil::DeleteDirectory(
+base::File::Error LocalFileUtil::DeleteDirectory(
     FileSystemOperationContext* context,
     const FileSystemURL& url) {
   base::FilePath file_path;
-  PlatformFileError error = GetLocalFilePath(context, url, &file_path);
-  if (error != base::PLATFORM_FILE_OK)
+  base::File::Error error = GetLocalFilePath(context, url, &file_path);
+  if (error != base::File::FILE_OK)
     return error;
   return NativeFileUtil::DeleteDirectory(file_path);
 }
@@ -255,14 +255,14 @@ PlatformFileError LocalFileUtil::DeleteDirectory(
 webkit_blob::ScopedFile LocalFileUtil::CreateSnapshotFile(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
-    base::PlatformFileError* error,
-    base::PlatformFileInfo* file_info,
+    base::File::Error* error,
+    base::File::Info* file_info,
     base::FilePath* platform_path) {
   DCHECK(file_info);
   // We're just returning the local file information.
   *error = GetFileInfo(context, url, file_info, platform_path);
-  if (*error == base::PLATFORM_FILE_OK && file_info->is_directory)
-    *error = base::PLATFORM_FILE_ERROR_NOT_A_FILE;
+  if (*error == base::File::FILE_OK && file_info->is_directory)
+    *error = base::File::FILE_ERROR_NOT_A_FILE;
   return webkit_blob::ScopedFile();
 }
 
diff --git a/webkit/browser/fileapi/local_file_util.h b/webkit/browser/fileapi/local_file_util.h
index 21efc72..b5220b0 100644
--- a/webkit/browser/fileapi/local_file_util.h
+++ b/webkit/browser/fileapi/local_file_util.h
@@ -30,65 +30,65 @@ class WEBKIT_STORAGE_BROWSER_EXPORT LocalFileUtil
   LocalFileUtil();
   virtual ~LocalFileUtil();
 
-  virtual base::PlatformFileError CreateOrOpen(
+  virtual base::File::Error CreateOrOpen(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       int file_flags,
       base::PlatformFile* file_handle,
       bool* created) OVERRIDE;
-  virtual base::PlatformFileError Close(
+  virtual base::File::Error Close(
       FileSystemOperationContext* context,
       base::PlatformFile file) OVERRIDE;
-  virtual base::PlatformFileError EnsureFileExists(
+  virtual base::File::Error EnsureFileExists(
       FileSystemOperationContext* context,
       const FileSystemURL& url, bool* created) OVERRIDE;
-  virtual base::PlatformFileError CreateDirectory(
+  virtual base::File::Error CreateDirectory(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       bool exclusive,
       bool recursive) OVERRIDE;
-  virtual base::PlatformFileError GetFileInfo(
+  virtual base::File::Error GetFileInfo(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
-      base::PlatformFileInfo* file_info,
+      base::File::Info* file_info,
       base::FilePath* platform_file) OVERRIDE;
   virtual scoped_ptr<AbstractFileEnumerator> CreateFileEnumerator(
       FileSystemOperationContext* context,
       const FileSystemURL& root_url) OVERRIDE;
-  virtual base::PlatformFileError GetLocalFilePath(
+  virtual base::File::Error GetLocalFilePath(
       FileSystemOperationContext* context,
       const FileSystemURL& file_system_url,
       base::FilePath* local_file_path) OVERRIDE;
-  virtual base::PlatformFileError Touch(
+  virtual base::File::Error Touch(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       const base::Time& last_access_time,
       const base::Time& last_modified_time) OVERRIDE;
-  virtual base::PlatformFileError Truncate(
+  virtual base::File::Error Truncate(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       int64 length) OVERRIDE;
-  virtual base::PlatformFileError CopyOrMoveFile(
+  virtual base::File::Error CopyOrMoveFile(
       FileSystemOperationContext* context,
       const FileSystemURL& src_url,
       const FileSystemURL& dest_url,
       CopyOrMoveOption option,
       bool copy) OVERRIDE;
-  virtual base::PlatformFileError CopyInForeignFile(
+  virtual base::File::Error CopyInForeignFile(
       FileSystemOperationContext* context,
       const base::FilePath& src_file_path,
       const FileSystemURL& dest_url) OVERRIDE;
-  virtual base::PlatformFileError DeleteFile(
+  virtual base::File::Error DeleteFile(
       FileSystemOperationContext* context,
       const FileSystemURL& url) OVERRIDE;
-  virtual base::PlatformFileError DeleteDirectory(
+  virtual base::File::Error DeleteDirectory(
       FileSystemOperationContext* context,
       const FileSystemURL& url) OVERRIDE;
   virtual webkit_blob::ScopedFile CreateSnapshotFile(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
-      base::PlatformFileError* error,
-      base::PlatformFileInfo* file_info,
+      base::File::Error* error,
+      base::File::Info* file_info,
       base::FilePath* platform_path) OVERRIDE;
 
  private:
diff --git a/webkit/browser/fileapi/native_file_util.cc b/webkit/browser/fileapi/native_file_util.cc
index e13d8e7..e99e297 100644
--- a/webkit/browser/fileapi/native_file_util.cc
+++ b/webkit/browser/fileapi/native_file_util.cc
@@ -73,7 +73,6 @@ bool CopyFileAndSync(const base::FilePath& from, const base::FilePath& to) {
 }  // namespace
 
 using base::PlatformFile;
-using base::PlatformFileError;
 
 class NativeFileEnumerator : public FileSystemFileUtil::AbstractFileEnumerator {
  public:
@@ -123,69 +122,74 @@ NativeFileUtil::CopyOrMoveMode NativeFileUtil::CopyOrMoveModeForDestination(
   return MOVE;
 }
 
-PlatformFileError NativeFileUtil::CreateOrOpen(
+base::File::Error NativeFileUtil::CreateOrOpen(
     const base::FilePath& path, int file_flags,
     PlatformFile* file_handle, bool* created) {
   if (!base::DirectoryExists(path.DirName())) {
     // If its parent does not exist, should return NOT_FOUND error.
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
   }
   if (base::DirectoryExists(path))
-    return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
-  PlatformFileError error_code = base::PLATFORM_FILE_OK;
+    return base::File::FILE_ERROR_NOT_A_FILE;
+
+  // TODO(rvargas): convert this code to use base::File.
+  base::PlatformFileError error_code = base::PLATFORM_FILE_OK;
   *file_handle = base::CreatePlatformFile(path, file_flags,
                                           created, &error_code);
-  return error_code;
+  return static_cast<base::File::Error>(error_code);
 }
 
-PlatformFileError NativeFileUtil::Close(PlatformFile file_handle) {
+base::File::Error NativeFileUtil::Close(PlatformFile file_handle) {
   if (!base::ClosePlatformFile(file_handle))
-    return base::PLATFORM_FILE_ERROR_FAILED;
-  return base::PLATFORM_FILE_OK;
+    return base::File::FILE_ERROR_FAILED;
+  return base::File::FILE_OK;
 }
 
-PlatformFileError NativeFileUtil::EnsureFileExists(
+base::File::Error NativeFileUtil::EnsureFileExists(
     const base::FilePath& path,
     bool* created) {
   if (!base::DirectoryExists(path.DirName()))
     // If its parent does not exist, should return NOT_FOUND error.
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  PlatformFileError error_code = base::PLATFORM_FILE_OK;
+    return base::File::FILE_ERROR_NOT_FOUND;
+
   // Tries to create the |path| exclusively.  This should fail
-  // with base::PLATFORM_FILE_ERROR_EXISTS if the path already exists.
-  PlatformFile handle = base::CreatePlatformFile(
-      path,
-      base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_READ,
-      created, &error_code);
-  if (error_code == base::PLATFORM_FILE_ERROR_EXISTS) {
+  // with base::File::FILE_ERROR_EXISTS if the path already exists.
+  base::File file(path, base::File::FLAG_CREATE | base::File::FLAG_READ);
+
+  if (file.IsValid()) {
+    if (created)
+      *created = file.created();
+    return base::File::FILE_OK;
+  }
+
+  base::File::Error error_code = file.error_details();
+  if (error_code == base::File::FILE_ERROR_EXISTS) {
     // Make sure created_ is false.
     if (created)
       *created = false;
-    error_code = base::PLATFORM_FILE_OK;
+    error_code = base::File::FILE_OK;
   }
-  if (handle != base::kInvalidPlatformFileValue)
-    base::ClosePlatformFile(handle);
   return error_code;
 }
 
-PlatformFileError NativeFileUtil::CreateDirectory(
+base::File::Error NativeFileUtil::CreateDirectory(
     const base::FilePath& path,
     bool exclusive,
     bool recursive) {
   // If parent dir of file doesn't exist.
   if (!recursive && !base::PathExists(path.DirName()))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
 
   bool path_exists = base::PathExists(path);
   if (exclusive && path_exists)
-    return base::PLATFORM_FILE_ERROR_EXISTS;
+    return base::File::FILE_ERROR_EXISTS;
 
   // If file exists at the path.
   if (path_exists && !base::DirectoryExists(path))
-    return base::PLATFORM_FILE_ERROR_EXISTS;
+    return base::File::FILE_ERROR_EXISTS;
 
   if (!base::CreateDirectory(path))
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
 
   if (!SetPlatformSpecificDirectoryPermissions(path)) {
     // Since some file systems don't support permission setting, we do not treat
@@ -194,19 +198,18 @@ PlatformFileError NativeFileUtil::CreateDirectory(
         << path.AsUTF8Unsafe();
   }
 
-  return base::PLATFORM_FILE_OK;
+  return base::File::FILE_OK;
 }
 
-PlatformFileError NativeFileUtil::GetFileInfo(
+base::File::Error NativeFileUtil::GetFileInfo(
     const base::FilePath& path,
-    base::PlatformFileInfo* file_info) {
+    base::File::Info* file_info) {
   if (!base::PathExists(path))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
 
-  // TODO(rvargas): convert this code to use base::File.
-  if (!base::GetFileInfo(path, reinterpret_cast<base::File::Info*>(file_info)))
-    return base::PLATFORM_FILE_ERROR_FAILED;
-  return base::PLATFORM_FILE_OK;
+  if (!base::GetFileInfo(path, file_info))
+    return base::File::FILE_ERROR_FAILED;
+  return base::File::FILE_OK;
 }
 
 scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator>
@@ -218,32 +221,25 @@ scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator>
       .PassAs<FileSystemFileUtil::AbstractFileEnumerator>();
 }
 
-PlatformFileError NativeFileUtil::Touch(
+base::File::Error NativeFileUtil::Touch(
     const base::FilePath& path,
     const base::Time& last_access_time,
     const base::Time& last_modified_time) {
   if (!base::TouchFile(path, last_access_time, last_modified_time))
-    return base::PLATFORM_FILE_ERROR_FAILED;
-  return base::PLATFORM_FILE_OK;
+    return base::File::FILE_ERROR_FAILED;
+  return base::File::FILE_OK;
 }
 
-PlatformFileError NativeFileUtil::Truncate(
-    const base::FilePath& path, int64 length) {
-  PlatformFileError error_code(base::PLATFORM_FILE_ERROR_FAILED);
-  PlatformFile file =
-      base::CreatePlatformFile(
-          path,
-          base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE,
-          NULL,
-          &error_code);
-  if (error_code != base::PLATFORM_FILE_OK) {
-    return error_code;
-  }
-  DCHECK_NE(base::kInvalidPlatformFileValue, file);
-  if (!base::TruncatePlatformFile(file, length))
-    error_code = base::PLATFORM_FILE_ERROR_FAILED;
-  base::ClosePlatformFile(file);
-  return error_code;
+base::File::Error NativeFileUtil::Truncate(const base::FilePath& path,
+                                           int64 length) {
+  base::File file(path, base::File::FLAG_OPEN | base::File::FLAG_WRITE);
+  if (!file.IsValid())
+    return file.error_details();
+
+  if (!file.SetLength(length))
+    return base::File::FILE_ERROR_FAILED;
+
+  return base::File::FILE_OK;
 }
 
 bool NativeFileUtil::PathExists(const base::FilePath& path) {
@@ -254,45 +250,45 @@ bool NativeFileUtil::DirectoryExists(const base::FilePath& path) {
   return base::DirectoryExists(path);
 }
 
-PlatformFileError NativeFileUtil::CopyOrMoveFile(
+base::File::Error NativeFileUtil::CopyOrMoveFile(
     const base::FilePath& src_path,
     const base::FilePath& dest_path,
     FileSystemOperation::CopyOrMoveOption option,
     CopyOrMoveMode mode) {
-  base::PlatformFileInfo info;
-  base::PlatformFileError error = NativeFileUtil::GetFileInfo(src_path, &info);
-  if (error != base::PLATFORM_FILE_OK)
+  base::File::Info info;
+  base::File::Error error = NativeFileUtil::GetFileInfo(src_path, &info);
+  if (error != base::File::FILE_OK)
     return error;
   if (info.is_directory)
-    return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
+    return base::File::FILE_ERROR_NOT_A_FILE;
   base::Time last_modified = info.last_modified;
 
   error = NativeFileUtil::GetFileInfo(dest_path, &info);
-  if (error != base::PLATFORM_FILE_OK &&
-      error != base::PLATFORM_FILE_ERROR_NOT_FOUND)
+  if (error != base::File::FILE_OK &&
+      error != base::File::FILE_ERROR_NOT_FOUND)
     return error;
   if (info.is_directory)
-    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND) {
+    return base::File::FILE_ERROR_INVALID_OPERATION;
+  if (error == base::File::FILE_ERROR_NOT_FOUND) {
     error = NativeFileUtil::GetFileInfo(dest_path.DirName(), &info);
-    if (error != base::PLATFORM_FILE_OK)
+    if (error != base::File::FILE_OK)
       return error;
     if (!info.is_directory)
-      return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+      return base::File::FILE_ERROR_NOT_FOUND;
   }
 
   switch (mode) {
     case COPY_NOSYNC:
       if (!base::CopyFile(src_path, dest_path))
-        return base::PLATFORM_FILE_ERROR_FAILED;
+        return base::File::FILE_ERROR_FAILED;
       break;
     case COPY_SYNC:
       if (!CopyFileAndSync(src_path, dest_path))
-        return base::PLATFORM_FILE_ERROR_FAILED;
+        return base::File::FILE_ERROR_FAILED;
       break;
     case MOVE:
       if (!base::Move(src_path, dest_path))
-        return base::PLATFORM_FILE_ERROR_FAILED;
+        return base::File::FILE_ERROR_FAILED;
       break;
   }
 
@@ -301,29 +297,29 @@ PlatformFileError NativeFileUtil::CopyOrMoveFile(
   if (option == FileSystemOperation::OPTION_PRESERVE_LAST_MODIFIED)
     base::TouchFile(dest_path, last_modified, last_modified);
 
-  return base::PLATFORM_FILE_OK;
+  return base::File::FILE_OK;
 }
 
-PlatformFileError NativeFileUtil::DeleteFile(const base::FilePath& path) {
+base::File::Error NativeFileUtil::DeleteFile(const base::FilePath& path) {
   if (!base::PathExists(path))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
   if (base::DirectoryExists(path))
-    return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
+    return base::File::FILE_ERROR_NOT_A_FILE;
   if (!base::DeleteFile(path, false))
-    return base::PLATFORM_FILE_ERROR_FAILED;
-  return base::PLATFORM_FILE_OK;
+    return base::File::FILE_ERROR_FAILED;
+  return base::File::FILE_OK;
 }
 
-PlatformFileError NativeFileUtil::DeleteDirectory(const base::FilePath& path) {
+base::File::Error NativeFileUtil::DeleteDirectory(const base::FilePath& path) {
   if (!base::PathExists(path))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
   if (!base::DirectoryExists(path))
-    return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
+    return base::File::FILE_ERROR_NOT_A_DIRECTORY;
   if (!base::IsDirectoryEmpty(path))
-    return base::PLATFORM_FILE_ERROR_NOT_EMPTY;
+    return base::File::FILE_ERROR_NOT_EMPTY;
   if (!base::DeleteFile(path, false))
-    return base::PLATFORM_FILE_ERROR_FAILED;
-  return base::PLATFORM_FILE_OK;
+    return base::File::FILE_ERROR_FAILED;
+  return base::File::FILE_OK;
 }
 
 }  // namespace fileapi
diff --git a/webkit/browser/fileapi/native_file_util.h b/webkit/browser/fileapi/native_file_util.h
index 4c36e5f..7069c02 100644
--- a/webkit/browser/fileapi/native_file_util.h
+++ b/webkit/browser/fileapi/native_file_util.h
@@ -5,6 +5,7 @@
 #ifndef WEBKIT_BROWSER_FILEAPI_NATIVE_FILE_UTIL_H_
 #define WEBKIT_BROWSER_FILEAPI_NATIVE_FILE_UTIL_H_
 
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util_proxy.h"
 #include "base/memory/scoped_ptr.h"
@@ -38,36 +39,36 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE NativeFileUtil {
   static CopyOrMoveMode CopyOrMoveModeForDestination(
       const FileSystemURL& dest_url, bool copy);
 
-  static base::PlatformFileError CreateOrOpen(
+  static base::File::Error CreateOrOpen(
       const base::FilePath& path,
       int file_flags,
       base::PlatformFile* file_handle,
       bool* created);
-  static base::PlatformFileError Close(base::PlatformFile file);
-  static base::PlatformFileError EnsureFileExists(const base::FilePath& path,
-                                                  bool* created);
-  static base::PlatformFileError CreateDirectory(const base::FilePath& path,
-                                                 bool exclusive,
-                                                 bool recursive);
-  static base::PlatformFileError GetFileInfo(const base::FilePath& path,
-                                             base::PlatformFileInfo* file_info);
+  static base::File::Error Close(base::PlatformFile file);
+  static base::File::Error EnsureFileExists(const base::FilePath& path,
+                                            bool* created);
+  static base::File::Error CreateDirectory(const base::FilePath& path,
+                                           bool exclusive,
+                                           bool recursive);
+  static base::File::Error GetFileInfo(const base::FilePath& path,
+                                       base::File::Info* file_info);
   static scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator>
       CreateFileEnumerator(const base::FilePath& root_path,
                            bool recursive);
-  static base::PlatformFileError Touch(const base::FilePath& path,
-                                       const base::Time& last_access_time,
-                                       const base::Time& last_modified_time);
-  static base::PlatformFileError Truncate(const base::FilePath& path,
+  static base::File::Error Touch(const base::FilePath& path,
+                                 const base::Time& last_access_time,
+                                 const base::Time& last_modified_time);
+  static base::File::Error Truncate(const base::FilePath& path,
                                           int64 length);
   static bool PathExists(const base::FilePath& path);
   static bool DirectoryExists(const base::FilePath& path);
-  static base::PlatformFileError CopyOrMoveFile(
+  static base::File::Error CopyOrMoveFile(
       const base::FilePath& src_path,
       const base::FilePath& dest_path,
       FileSystemOperation::CopyOrMoveOption option,
       CopyOrMoveMode mode);
-  static base::PlatformFileError DeleteFile(const base::FilePath& path);
-  static base::PlatformFileError DeleteDirectory(const base::FilePath& path);
+  static base::File::Error DeleteFile(const base::FilePath& path);
+  static base::File::Error DeleteDirectory(const base::FilePath& path);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(NativeFileUtil);
diff --git a/webkit/browser/fileapi/native_file_util_unittest.cc b/webkit/browser/fileapi/native_file_util_unittest.cc
index 587bf9a..cdf088f 100644
--- a/webkit/browser/fileapi/native_file_util_unittest.cc
+++ b/webkit/browser/fileapi/native_file_util_unittest.cc
@@ -52,7 +52,7 @@ TEST_F(NativeFileUtilTest, CreateCloseAndDeleteFile) {
   base::PlatformFile file_handle;
   bool created = false;
   int flags = base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_ASYNC;
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CreateOrOpen(file_name,
                                          base::PLATFORM_FILE_CREATE | flags,
                                          &file_handle, &created));
@@ -63,16 +63,16 @@ TEST_F(NativeFileUtilTest, CreateCloseAndDeleteFile) {
   EXPECT_EQ(0, GetSize(file_name));
   EXPECT_NE(base::kInvalidPlatformFileValue, file_handle);
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK, NativeFileUtil::Close(file_handle));
+  ASSERT_EQ(base::File::FILE_OK, NativeFileUtil::Close(file_handle));
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CreateOrOpen(file_name,
                                          base::PLATFORM_FILE_OPEN | flags,
                                          &file_handle, &created));
   ASSERT_FALSE(created);
-  ASSERT_EQ(base::PLATFORM_FILE_OK, NativeFileUtil::Close(file_handle));
+  ASSERT_EQ(base::File::FILE_OK, NativeFileUtil::Close(file_handle));
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::DeleteFile(file_name));
   EXPECT_FALSE(base::PathExists(file_name));
   EXPECT_FALSE(NativeFileUtil::PathExists(file_name));
@@ -81,21 +81,21 @@ TEST_F(NativeFileUtilTest, CreateCloseAndDeleteFile) {
 TEST_F(NativeFileUtilTest, EnsureFileExists) {
   base::FilePath file_name = Path("foobar");
   bool created = false;
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::EnsureFileExists(file_name, &created));
   ASSERT_TRUE(created);
 
   EXPECT_TRUE(FileExists(file_name));
   EXPECT_EQ(0, GetSize(file_name));
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::EnsureFileExists(file_name, &created));
   EXPECT_FALSE(created);
 }
 
 TEST_F(NativeFileUtilTest, CreateAndDeleteDirectory) {
   base::FilePath dir_name = Path("test_dir");
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CreateDirectory(dir_name,
                                             false /* exclusive */,
                                             false /* recursive */));
@@ -103,12 +103,12 @@ TEST_F(NativeFileUtilTest, CreateAndDeleteDirectory) {
   EXPECT_TRUE(NativeFileUtil::DirectoryExists(dir_name));
   EXPECT_TRUE(base::DirectoryExists(dir_name));
 
-  ASSERT_EQ(base::PLATFORM_FILE_ERROR_EXISTS,
+  ASSERT_EQ(base::File::FILE_ERROR_EXISTS,
             NativeFileUtil::CreateDirectory(dir_name,
                                             true /* exclusive */,
                                             false /* recursive */));
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::DeleteDirectory(dir_name));
   EXPECT_FALSE(base::DirectoryExists(dir_name));
   EXPECT_FALSE(NativeFileUtil::DirectoryExists(dir_name));
@@ -116,18 +116,18 @@ TEST_F(NativeFileUtilTest, CreateAndDeleteDirectory) {
 
 TEST_F(NativeFileUtilTest, TouchFileAndGetFileInfo) {
   base::FilePath file_name = Path("test_file");
-  base::PlatformFileInfo native_info;
-  ASSERT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  base::File::Info native_info;
+  ASSERT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             NativeFileUtil::GetFileInfo(file_name, &native_info));
 
   bool created = false;
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::EnsureFileExists(file_name, &created));
   ASSERT_TRUE(created);
 
   base::File::Info info;
   ASSERT_TRUE(base::GetFileInfo(file_name, &info));
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::GetFileInfo(file_name, &native_info));
   ASSERT_EQ(info.size, native_info.size);
   ASSERT_EQ(info.is_directory, native_info.is_directory);
@@ -141,7 +141,7 @@ TEST_F(NativeFileUtilTest, TouchFileAndGetFileInfo) {
   const base::Time new_modified =
       info.last_modified + base::TimeDelta::FromHours(5);
 
-  EXPECT_EQ(base::PLATFORM_FILE_OK,
+  EXPECT_EQ(base::File::FILE_OK,
             NativeFileUtil::Touch(file_name,
                                   new_accessed, new_modified));
 
@@ -157,16 +157,16 @@ TEST_F(NativeFileUtilTest, CreateFileEnumerator) {
   base::FilePath path_12 = Path("dir1").AppendASCII("dir12");
   base::FilePath path_121 =
       Path("dir1").AppendASCII("dir12").AppendASCII("file121");
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CreateDirectory(path_1, false, false));
   bool created = false;
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::EnsureFileExists(path_2, &created));
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::EnsureFileExists(path_11, &created));
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CreateDirectory(path_12, false, false));
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::EnsureFileExists(path_121, &created));
 
   {
@@ -200,11 +200,11 @@ TEST_F(NativeFileUtilTest, CreateFileEnumerator) {
 TEST_F(NativeFileUtilTest, Truncate) {
   base::FilePath file_name = Path("truncated");
   bool created = false;
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::EnsureFileExists(file_name, &created));
   ASSERT_TRUE(created);
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::Truncate(file_name, 1020));
 
   EXPECT_TRUE(FileExists(file_name));
@@ -218,21 +218,21 @@ TEST_F(NativeFileUtilTest, CopyFile) {
   const NativeFileUtil::CopyOrMoveMode nosync = NativeFileUtil::COPY_NOSYNC;
   const NativeFileUtil::CopyOrMoveMode sync = NativeFileUtil::COPY_SYNC;
   bool created = false;
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::EnsureFileExists(from_file, &created));
   ASSERT_TRUE(created);
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::Truncate(from_file, 1020));
 
   EXPECT_TRUE(FileExists(from_file));
   EXPECT_EQ(1020, GetSize(from_file));
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CopyOrMoveFile(
                 from_file, to_file1, FileSystemOperation::OPTION_NONE, nosync));
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CopyOrMoveFile(
                 from_file, to_file2, FileSystemOperation::OPTION_NONE, sync));
 
@@ -244,11 +244,11 @@ TEST_F(NativeFileUtilTest, CopyFile) {
   EXPECT_EQ(1020, GetSize(to_file2));
 
   base::FilePath dir = Path("dir");
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CreateDirectory(dir, false, false));
   ASSERT_TRUE(base::DirectoryExists(dir));
   base::FilePath to_dir_file = dir.AppendASCII("file");
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CopyOrMoveFile(
                 from_file, to_dir_file,
                 FileSystemOperation::OPTION_NONE, nosync));
@@ -257,26 +257,26 @@ TEST_F(NativeFileUtilTest, CopyFile) {
 
   // Following tests are error checking.
   // Source doesn't exist.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             NativeFileUtil::CopyOrMoveFile(
                 Path("nonexists"), Path("file"),
                 FileSystemOperation::OPTION_NONE, nosync));
 
   // Source is not a file.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_FILE,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_A_FILE,
             NativeFileUtil::CopyOrMoveFile(
                 dir, Path("file"), FileSystemOperation::OPTION_NONE, nosync));
   // Destination is not a file.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION,
+  EXPECT_EQ(base::File::FILE_ERROR_INVALID_OPERATION,
             NativeFileUtil::CopyOrMoveFile(
                 from_file, dir, FileSystemOperation::OPTION_NONE, nosync));
   // Destination's parent doesn't exist.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             NativeFileUtil::CopyOrMoveFile(
                 from_file, Path("nodir").AppendASCII("file"),
                 FileSystemOperation::OPTION_NONE, nosync));
   // Destination's parent is a file.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             NativeFileUtil::CopyOrMoveFile(
                 from_file, Path("tofile1").AppendASCII("file"),
                 FileSystemOperation::OPTION_NONE, nosync));
@@ -287,16 +287,16 @@ TEST_F(NativeFileUtilTest, MoveFile) {
   base::FilePath to_file = Path("tofile");
   const NativeFileUtil::CopyOrMoveMode move = NativeFileUtil::MOVE;
   bool created = false;
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::EnsureFileExists(from_file, &created));
   ASSERT_TRUE(created);
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK, NativeFileUtil::Truncate(from_file, 1020));
+  ASSERT_EQ(base::File::FILE_OK, NativeFileUtil::Truncate(from_file, 1020));
 
   EXPECT_TRUE(FileExists(from_file));
   EXPECT_EQ(1020, GetSize(from_file));
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CopyOrMoveFile(
                 from_file, to_file, FileSystemOperation::OPTION_NONE, move));
 
@@ -304,17 +304,17 @@ TEST_F(NativeFileUtilTest, MoveFile) {
   EXPECT_TRUE(FileExists(to_file));
   EXPECT_EQ(1020, GetSize(to_file));
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::EnsureFileExists(from_file, &created));
   ASSERT_TRUE(FileExists(from_file));
-  ASSERT_EQ(base::PLATFORM_FILE_OK, NativeFileUtil::Truncate(from_file, 1020));
+  ASSERT_EQ(base::File::FILE_OK, NativeFileUtil::Truncate(from_file, 1020));
 
   base::FilePath dir = Path("dir");
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CreateDirectory(dir, false, false));
   ASSERT_TRUE(base::DirectoryExists(dir));
   base::FilePath to_dir_file = dir.AppendASCII("file");
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CopyOrMoveFile(
                 from_file, to_dir_file,
                 FileSystemOperation::OPTION_NONE, move));
@@ -324,33 +324,33 @@ TEST_F(NativeFileUtilTest, MoveFile) {
 
   // Following is error checking.
   // Source doesn't exist.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             NativeFileUtil::CopyOrMoveFile(
                 Path("nonexists"), Path("file"),
                 FileSystemOperation::OPTION_NONE, move));
 
   // Source is not a file.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_FILE,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_A_FILE,
             NativeFileUtil::CopyOrMoveFile(
                 dir, Path("file"), FileSystemOperation::OPTION_NONE, move));
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::EnsureFileExists(from_file, &created));
   ASSERT_TRUE(FileExists(from_file));
   // Destination is not a file.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION,
+  EXPECT_EQ(base::File::FILE_ERROR_INVALID_OPERATION,
             NativeFileUtil::CopyOrMoveFile(
                 from_file, dir, FileSystemOperation::OPTION_NONE, move));
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::EnsureFileExists(from_file, &created));
   ASSERT_TRUE(FileExists(from_file));
   // Destination's parent doesn't exist.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             NativeFileUtil::CopyOrMoveFile(
                 from_file, Path("nodir").AppendASCII("file"),
                 FileSystemOperation::OPTION_NONE, move));
   // Destination's parent is a file.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             NativeFileUtil::CopyOrMoveFile(
                 from_file, Path("tofile1").AppendASCII("file"),
                 FileSystemOperation::OPTION_NONE, move));
@@ -362,49 +362,49 @@ TEST_F(NativeFileUtilTest, PreserveLastModified) {
   base::FilePath to_file2 = Path("tofile2");
   base::FilePath to_file3 = Path("tofile3");
   bool created = false;
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::EnsureFileExists(from_file, &created));
   ASSERT_TRUE(created);
   EXPECT_TRUE(FileExists(from_file));
 
-  base::PlatformFileInfo file_info1;
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  base::File::Info file_info1;
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::GetFileInfo(from_file, &file_info1));
 
   // Test for copy (nosync).
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CopyOrMoveFile(
                 from_file, to_file1,
                 FileSystemOperation::OPTION_PRESERVE_LAST_MODIFIED,
                 NativeFileUtil::COPY_NOSYNC));
 
-  base::PlatformFileInfo file_info2;
+  base::File::Info file_info2;
   ASSERT_TRUE(FileExists(to_file1));
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::GetFileInfo(to_file1, &file_info2));
   EXPECT_EQ(file_info1.last_modified, file_info2.last_modified);
 
   // Test for copy (sync).
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CopyOrMoveFile(
                 from_file, to_file2,
                 FileSystemOperation::OPTION_PRESERVE_LAST_MODIFIED,
                 NativeFileUtil::COPY_SYNC));
 
   ASSERT_TRUE(FileExists(to_file2));
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::GetFileInfo(to_file1, &file_info2));
   EXPECT_EQ(file_info1.last_modified, file_info2.last_modified);
 
   // Test for move.
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::CopyOrMoveFile(
                 from_file, to_file3,
                 FileSystemOperation::OPTION_PRESERVE_LAST_MODIFIED,
                 NativeFileUtil::MOVE));
 
   ASSERT_TRUE(FileExists(to_file3));
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             NativeFileUtil::GetFileInfo(to_file2, &file_info2));
   EXPECT_EQ(file_info1.last_modified, file_info2.last_modified);
 }
diff --git a/webkit/browser/fileapi/obfuscated_file_util.cc b/webkit/browser/fileapi/obfuscated_file_util.cc
index 1824397..5cae814 100644
--- a/webkit/browser/fileapi/obfuscated_file_util.cc
+++ b/webkit/browser/fileapi/obfuscated_file_util.cc
@@ -106,7 +106,6 @@ enum IsolatedOriginStatus {
 }  // namespace
 
 using base::PlatformFile;
-using base::PlatformFileError;
 
 class ObfuscatedFileEnumerator
     : public FileSystemFileUtil::AbstractFileEnumerator {
@@ -145,11 +144,11 @@ class ObfuscatedFileEnumerator
 
     FileInfo file_info;
     base::FilePath platform_file_path;
-    base::PlatformFileError error =
+    base::File::Error error =
         obfuscated_file_util_->GetFileInfoInternal(
             db_, context_, root_url_, current_file_id_,
             &file_info, &current_platform_file_info_, &platform_file_path);
-    if (error != base::PLATFORM_FILE_OK)
+    if (error != base::File::FILE_OK)
       return Next();
 
     base::FilePath virtual_path =
@@ -205,7 +204,7 @@ class ObfuscatedFileEnumerator
   base::FilePath current_parent_virtual_path_;
 
   FileId current_file_id_;
-  base::PlatformFileInfo current_platform_file_info_;
+  base::File::Info current_platform_file_info_;
 };
 
 class ObfuscatedOriginEnumerator
@@ -272,52 +271,52 @@ ObfuscatedFileUtil::~ObfuscatedFileUtil() {
   DropDatabases();
 }
 
-PlatformFileError ObfuscatedFileUtil::CreateOrOpen(
+base::File::Error ObfuscatedFileUtil::CreateOrOpen(
     FileSystemOperationContext* context,
     const FileSystemURL& url, int file_flags,
     PlatformFile* file_handle, bool* created) {
-  PlatformFileError error = CreateOrOpenInternal(context, url, file_flags,
+  base::File::Error error = CreateOrOpenInternal(context, url, file_flags,
                                                  file_handle, created);
   if (*file_handle != base::kInvalidPlatformFileValue &&
       file_flags & base::PLATFORM_FILE_WRITE &&
       context->quota_limit_type() == quota::kQuotaLimitTypeUnlimited &&
       sandbox_delegate_) {
-    DCHECK_EQ(base::PLATFORM_FILE_OK, error);
+    DCHECK_EQ(base::File::FILE_OK, error);
     sandbox_delegate_->StickyInvalidateUsageCache(url.origin(), url.type());
   }
   return error;
 }
 
-PlatformFileError ObfuscatedFileUtil::Close(
+base::File::Error ObfuscatedFileUtil::Close(
     FileSystemOperationContext* context,
     base::PlatformFile file) {
   return NativeFileUtil::Close(file);
 }
 
-PlatformFileError ObfuscatedFileUtil::EnsureFileExists(
+base::File::Error ObfuscatedFileUtil::EnsureFileExists(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     bool* created) {
   SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, true);
   if (!db)
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
 
   FileId file_id;
   if (db->GetFileWithPath(url.path(), &file_id)) {
     FileInfo file_info;
     if (!db->GetFileInfo(file_id, &file_info)) {
       NOTREACHED();
-      return base::PLATFORM_FILE_ERROR_FAILED;
+      return base::File::FILE_ERROR_FAILED;
     }
     if (file_info.is_directory())
-      return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
+      return base::File::FILE_ERROR_NOT_A_FILE;
     if (created)
       *created = false;
-    return base::PLATFORM_FILE_OK;
+    return base::File::FILE_OK;
   }
   FileId parent_id;
   if (!db->GetFileWithPath(VirtualPath::DirName(url.path()), &parent_id))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
 
   FileInfo file_info;
   InitFileInfo(&file_info, parent_id,
@@ -325,10 +324,10 @@ PlatformFileError ObfuscatedFileUtil::EnsureFileExists(
 
   int64 growth = UsageForPath(file_info.name.size());
   if (!AllocateQuota(context, growth))
-    return base::PLATFORM_FILE_ERROR_NO_SPACE;
-  PlatformFileError error = CreateFile(
+    return base::File::FILE_ERROR_NO_SPACE;
+  base::File::Error error = CreateFile(
       context, base::FilePath(), url, &file_info, 0, NULL);
-  if (created && base::PLATFORM_FILE_OK == error) {
+  if (created && base::File::FILE_OK == error) {
     *created = true;
     UpdateUsage(context, url, growth);
     context->change_observers()->Notify(
@@ -337,27 +336,27 @@ PlatformFileError ObfuscatedFileUtil::EnsureFileExists(
   return error;
 }
 
-PlatformFileError ObfuscatedFileUtil::CreateDirectory(
+base::File::Error ObfuscatedFileUtil::CreateDirectory(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     bool exclusive,
     bool recursive) {
   SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, true);
   if (!db)
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
 
   FileId file_id;
   if (db->GetFileWithPath(url.path(), &file_id)) {
     FileInfo file_info;
     if (exclusive)
-      return base::PLATFORM_FILE_ERROR_EXISTS;
+      return base::File::FILE_ERROR_EXISTS;
     if (!db->GetFileInfo(file_id, &file_info)) {
       NOTREACHED();
-      return base::PLATFORM_FILE_ERROR_FAILED;
+      return base::File::FILE_ERROR_FAILED;
     }
     if (!file_info.is_directory())
-      return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
-    return base::PLATFORM_FILE_OK;
+      return base::File::FILE_ERROR_NOT_A_DIRECTORY;
+    return base::File::FILE_OK;
   }
 
   std::vector<base::FilePath::StringType> components;
@@ -372,9 +371,9 @@ PlatformFileError ObfuscatedFileUtil::CreateDirectory(
       break;
   }
   if (!db->IsDirectory(parent_id))
-    return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
+    return base::File::FILE_ERROR_NOT_A_DIRECTORY;
   if (!recursive && components.size() - index > 1)
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
   bool first = true;
   for (; index < components.size(); ++index) {
     FileInfo file_info;
@@ -385,9 +384,9 @@ PlatformFileError ObfuscatedFileUtil::CreateDirectory(
     file_info.parent_id = parent_id;
     int64 growth = UsageForPath(file_info.name.size());
     if (!AllocateQuota(context, growth))
-      return base::PLATFORM_FILE_ERROR_NO_SPACE;
-    base::PlatformFileError error = db->AddFileInfo(file_info, &parent_id);
-    if (error != base::PLATFORM_FILE_OK)
+      return base::File::FILE_ERROR_NO_SPACE;
+    base::File::Error error = db->AddFileInfo(file_info, &parent_id);
+    if (error != base::File::FILE_OK)
       return error;
     UpdateUsage(context, url, growth);
     context->change_observers()->Notify(
@@ -397,20 +396,20 @@ PlatformFileError ObfuscatedFileUtil::CreateDirectory(
       TouchDirectory(db, file_info.parent_id);
     }
   }
-  return base::PLATFORM_FILE_OK;
+  return base::File::FILE_OK;
 }
 
-PlatformFileError ObfuscatedFileUtil::GetFileInfo(
+base::File::Error ObfuscatedFileUtil::GetFileInfo(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
-    base::PlatformFileInfo* file_info,
+    base::File::Info* file_info,
     base::FilePath* platform_file_path) {
   SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, false);
   if (!db)
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
   FileId file_id;
   if (!db->GetFileWithPath(url.path(), &file_id))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
   FileInfo local_info;
   return GetFileInfoInternal(db, context, url,
                              file_id, &local_info,
@@ -424,72 +423,72 @@ scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator>
   return CreateFileEnumerator(context, root_url, false /* recursive */);
 }
 
-PlatformFileError ObfuscatedFileUtil::GetLocalFilePath(
+base::File::Error ObfuscatedFileUtil::GetLocalFilePath(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     base::FilePath* local_path) {
   SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, false);
   if (!db)
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
   FileId file_id;
   if (!db->GetFileWithPath(url.path(), &file_id))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info) || file_info.is_directory()) {
     NOTREACHED();
     // Directories have no local file path.
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
   }
   *local_path = DataPathToLocalPath(url, file_info.data_path);
 
   if (local_path->empty())
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  return base::PLATFORM_FILE_OK;
+    return base::File::FILE_ERROR_NOT_FOUND;
+  return base::File::FILE_OK;
 }
 
-PlatformFileError ObfuscatedFileUtil::Touch(
+base::File::Error ObfuscatedFileUtil::Touch(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time) {
   SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, false);
   if (!db)
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
   FileId file_id;
   if (!db->GetFileWithPath(url.path(), &file_id))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
 
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info)) {
     NOTREACHED();
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
   }
   if (file_info.is_directory()) {
     if (!db->UpdateModificationTime(file_id, last_modified_time))
-      return base::PLATFORM_FILE_ERROR_FAILED;
-    return base::PLATFORM_FILE_OK;
+      return base::File::FILE_ERROR_FAILED;
+    return base::File::FILE_OK;
   }
   return NativeFileUtil::Touch(
       DataPathToLocalPath(url, file_info.data_path),
       last_access_time, last_modified_time);
 }
 
-PlatformFileError ObfuscatedFileUtil::Truncate(
+base::File::Error ObfuscatedFileUtil::Truncate(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     int64 length) {
-  base::PlatformFileInfo file_info;
+  base::File::Info file_info;
   base::FilePath local_path;
-  base::PlatformFileError error =
+  base::File::Error error =
       GetFileInfo(context, url, &file_info, &local_path);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return error;
 
   int64 growth = length - file_info.size;
   if (!AllocateQuota(context, growth))
-    return base::PLATFORM_FILE_ERROR_NO_SPACE;
+    return base::File::FILE_ERROR_NO_SPACE;
   error = NativeFileUtil::Truncate(local_path, length);
-  if (error == base::PLATFORM_FILE_OK) {
+  if (error == base::File::FILE_OK) {
     UpdateUsage(context, url, growth);
     context->change_observers()->Notify(
         &FileChangeObserver::OnModifyFile, MakeTuple(url));
@@ -497,7 +496,7 @@ PlatformFileError ObfuscatedFileUtil::Truncate(
   return error;
 }
 
-PlatformFileError ObfuscatedFileUtil::CopyOrMoveFile(
+base::File::Error ObfuscatedFileUtil::CopyOrMoveFile(
     FileSystemOperationContext* context,
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
@@ -509,46 +508,46 @@ PlatformFileError ObfuscatedFileUtil::CopyOrMoveFile(
 
   SandboxDirectoryDatabase* db = GetDirectoryDatabase(src_url, true);
   if (!db)
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
 
   FileId src_file_id;
   if (!db->GetFileWithPath(src_url.path(), &src_file_id))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
 
   FileId dest_file_id;
   bool overwrite = db->GetFileWithPath(dest_url.path(),
                                        &dest_file_id);
 
   FileInfo src_file_info;
-  base::PlatformFileInfo src_platform_file_info;
+  base::File::Info src_platform_file_info;
   base::FilePath src_local_path;
-  base::PlatformFileError error = GetFileInfoInternal(
+  base::File::Error error = GetFileInfoInternal(
       db, context, src_url, src_file_id,
       &src_file_info, &src_platform_file_info, &src_local_path);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return error;
   if (src_file_info.is_directory())
-    return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
+    return base::File::FILE_ERROR_NOT_A_FILE;
 
   FileInfo dest_file_info;
-  base::PlatformFileInfo dest_platform_file_info;  // overwrite case only
+  base::File::Info dest_platform_file_info;  // overwrite case only
   base::FilePath dest_local_path;  // overwrite case only
   if (overwrite) {
-    base::PlatformFileError error = GetFileInfoInternal(
+    base::File::Error error = GetFileInfoInternal(
         db, context, dest_url, dest_file_id,
         &dest_file_info, &dest_platform_file_info, &dest_local_path);
-    if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND)
+    if (error == base::File::FILE_ERROR_NOT_FOUND)
       overwrite = false;  // fallback to non-overwrite case
-    else if (error != base::PLATFORM_FILE_OK)
+    else if (error != base::File::FILE_OK)
       return error;
     else if (dest_file_info.is_directory())
-      return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+      return base::File::FILE_ERROR_INVALID_OPERATION;
   }
   if (!overwrite) {
     FileId dest_parent_id;
     if (!db->GetFileWithPath(VirtualPath::DirName(dest_url.path()),
                              &dest_parent_id)) {
-      return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+      return base::File::FILE_ERROR_NOT_FOUND;
     }
 
     dest_file_info = src_file_info;
@@ -567,7 +566,7 @@ PlatformFileError ObfuscatedFileUtil::CopyOrMoveFile(
   else
     growth += UsageForPath(dest_file_info.name.size());
   if (!AllocateQuota(context, growth))
-    return base::PLATFORM_FILE_ERROR_NO_SPACE;
+    return base::File::FILE_ERROR_NO_SPACE;
 
   /*
    * Copy-with-overwrite
@@ -583,7 +582,7 @@ PlatformFileError ObfuscatedFileUtil::CopyOrMoveFile(
    * Move-without-overwrite
    *  Just update metadata
    */
-  error = base::PLATFORM_FILE_ERROR_FAILED;
+  error = base::File::FILE_ERROR_FAILED;
   if (copy) {
     if (overwrite) {
       error = NativeFileUtil::CopyOrMoveFile(
@@ -599,22 +598,22 @@ PlatformFileError ObfuscatedFileUtil::CopyOrMoveFile(
   } else {
     if (overwrite) {
       if (db->OverwritingMoveFile(src_file_id, dest_file_id)) {
-        if (base::PLATFORM_FILE_OK !=
+        if (base::File::FILE_OK !=
             NativeFileUtil::DeleteFile(dest_local_path))
           LOG(WARNING) << "Leaked a backing file.";
-        error = base::PLATFORM_FILE_OK;
+        error = base::File::FILE_OK;
       } else {
-        error = base::PLATFORM_FILE_ERROR_FAILED;
+        error = base::File::FILE_ERROR_FAILED;
       }
     } else {  // non-overwrite
       if (db->UpdateFileInfo(src_file_id, dest_file_info))
-        error = base::PLATFORM_FILE_OK;
+        error = base::File::FILE_OK;
       else
-        error = base::PLATFORM_FILE_ERROR_FAILED;
+        error = base::File::FILE_ERROR_FAILED;
     }
   }
 
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return error;
 
   if (overwrite) {
@@ -639,44 +638,44 @@ PlatformFileError ObfuscatedFileUtil::CopyOrMoveFile(
   return error;
 }
 
-PlatformFileError ObfuscatedFileUtil::CopyInForeignFile(
+base::File::Error ObfuscatedFileUtil::CopyInForeignFile(
     FileSystemOperationContext* context,
     const base::FilePath& src_file_path,
     const FileSystemURL& dest_url) {
   SandboxDirectoryDatabase* db = GetDirectoryDatabase(dest_url, true);
   if (!db)
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
 
   base::File::Info src_platform_file_info;
   if (!base::GetFileInfo(src_file_path, &src_platform_file_info))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
 
   FileId dest_file_id;
   bool overwrite = db->GetFileWithPath(dest_url.path(),
                                        &dest_file_id);
 
   FileInfo dest_file_info;
-  base::PlatformFileInfo dest_platform_file_info;  // overwrite case only
+  base::File::Info dest_platform_file_info;  // overwrite case only
   if (overwrite) {
     base::FilePath dest_local_path;
-    base::PlatformFileError error = GetFileInfoInternal(
+    base::File::Error error = GetFileInfoInternal(
         db, context, dest_url, dest_file_id,
         &dest_file_info, &dest_platform_file_info, &dest_local_path);
-    if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND)
+    if (error == base::File::FILE_ERROR_NOT_FOUND)
       overwrite = false;  // fallback to non-overwrite case
-    else if (error != base::PLATFORM_FILE_OK)
+    else if (error != base::File::FILE_OK)
       return error;
     else if (dest_file_info.is_directory())
-      return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+      return base::File::FILE_ERROR_INVALID_OPERATION;
   }
   if (!overwrite) {
     FileId dest_parent_id;
     if (!db->GetFileWithPath(VirtualPath::DirName(dest_url.path()),
                              &dest_parent_id)) {
-      return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+      return base::File::FILE_ERROR_NOT_FOUND;
     }
     if (!dest_file_info.is_directory())
-      return base::PLATFORM_FILE_ERROR_FAILED;
+      return base::File::FILE_ERROR_FAILED;
     InitFileInfo(&dest_file_info, dest_parent_id,
                  VirtualPath::BaseName(dest_url.path()).value());
   }
@@ -687,9 +686,9 @@ PlatformFileError ObfuscatedFileUtil::CopyInForeignFile(
   else
     growth += UsageForPath(dest_file_info.name.size());
   if (!AllocateQuota(context, growth))
-    return base::PLATFORM_FILE_ERROR_NO_SPACE;
+    return base::File::FILE_ERROR_NO_SPACE;
 
-  base::PlatformFileError error;
+  base::File::Error error;
   if (overwrite) {
     base::FilePath dest_local_path =
         DataPathToLocalPath(dest_url, dest_file_info.data_path);
@@ -703,7 +702,7 @@ PlatformFileError ObfuscatedFileUtil::CopyInForeignFile(
                        dest_url, &dest_file_info, 0, NULL);
   }
 
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return error;
 
   if (overwrite) {
@@ -716,36 +715,36 @@ PlatformFileError ObfuscatedFileUtil::CopyInForeignFile(
 
   UpdateUsage(context, dest_url, growth);
   TouchDirectory(db, dest_file_info.parent_id);
-  return base::PLATFORM_FILE_OK;
+  return base::File::FILE_OK;
 }
 
-PlatformFileError ObfuscatedFileUtil::DeleteFile(
+base::File::Error ObfuscatedFileUtil::DeleteFile(
     FileSystemOperationContext* context,
     const FileSystemURL& url) {
   SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, true);
   if (!db)
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
   FileId file_id;
   if (!db->GetFileWithPath(url.path(), &file_id))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
 
   FileInfo file_info;
-  base::PlatformFileInfo platform_file_info;
+  base::File::Info platform_file_info;
   base::FilePath local_path;
-  base::PlatformFileError error = GetFileInfoInternal(
+  base::File::Error error = GetFileInfoInternal(
       db, context, url, file_id, &file_info, &platform_file_info, &local_path);
-  if (error != base::PLATFORM_FILE_ERROR_NOT_FOUND &&
-      error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_ERROR_NOT_FOUND &&
+      error != base::File::FILE_OK)
     return error;
 
   if (file_info.is_directory())
-    return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
+    return base::File::FILE_ERROR_NOT_A_FILE;
 
   int64 growth = -UsageForPath(file_info.name.size()) - platform_file_info.size;
   AllocateQuota(context, growth);
   if (!db->RemoveFileInfo(file_id)) {
     NOTREACHED();
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
   }
   UpdateUsage(context, url, growth);
   TouchDirectory(db, file_info.parent_id);
@@ -753,54 +752,54 @@ PlatformFileError ObfuscatedFileUtil::DeleteFile(
   context->change_observers()->Notify(
       &FileChangeObserver::OnRemoveFile, MakeTuple(url));
 
-  if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND)
-    return base::PLATFORM_FILE_OK;
+  if (error == base::File::FILE_ERROR_NOT_FOUND)
+    return base::File::FILE_OK;
 
   error = NativeFileUtil::DeleteFile(local_path);
-  if (base::PLATFORM_FILE_OK != error)
+  if (base::File::FILE_OK != error)
     LOG(WARNING) << "Leaked a backing file.";
-  return base::PLATFORM_FILE_OK;
+  return base::File::FILE_OK;
 }
 
-PlatformFileError ObfuscatedFileUtil::DeleteDirectory(
+base::File::Error ObfuscatedFileUtil::DeleteDirectory(
     FileSystemOperationContext* context,
     const FileSystemURL& url) {
   SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, true);
   if (!db)
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
 
   FileId file_id;
   if (!db->GetFileWithPath(url.path(), &file_id))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info)) {
     NOTREACHED();
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
   }
   if (!file_info.is_directory())
-    return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
+    return base::File::FILE_ERROR_NOT_A_DIRECTORY;
   if (!db->RemoveFileInfo(file_id))
-    return base::PLATFORM_FILE_ERROR_NOT_EMPTY;
+    return base::File::FILE_ERROR_NOT_EMPTY;
   int64 growth = -UsageForPath(file_info.name.size());
   AllocateQuota(context, growth);
   UpdateUsage(context, url, growth);
   TouchDirectory(db, file_info.parent_id);
   context->change_observers()->Notify(
       &FileChangeObserver::OnRemoveDirectory, MakeTuple(url));
-  return base::PLATFORM_FILE_OK;
+  return base::File::FILE_OK;
 }
 
 webkit_blob::ScopedFile ObfuscatedFileUtil::CreateSnapshotFile(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
-    base::PlatformFileError* error,
-    base::PlatformFileInfo* file_info,
+    base::File::Error* error,
+    base::File::Info* file_info,
     base::FilePath* platform_path) {
   // We're just returning the local file information.
   *error = GetFileInfo(context, url, file_info, platform_path);
-  if (*error == base::PLATFORM_FILE_OK && file_info->is_directory) {
-    *file_info = base::PlatformFileInfo();
-    *error = base::PLATFORM_FILE_ERROR_NOT_A_FILE;
+  if (*error == base::File::FILE_OK && file_info->is_directory) {
+    *file_info = base::File::Info();
+    *error = base::File::FILE_ERROR_NOT_A_FILE;
   }
   return webkit_blob::ScopedFile();
 }
@@ -846,19 +845,19 @@ base::FilePath ObfuscatedFileUtil::GetDirectoryForOriginAndType(
     const GURL& origin,
     const std::string& type_string,
     bool create,
-    base::PlatformFileError* error_code) {
+    base::File::Error* error_code) {
   base::FilePath origin_dir = GetDirectoryForOrigin(origin, create, error_code);
   if (origin_dir.empty())
     return base::FilePath();
   if (type_string.empty())
     return origin_dir;
   base::FilePath path = origin_dir.AppendASCII(type_string);
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   if (!base::DirectoryExists(path) &&
       (!create || !base::CreateDirectory(path))) {
     error = create ?
-          base::PLATFORM_FILE_ERROR_FAILED :
-          base::PLATFORM_FILE_ERROR_NOT_FOUND;
+          base::File::FILE_ERROR_FAILED :
+          base::File::FILE_ERROR_NOT_FOUND;
   }
 
   if (error_code)
@@ -869,12 +868,12 @@ base::FilePath ObfuscatedFileUtil::GetDirectoryForOriginAndType(
 bool ObfuscatedFileUtil::DeleteDirectoryForOriginAndType(
     const GURL& origin,
     const std::string& type_string) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   base::FilePath origin_type_path = GetDirectoryForOriginAndType(
       origin, type_string, false, &error);
   if (origin_type_path.empty())
     return true;
-  if (error != base::PLATFORM_FILE_ERROR_NOT_FOUND) {
+  if (error != base::File::FILE_ERROR_NOT_FOUND) {
     // TODO(dmikurube): Consider the return value of DestroyDirectoryDatabase.
     // We ignore its error now since 1) it doesn't matter the final result, and
     // 2) it always returns false in Windows because of LevelDB's
@@ -940,10 +939,10 @@ bool ObfuscatedFileUtil::DestroyDirectoryDatabase(
     delete database;
   }
 
-  PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   base::FilePath path = GetDirectoryForOriginAndType(
       origin, type_string, false, &error);
-  if (path.empty() || error == base::PLATFORM_FILE_ERROR_NOT_FOUND)
+  if (path.empty() || error == base::File::FILE_ERROR_NOT_FOUND)
     return true;
   return SandboxDirectoryDatabase::DestroyDatabase(path);
 }
@@ -968,10 +967,10 @@ void ObfuscatedFileUtil::MaybePrepopulateDatabase(
     // Only handles known types.
     if (!ContainsKey(known_type_strings_, type_string))
       continue;
-    PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+    base::File::Error error = base::File::FILE_ERROR_FAILED;
     base::FilePath path = GetDirectoryForOriginAndType(
         origin, type_string, false, &error);
-    if (error != base::PLATFORM_FILE_OK)
+    if (error != base::File::FILE_OK)
       continue;
     scoped_ptr<SandboxDirectoryDatabase> db(new SandboxDirectoryDatabase(path));
     if (db->Init(SandboxDirectoryDatabase::FAIL_ON_CORRUPTION)) {
@@ -987,7 +986,7 @@ void ObfuscatedFileUtil::MaybePrepopulateDatabase(
 base::FilePath ObfuscatedFileUtil::GetDirectoryForURL(
     const FileSystemURL& url,
     bool create,
-    base::PlatformFileError* error_code) {
+    base::File::Error* error_code) {
   return GetDirectoryForOriginAndType(
       url.origin(), CallGetTypeStringForURL(url), create, error_code);
 }
@@ -998,13 +997,13 @@ std::string ObfuscatedFileUtil::CallGetTypeStringForURL(
   return get_type_string_for_url_.Run(url);
 }
 
-PlatformFileError ObfuscatedFileUtil::GetFileInfoInternal(
+base::File::Error ObfuscatedFileUtil::GetFileInfoInternal(
     SandboxDirectoryDatabase* db,
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     FileId file_id,
     FileInfo* local_info,
-    base::PlatformFileInfo* file_info,
+    base::File::Info* file_info,
     base::FilePath* platform_file_path) {
   DCHECK(db);
   DCHECK(context);
@@ -1013,7 +1012,7 @@ PlatformFileError ObfuscatedFileUtil::GetFileInfoInternal(
 
   if (!db->GetFileInfo(file_id, local_info)) {
     NOTREACHED();
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
   }
 
   if (local_info->is_directory()) {
@@ -1023,30 +1022,30 @@ PlatformFileError ObfuscatedFileUtil::GetFileInfoInternal(
     file_info->last_modified = local_info->modification_time;
     *platform_file_path = base::FilePath();
     // We don't fill in ctime or atime.
-    return base::PLATFORM_FILE_OK;
+    return base::File::FILE_OK;
   }
   if (local_info->data_path.empty())
-    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+    return base::File::FILE_ERROR_INVALID_OPERATION;
   base::FilePath local_path = DataPathToLocalPath(url, local_info->data_path);
-  base::PlatformFileError error = NativeFileUtil::GetFileInfo(
+  base::File::Error error = NativeFileUtil::GetFileInfo(
       local_path, file_info);
   // We should not follow symbolic links in sandboxed file system.
   if (base::IsLink(local_path)) {
     LOG(WARNING) << "Found a symbolic file.";
-    error = base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    error = base::File::FILE_ERROR_NOT_FOUND;
   }
-  if (error == base::PLATFORM_FILE_OK) {
+  if (error == base::File::FILE_OK) {
     *platform_file_path = local_path;
-  } else if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND) {
+  } else if (error == base::File::FILE_ERROR_NOT_FOUND) {
     LOG(WARNING) << "Lost a backing file.";
     InvalidateUsageCache(context, url.origin(), url.type());
     if (!db->RemoveFileInfo(file_id))
-      return base::PLATFORM_FILE_ERROR_FAILED;
+      return base::File::FILE_ERROR_FAILED;
   }
   return error;
 }
 
-PlatformFileError ObfuscatedFileUtil::CreateFile(
+base::File::Error ObfuscatedFileUtil::CreateFile(
     FileSystemOperationContext* context,
     const base::FilePath& src_file_path,
     const FileSystemURL& dest_url,
@@ -1055,14 +1054,14 @@ PlatformFileError ObfuscatedFileUtil::CreateFile(
     *handle = base::kInvalidPlatformFileValue;
   SandboxDirectoryDatabase* db = GetDirectoryDatabase(dest_url, true);
 
-  PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   base::FilePath root = GetDirectoryForURL(dest_url, false, &error);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return error;
 
   base::FilePath dest_local_path;
   error = GenerateNewLocalPath(db, context, dest_url, &dest_local_path);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return error;
 
   bool created = false;
@@ -1079,7 +1078,7 @@ PlatformFileError ObfuscatedFileUtil::CreateFile(
     if (base::PathExists(dest_local_path)) {
       if (!base::DeleteFile(dest_local_path, true /* recursive */)) {
         NOTREACHED();
-        return base::PLATFORM_FILE_ERROR_FAILED;
+        return base::File::FILE_ERROR_FAILED;
       }
       LOG(WARNING) << "A stray file detected";
       InvalidateUsageCache(context, dest_url.origin(), dest_url.type());
@@ -1094,7 +1093,7 @@ PlatformFileError ObfuscatedFileUtil::CreateFile(
       error = NativeFileUtil::EnsureFileExists(dest_local_path, &created);
     }
   }
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return error;
 
   if (!created) {
@@ -1105,7 +1104,7 @@ PlatformFileError ObfuscatedFileUtil::CreateFile(
       base::DeleteFile(dest_local_path, false /* recursive */);
       *handle = base::kInvalidPlatformFileValue;
     }
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
   }
 
   // This removes the root, including the trailing slash, leaving a relative
@@ -1115,7 +1114,7 @@ PlatformFileError ObfuscatedFileUtil::CreateFile(
 
   FileId file_id;
   error = db->AddFileInfo(*dest_file_info, &file_id);
-  if (error != base::PLATFORM_FILE_OK) {
+  if (error != base::File::FILE_OK) {
     if (handle) {
       DCHECK_NE(base::kInvalidPlatformFileValue, *handle);
       base::ClosePlatformFile(*handle);
@@ -1126,14 +1125,14 @@ PlatformFileError ObfuscatedFileUtil::CreateFile(
   }
   TouchDirectory(db, dest_file_info->parent_id);
 
-  return base::PLATFORM_FILE_OK;
+  return base::File::FILE_OK;
 }
 
 base::FilePath ObfuscatedFileUtil::DataPathToLocalPath(
     const FileSystemURL& url, const base::FilePath& data_path) {
-  PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   base::FilePath root = GetDirectoryForURL(url, false, &error);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return base::FilePath();
   return root.Append(data_path);
 }
@@ -1166,9 +1165,9 @@ SandboxDirectoryDatabase* ObfuscatedFileUtil::GetDirectoryDatabase(
     return iter->second;
   }
 
-  PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   base::FilePath path = GetDirectoryForURL(url, create, &error);
-  if (error != base::PLATFORM_FILE_OK) {
+  if (error != base::File::FILE_OK) {
     LOG(WARNING) << "Failed to get origin+type directory: "
                  << url.DebugString() << " error:" << error;
     return NULL;
@@ -1180,12 +1179,12 @@ SandboxDirectoryDatabase* ObfuscatedFileUtil::GetDirectoryDatabase(
 }
 
 base::FilePath ObfuscatedFileUtil::GetDirectoryForOrigin(
-    const GURL& origin, bool create, base::PlatformFileError* error_code) {
+    const GURL& origin, bool create, base::File::Error* error_code) {
   if (!InitOriginDatabase(origin, create)) {
     if (error_code) {
       *error_code = create ?
-          base::PLATFORM_FILE_ERROR_FAILED :
-          base::PLATFORM_FILE_ERROR_NOT_FOUND;
+          base::File::FILE_ERROR_FAILED :
+          base::File::FILE_ERROR_NOT_FOUND;
     }
     return base::FilePath();
   }
@@ -1195,12 +1194,12 @@ base::FilePath ObfuscatedFileUtil::GetDirectoryForOrigin(
   bool exists_in_db = origin_database_->HasOriginPath(id);
   if (!exists_in_db && !create) {
     if (error_code)
-      *error_code = base::PLATFORM_FILE_ERROR_NOT_FOUND;
+      *error_code = base::File::FILE_ERROR_NOT_FOUND;
     return base::FilePath();
   }
   if (!origin_database_->GetPathForOrigin(id, &directory_name)) {
     if (error_code)
-      *error_code = base::PLATFORM_FILE_ERROR_FAILED;
+      *error_code = base::File::FILE_ERROR_FAILED;
     return base::FilePath();
   }
 
@@ -1209,7 +1208,7 @@ base::FilePath ObfuscatedFileUtil::GetDirectoryForOrigin(
   if (!exists_in_db && exists_in_fs) {
     if (!base::DeleteFile(path, true)) {
       if (error_code)
-        *error_code = base::PLATFORM_FILE_ERROR_FAILED;
+        *error_code = base::File::FILE_ERROR_FAILED;
       return base::FilePath();
     }
     exists_in_fs = false;
@@ -1219,14 +1218,14 @@ base::FilePath ObfuscatedFileUtil::GetDirectoryForOrigin(
     if (!create || !base::CreateDirectory(path)) {
       if (error_code)
         *error_code = create ?
-            base::PLATFORM_FILE_ERROR_FAILED :
-            base::PLATFORM_FILE_ERROR_NOT_FOUND;
+            base::File::FILE_ERROR_FAILED :
+            base::File::FILE_ERROR_NOT_FOUND;
       return base::FilePath();
     }
   }
 
   if (error_code)
-    *error_code = base::PLATFORM_FILE_OK;
+    *error_code = base::File::FILE_OK;
 
   return path;
 }
@@ -1301,7 +1300,7 @@ bool ObfuscatedFileUtil::InitOriginDatabase(const GURL& origin_hint,
   return true;
 }
 
-PlatformFileError ObfuscatedFileUtil::GenerateNewLocalPath(
+base::File::Error ObfuscatedFileUtil::GenerateNewLocalPath(
     SandboxDirectoryDatabase* db,
     FileSystemOperationContext* context,
     const FileSystemURL& url,
@@ -1309,12 +1308,12 @@ PlatformFileError ObfuscatedFileUtil::GenerateNewLocalPath(
   DCHECK(local_path);
   int64 number;
   if (!db || !db->GetNextInteger(&number))
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
 
-  PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   base::FilePath new_local_path = GetDirectoryForURL(url, false, &error);
-  if (error != base::PLATFORM_FILE_OK)
-    return base::PLATFORM_FILE_ERROR_FAILED;
+  if (error != base::File::FILE_OK)
+    return base::File::FILE_ERROR_FAILED;
 
   // We use the third- and fourth-to-last digits as the directory.
   int64 directory_number = number % 10000 / 100;
@@ -1323,15 +1322,15 @@ PlatformFileError ObfuscatedFileUtil::GenerateNewLocalPath(
 
   error = NativeFileUtil::CreateDirectory(
       new_local_path, false /* exclusive */, false /* recursive */);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return error;
 
   *local_path =
       new_local_path.AppendASCII(base::StringPrintf("%08" PRId64, number));
-  return base::PLATFORM_FILE_OK;
+  return base::File::FILE_OK;
 }
 
-PlatformFileError ObfuscatedFileUtil::CreateOrOpenInternal(
+base::File::Error ObfuscatedFileUtil::CreateOrOpenInternal(
     FileSystemOperationContext* context,
     const FileSystemURL& url, int file_flags,
     PlatformFile* file_handle, bool* created) {
@@ -1340,28 +1339,28 @@ PlatformFileError ObfuscatedFileUtil::CreateOrOpenInternal(
         base::PLATFORM_FILE_EXCLUSIVE_WRITE)));
   SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, true);
   if (!db)
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
   FileId file_id;
   if (!db->GetFileWithPath(url.path(), &file_id)) {
     // The file doesn't exist.
     if (!(file_flags & (base::PLATFORM_FILE_CREATE |
         base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_OPEN_ALWAYS)))
-      return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+      return base::File::FILE_ERROR_NOT_FOUND;
     FileId parent_id;
     if (!db->GetFileWithPath(VirtualPath::DirName(url.path()),
                              &parent_id))
-      return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+      return base::File::FILE_ERROR_NOT_FOUND;
     FileInfo file_info;
     InitFileInfo(&file_info, parent_id,
                  VirtualPath::BaseName(url.path()).value());
 
     int64 growth = UsageForPath(file_info.name.size());
     if (!AllocateQuota(context, growth))
-      return base::PLATFORM_FILE_ERROR_NO_SPACE;
-    PlatformFileError error = CreateFile(
+      return base::File::FILE_ERROR_NO_SPACE;
+    base::File::Error error = CreateFile(
         context, base::FilePath(),
         url, &file_info, file_flags, file_handle);
-    if (created && base::PLATFORM_FILE_OK == error) {
+    if (created && base::File::FILE_OK == error) {
       *created = true;
       UpdateUsage(context, url, growth);
       context->change_observers()->Notify(
@@ -1371,17 +1370,17 @@ PlatformFileError ObfuscatedFileUtil::CreateOrOpenInternal(
   }
 
   if (file_flags & base::PLATFORM_FILE_CREATE)
-    return base::PLATFORM_FILE_ERROR_EXISTS;
+    return base::File::FILE_ERROR_EXISTS;
 
-  base::PlatformFileInfo platform_file_info;
+  base::File::Info platform_file_info;
   base::FilePath local_path;
   FileInfo file_info;
-  base::PlatformFileError error = GetFileInfoInternal(
+  base::File::Error error = GetFileInfoInternal(
       db, context, url, file_id, &file_info, &platform_file_info, &local_path);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return error;
   if (file_info.is_directory())
-    return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
+    return base::File::FILE_ERROR_NOT_A_FILE;
 
   int64 delta = 0;
   if (file_flags & (base::PLATFORM_FILE_CREATE_ALWAYS |
@@ -1393,16 +1392,16 @@ PlatformFileError ObfuscatedFileUtil::CreateOrOpenInternal(
 
   error = NativeFileUtil::CreateOrOpen(
       local_path, file_flags, file_handle, created);
-  if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND) {
+  if (error == base::File::FILE_ERROR_NOT_FOUND) {
     // TODO(tzik): Also invalidate on-memory usage cache in UsageTracker.
     // TODO(tzik): Delete database entry after ensuring the file lost.
     InvalidateUsageCache(context, url.origin(), url.type());
     LOG(WARNING) << "Lost a backing file.";
-    error = base::PLATFORM_FILE_ERROR_FAILED;
+    error = base::File::FILE_ERROR_FAILED;
   }
 
   // If truncating we need to update the usage.
-  if (error == base::PLATFORM_FILE_OK && delta) {
+  if (error == base::File::FILE_OK && delta) {
     UpdateUsage(context, url, delta);
     context->change_observers()->Notify(
         &FileChangeObserver::OnModifyFile, MakeTuple(url));
diff --git a/webkit/browser/fileapi/obfuscated_file_util.h b/webkit/browser/fileapi/obfuscated_file_util.h
index 7b14779..ed1f2bc 100644
--- a/webkit/browser/fileapi/obfuscated_file_util.h
+++ b/webkit/browser/fileapi/obfuscated_file_util.h
@@ -11,6 +11,7 @@
 #include <vector>
 
 #include "base/callback_forward.h"
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util_proxy.h"
 #include "base/gtest_prod_util.h"
@@ -110,65 +111,65 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE ObfuscatedFileUtil
   virtual ~ObfuscatedFileUtil();
 
   // FileSystemFileUtil overrides.
-  virtual base::PlatformFileError CreateOrOpen(
+  virtual base::File::Error CreateOrOpen(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       int file_flags,
       base::PlatformFile* file_handle,
       bool* created) OVERRIDE;
-  virtual base::PlatformFileError Close(
+  virtual base::File::Error Close(
       FileSystemOperationContext* context,
       base::PlatformFile file) OVERRIDE;
-  virtual base::PlatformFileError EnsureFileExists(
+  virtual base::File::Error EnsureFileExists(
       FileSystemOperationContext* context,
       const FileSystemURL& url, bool* created) OVERRIDE;
-  virtual base::PlatformFileError CreateDirectory(
+  virtual base::File::Error CreateDirectory(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       bool exclusive,
       bool recursive) OVERRIDE;
-  virtual base::PlatformFileError GetFileInfo(
+  virtual base::File::Error GetFileInfo(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
-      base::PlatformFileInfo* file_info,
+      base::File::Info* file_info,
       base::FilePath* platform_file) OVERRIDE;
   virtual scoped_ptr<AbstractFileEnumerator> CreateFileEnumerator(
       FileSystemOperationContext* context,
       const FileSystemURL& root_url) OVERRIDE;
-  virtual base::PlatformFileError GetLocalFilePath(
+  virtual base::File::Error GetLocalFilePath(
       FileSystemOperationContext* context,
       const FileSystemURL& file_system_url,
       base::FilePath* local_path) OVERRIDE;
-  virtual base::PlatformFileError Touch(
+  virtual base::File::Error Touch(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       const base::Time& last_access_time,
       const base::Time& last_modified_time) OVERRIDE;
-  virtual base::PlatformFileError Truncate(
+  virtual base::File::Error Truncate(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       int64 length) OVERRIDE;
-  virtual base::PlatformFileError CopyOrMoveFile(
+  virtual base::File::Error CopyOrMoveFile(
       FileSystemOperationContext* context,
       const FileSystemURL& src_url,
       const FileSystemURL& dest_url,
       CopyOrMoveOption option,
       bool copy) OVERRIDE;
-  virtual base::PlatformFileError CopyInForeignFile(
+  virtual base::File::Error CopyInForeignFile(
         FileSystemOperationContext* context,
         const base::FilePath& src_file_path,
         const FileSystemURL& dest_url) OVERRIDE;
-  virtual base::PlatformFileError DeleteFile(
+  virtual base::File::Error DeleteFile(
       FileSystemOperationContext* context,
       const FileSystemURL& url) OVERRIDE;
-  virtual base::PlatformFileError DeleteDirectory(
+  virtual base::File::Error DeleteDirectory(
       FileSystemOperationContext* context,
       const FileSystemURL& url) OVERRIDE;
   virtual webkit_blob::ScopedFile CreateSnapshotFile(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
-      base::PlatformFileError* error,
-      base::PlatformFileInfo* file_info,
+      base::File::Error* error,
+      base::File::Info* file_info,
       base::FilePath* platform_path) OVERRIDE;
 
   // Same as the other CreateFileEnumerator, but with recursive support.
@@ -195,7 +196,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE ObfuscatedFileUtil
       const GURL& origin,
       const std::string& type_string,
       bool create,
-      base::PlatformFileError* error_code);
+      base::File::Error* error_code);
 
   // Deletes the topmost directory specific to this origin and type.  This will
   // delete its directory database.
@@ -247,18 +248,18 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE ObfuscatedFileUtil
   base::FilePath GetDirectoryForURL(
       const FileSystemURL& url,
       bool create,
-      base::PlatformFileError* error_code);
+      base::File::Error* error_code);
 
   // This just calls get_type_string_for_url_ callback that is given in ctor.
   std::string CallGetTypeStringForURL(const FileSystemURL& url);
 
-  base::PlatformFileError GetFileInfoInternal(
+  base::File::Error GetFileInfoInternal(
       SandboxDirectoryDatabase* db,
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       FileId file_id,
       FileInfo* local_info,
-      base::PlatformFileInfo* file_info,
+      base::File::Info* file_info,
       base::FilePath* platform_file_path);
 
   // Creates a new file, both the underlying backing file and the entry in the
@@ -272,7 +273,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE ObfuscatedFileUtil
   // Caveat: do not supply handle if you're also supplying a data path.  It was
   // easier not to support this, and no code has needed it so far, so it will
   // DCHECK and handle will hold base::kInvalidPlatformFileValue.
-  base::PlatformFileError CreateFile(
+  base::File::Error CreateFile(
       FileSystemOperationContext* context,
       const base::FilePath& source_file_path,
       const FileSystemURL& dest_url,
@@ -300,7 +301,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE ObfuscatedFileUtil
   // contain both the filesystem type subdirectories.
   base::FilePath GetDirectoryForOrigin(const GURL& origin,
                                        bool create,
-                                       base::PlatformFileError* error_code);
+                                       base::File::Error* error_code);
 
   void InvalidateUsageCache(FileSystemOperationContext* context,
                             const GURL& origin,
@@ -313,13 +314,13 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE ObfuscatedFileUtil
   // for initializing database if it's not empty.
   bool InitOriginDatabase(const GURL& origin_hint, bool create);
 
-  base::PlatformFileError GenerateNewLocalPath(
+  base::File::Error GenerateNewLocalPath(
       SandboxDirectoryDatabase* db,
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       base::FilePath* local_path);
 
-  base::PlatformFileError CreateOrOpenInternal(
+  base::File::Error CreateOrOpenInternal(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       int file_flags,
diff --git a/webkit/browser/fileapi/plugin_private_file_system_backend.cc b/webkit/browser/fileapi/plugin_private_file_system_backend.cc
index b4a3f8b..2ea302f 100644
--- a/webkit/browser/fileapi/plugin_private_file_system_backend.cc
+++ b/webkit/browser/fileapi/plugin_private_file_system_backend.cc
@@ -66,18 +66,18 @@ const base::FilePath::CharType* 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;
 }
@@ -123,7 +123,7 @@ void PluginPrivateFileSystemBackend::OpenPrivateFileSystem(
     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;
   }
 
@@ -153,7 +153,7 @@ void PluginPrivateFileSystemBackend::OpenFileSystem(
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, GURL(), std::string(),
-                 base::PLATFORM_FILE_ERROR_SECURITY));
+                 base::File::FILE_ERROR_SECURITY));
 }
 
 AsyncFileUtil*
@@ -164,16 +164,16 @@ PluginPrivateFileSystemBackend::GetAsyncFileUtil(FileSystemType type) {
 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());
@@ -200,19 +200,19 @@ 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(
diff --git a/webkit/browser/fileapi/plugin_private_file_system_backend.h b/webkit/browser/fileapi/plugin_private_file_system_backend.h
index 8e3f356..0d34988 100644
--- a/webkit/browser/fileapi/plugin_private_file_system_backend.h
+++ b/webkit/browser/fileapi/plugin_private_file_system_backend.h
@@ -35,7 +35,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT PluginPrivateFileSystemBackend
       public FileSystemQuotaUtil {
  public:
   class FileSystemIDToPluginMap;
-  typedef base::Callback<void(base::PlatformFileError result)> StatusCallback;
+  typedef base::Callback<void(base::File::Error result)> StatusCallback;
 
   PluginPrivateFileSystemBackend(
       base::SequencedTaskRunner* file_task_runner,
@@ -69,11 +69,11 @@ class WEBKIT_STORAGE_BROWSER_EXPORT PluginPrivateFileSystemBackend
   virtual AsyncFileUtil* GetAsyncFileUtil(FileSystemType type) OVERRIDE;
   virtual CopyOrMoveFileValidatorFactory* GetCopyOrMoveFileValidatorFactory(
       FileSystemType type,
-      base::PlatformFileError* error_code) OVERRIDE;
+      base::File::Error* error_code) OVERRIDE;
   virtual FileSystemOperation* CreateFileSystemOperation(
       const FileSystemURL& url,
       FileSystemContext* context,
-      base::PlatformFileError* error_code) const OVERRIDE;
+      base::File::Error* error_code) const OVERRIDE;
   virtual scoped_ptr<webkit_blob::FileStreamReader> CreateFileStreamReader(
       const FileSystemURL& url,
       int64 offset,
@@ -86,7 +86,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT PluginPrivateFileSystemBackend
   virtual FileSystemQuotaUtil* GetQuotaUtil() OVERRIDE;
 
   // FileSystemQuotaUtil overrides.
-  virtual base::PlatformFileError DeleteOriginDataOnFileTaskRunner(
+  virtual base::File::Error DeleteOriginDataOnFileTaskRunner(
       FileSystemContext* context,
       quota::QuotaManagerProxy* proxy,
       const GURL& origin_url,
diff --git a/webkit/browser/fileapi/quota/quota_backend_impl.cc b/webkit/browser/fileapi/quota/quota_backend_impl.cc
index 05e199b..62cd5a86 100644
--- a/webkit/browser/fileapi/quota/quota_backend_impl.cc
+++ b/webkit/browser/fileapi/quota/quota_backend_impl.cc
@@ -39,7 +39,7 @@ void QuotaBackendImpl::ReserveQuota(const GURL& origin,
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(origin.is_valid());
   if (!delta) {
-    callback.Run(base::PLATFORM_FILE_OK);
+    callback.Run(base::File::FILE_OK);
     return;
   }
   DCHECK(quota_manager_proxy_);
@@ -70,7 +70,7 @@ void QuotaBackendImpl::CommitQuotaUsage(const GURL& origin,
     return;
   ReserveQuotaInternal(QuotaReservationInfo(origin, type, delta));
   base::FilePath path;
-  if (GetUsageCachePath(origin, type, &path) != base::PLATFORM_FILE_OK)
+  if (GetUsageCachePath(origin, type, &path) != base::File::FILE_OK)
     return;
   bool result = file_system_usage_cache_->AtomicUpdateUsageByDelta(path, delta);
   DCHECK(result);
@@ -81,7 +81,7 @@ void QuotaBackendImpl::IncrementDirtyCount(const GURL& origin,
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(origin.is_valid());
   base::FilePath path;
-  if (GetUsageCachePath(origin, type, &path) != base::PLATFORM_FILE_OK)
+  if (GetUsageCachePath(origin, type, &path) != base::File::FILE_OK)
     return;
   DCHECK(file_system_usage_cache_);
   file_system_usage_cache_->IncrementDirty(path);
@@ -92,7 +92,7 @@ void QuotaBackendImpl::DecrementDirtyCount(const GURL& origin,
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(origin.is_valid());
   base::FilePath path;
-  if (GetUsageCachePath(origin, type, &path) != base::PLATFORM_FILE_OK)
+  if (GetUsageCachePath(origin, type, &path) != base::File::FILE_OK)
     return;
   DCHECK(file_system_usage_cache_);
   file_system_usage_cache_->DecrementDirty(path);
@@ -105,17 +105,17 @@ void QuotaBackendImpl::DidGetUsageAndQuotaForReserveQuota(
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(info.origin.is_valid());
   if (status != quota::kQuotaStatusOk) {
-    callback.Run(base::PLATFORM_FILE_ERROR_FAILED);
+    callback.Run(base::File::FILE_ERROR_FAILED);
     return;
   }
 
   if (quota < usage + info.delta) {
-    callback.Run(base::PLATFORM_FILE_ERROR_NO_SPACE);
+    callback.Run(base::File::FILE_ERROR_NO_SPACE);
     return;
   }
 
   ReserveQuotaInternal(info);
-  if (callback.Run(base::PLATFORM_FILE_OK))
+  if (callback.Run(base::File::FILE_OK))
     return;
   // The requester could not accept the reserved quota. Revert it.
   ReserveQuotaInternal(
@@ -131,14 +131,14 @@ void QuotaBackendImpl::ReserveQuotaInternal(const QuotaReservationInfo& info) {
       FileSystemTypeToQuotaStorageType(info.type), info.delta);
 }
 
-base::PlatformFileError QuotaBackendImpl::GetUsageCachePath(
+base::File::Error QuotaBackendImpl::GetUsageCachePath(
     const GURL& origin,
     FileSystemType type,
     base::FilePath* usage_file_path) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(origin.is_valid());
   DCHECK(usage_file_path);
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   *usage_file_path =
       SandboxFileSystemBackendDelegate::GetUsageCachePathForOriginAndType(
           obfuscated_file_util_, origin, type, &error);
diff --git a/webkit/browser/fileapi/quota/quota_backend_impl.h b/webkit/browser/fileapi/quota/quota_backend_impl.h
index 10c38e7..787f5389 100644
--- a/webkit/browser/fileapi/quota/quota_backend_impl.h
+++ b/webkit/browser/fileapi/quota/quota_backend_impl.h
@@ -80,7 +80,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT QuotaBackendImpl
 
   void ReserveQuotaInternal(
       const QuotaReservationInfo& info);
-  base::PlatformFileError GetUsageCachePath(
+  base::File::Error GetUsageCachePath(
       const GURL& origin,
       FileSystemType type,
       base::FilePath* usage_file_path);
diff --git a/webkit/browser/fileapi/quota/quota_backend_impl_unittest.cc b/webkit/browser/fileapi/quota/quota_backend_impl_unittest.cc
index edc554c..35deca0 100644
--- a/webkit/browser/fileapi/quota/quota_backend_impl_unittest.cc
+++ b/webkit/browser/fileapi/quota/quota_backend_impl_unittest.cc
@@ -20,8 +20,8 @@ namespace {
 const char kOrigin[] = "http://example.com";
 
 bool DidReserveQuota(bool accepted,
-                     base::PlatformFileError* error_out,
-                     base::PlatformFileError error) {
+                     base::File::Error* error_out,
+                     base::File::Error error) {
   DCHECK(error_out);
   *error_out = error;
   return accepted;
@@ -108,10 +108,10 @@ class QuotaBackendImplTest : public testing::Test {
 
     std::string type_string =
         SandboxFileSystemBackendDelegate::GetTypeString(type);
-    base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+    base::File::Error error = base::File::FILE_ERROR_FAILED;
     base::FilePath path = file_util_->GetDirectoryForOriginAndType(
         origin, type_string, true /* create */, &error);
-    ASSERT_EQ(base::PLATFORM_FILE_OK, error);
+    ASSERT_EQ(base::File::FILE_OK, error);
 
     ASSERT_TRUE(file_system_usage_cache_.UpdateUsage(
         GetUsageCachePath(origin, type), 0));
@@ -123,9 +123,9 @@ class QuotaBackendImplTest : public testing::Test {
 
   base::FilePath GetUsageCachePath(const GURL& origin, FileSystemType type) {
     base::FilePath path;
-    base::PlatformFileError error =
+    base::File::Error error =
         backend_->GetUsageCachePath(origin, type, &path);
-    EXPECT_EQ(base::PLATFORM_FILE_OK, error);
+    EXPECT_EQ(base::File::FILE_OK, error);
     EXPECT_FALSE(path.empty());
     return path;
   }
@@ -147,17 +147,17 @@ TEST_F(QuotaBackendImplTest, ReserveQuota_Basic) {
   quota_manager_proxy_->set_quota(10000);
 
   const int64 kDelta1 = 1000;
-  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error error = base::File::FILE_ERROR_FAILED;
   backend_->ReserveQuota(GURL(kOrigin), type, kDelta1,
                          base::Bind(&DidReserveQuota, true, &error));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, error);
+  EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(kDelta1, quota_manager_proxy_->usage());
 
   const int64 kDelta2 = -300;
-  error = base::PLATFORM_FILE_ERROR_FAILED;
+  error = base::File::FILE_ERROR_FAILED;
   backend_->ReserveQuota(GURL(kOrigin), type, kDelta2,
                          base::Bind(&DidReserveQuota, true, &error));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, error);
+  EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(kDelta1 + kDelta2, quota_manager_proxy_->usage());
 
   EXPECT_EQ(2, quota_manager_proxy_->storage_modified_count());
@@ -169,10 +169,10 @@ TEST_F(QuotaBackendImplTest, ReserveQuota_NoSpace) {
   quota_manager_proxy_->set_quota(100);
 
   const int64 kDelta = 1000;
-  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error error = base::File::FILE_ERROR_FAILED;
   backend_->ReserveQuota(GURL(kOrigin), type, kDelta,
                          base::Bind(&DidReserveQuota, true, &error));
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, error);
+  EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, error);
   EXPECT_EQ(0, quota_manager_proxy_->usage());
 
   EXPECT_EQ(0, quota_manager_proxy_->storage_modified_count());
@@ -184,10 +184,10 @@ TEST_F(QuotaBackendImplTest, ReserveQuota_Revert) {
   quota_manager_proxy_->set_quota(10000);
 
   const int64 kDelta = 1000;
-  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error error = base::File::FILE_ERROR_FAILED;
   backend_->ReserveQuota(GURL(kOrigin), type, kDelta,
                          base::Bind(&DidReserveQuota, false, &error));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, error);
+  EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(0, quota_manager_proxy_->usage());
 
   EXPECT_EQ(2, quota_manager_proxy_->storage_modified_count());
diff --git a/webkit/browser/fileapi/quota/quota_reservation.cc b/webkit/browser/fileapi/quota/quota_reservation.cc
index da4ef95..af74174 100644
--- a/webkit/browser/fileapi/quota/quota_reservation.cc
+++ b/webkit/browser/fileapi/quota/quota_reservation.cc
@@ -95,7 +95,7 @@ bool QuotaReservation::AdaptDidUpdateReservedQuota(
     const base::WeakPtr<QuotaReservation>& reservation,
     int64 new_reserved_size,
     const StatusCallback& callback,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   if (!reservation)
     return false;
 
@@ -106,17 +106,17 @@ bool QuotaReservation::AdaptDidUpdateReservedQuota(
 bool QuotaReservation::DidUpdateReservedQuota(
     int64 new_reserved_size,
     const StatusCallback& callback,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(running_refresh_request_);
   running_refresh_request_ = false;
 
   if (client_crashed_) {
-    callback.Run(base::PLATFORM_FILE_ERROR_ABORT);
+    callback.Run(base::File::FILE_ERROR_ABORT);
     return false;
   }
 
-  if (error == base::PLATFORM_FILE_OK)
+  if (error == base::File::FILE_OK)
     remaining_quota_ = new_reserved_size;
   callback.Run(error);
   return true;
diff --git a/webkit/browser/fileapi/quota/quota_reservation.h b/webkit/browser/fileapi/quota/quota_reservation.h
index 18fbcb4..dad3b30 100644
--- a/webkit/browser/fileapi/quota/quota_reservation.h
+++ b/webkit/browser/fileapi/quota/quota_reservation.h
@@ -6,6 +6,7 @@
 #define WEBKIT_BROWSER_FILEAPI_QUOTA_QUOTA_RESERVATION_H_
 
 #include "base/basictypes.h"
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
@@ -24,7 +25,7 @@ class OpenFileHandle;
 class WEBKIT_STORAGE_BROWSER_EXPORT QuotaReservation
     : public base::RefCounted<QuotaReservation> {
  public:
-  typedef base::Callback<void(base::PlatformFileError error)> StatusCallback;
+  typedef base::Callback<void(base::File::Error error)> StatusCallback;
 
   // Reclaims unused quota and reserves another |size| of quota.  So that the
   // resulting new |remaining_quota| will be same as |size|.
@@ -68,10 +69,10 @@ class WEBKIT_STORAGE_BROWSER_EXPORT QuotaReservation
       const base::WeakPtr<QuotaReservation>& reservation,
       int64 new_reserved_size,
       const StatusCallback& callback,
-      base::PlatformFileError error);
+      base::File::Error error);
   bool DidUpdateReservedQuota(int64 new_reserved_size,
                               const StatusCallback& callback,
-                              base::PlatformFileError error);
+                              base::File::Error error);
 
   bool client_crashed_;
   bool running_refresh_request_;
diff --git a/webkit/browser/fileapi/quota/quota_reservation_buffer.cc b/webkit/browser/fileapi/quota/quota_reservation_buffer.cc
index 122674b..662c415 100644
--- a/webkit/browser/fileapi/quota/quota_reservation_buffer.cc
+++ b/webkit/browser/fileapi/quota/quota_reservation_buffer.cc
@@ -92,9 +92,9 @@ bool QuotaReservationBuffer::DecrementDirtyCount(
     base::WeakPtr<QuotaReservationManager> reservation_manager,
     const GURL& origin,
     FileSystemType type,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   DCHECK(origin.is_valid());
-  if (error == base::PLATFORM_FILE_OK && reservation_manager) {
+  if (error == base::File::FILE_OK && reservation_manager) {
     reservation_manager->DecrementDirtyCount(origin, type);
     return true;
   }
diff --git a/webkit/browser/fileapi/quota/quota_reservation_buffer.h b/webkit/browser/fileapi/quota/quota_reservation_buffer.h
index 9a11fa5..cc6a435 100644
--- a/webkit/browser/fileapi/quota/quota_reservation_buffer.h
+++ b/webkit/browser/fileapi/quota/quota_reservation_buffer.h
@@ -8,10 +8,10 @@
 #include <map>
 
 #include "base/basictypes.h"
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
-#include "base/platform_file.h"
 #include "url/gurl.h"
 #include "webkit/browser/webkit_storage_browser_export.h"
 #include "webkit/common/fileapi/file_system_types.h"
@@ -60,7 +60,7 @@ class QuotaReservationBuffer : public base::RefCounted<QuotaReservationBuffer> {
       base::WeakPtr<QuotaReservationManager> reservation_manager,
       const GURL& origin,
       FileSystemType type,
-      base::PlatformFileError error);
+      base::File::Error error);
 
   typedef std::map<base::FilePath, OpenFileHandleContext*>
       OpenFileHandleContextByPath;
diff --git a/webkit/browser/fileapi/quota/quota_reservation_manager.h b/webkit/browser/fileapi/quota/quota_reservation_manager.h
index 07beacc..9b64a15 100644
--- a/webkit/browser/fileapi/quota/quota_reservation_manager.h
+++ b/webkit/browser/fileapi/quota/quota_reservation_manager.h
@@ -10,9 +10,9 @@
 
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
+#include "base/files/file.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
-#include "base/platform_file.h"
 #include "url/gurl.h"
 #include "webkit/browser/webkit_storage_browser_export.h"
 #include "webkit/common/fileapi/file_system_types.h"
@@ -28,7 +28,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT QuotaReservationManager {
  public:
   // Callback for ReserveQuota. When this callback returns false, ReserveQuota
   // operation should be reverted.
-  typedef base::Callback<bool(base::PlatformFileError error)>
+  typedef base::Callback<bool(base::File::Error error)>
       ReserveQuotaCallback;
 
   // An abstraction of backing quota system.
diff --git a/webkit/browser/fileapi/quota/quota_reservation_manager_unittest.cc b/webkit/browser/fileapi/quota/quota_reservation_manager_unittest.cc
index a406a7b..1ec2fb7 100644
--- a/webkit/browser/fileapi/quota/quota_reservation_manager_unittest.cc
+++ b/webkit/browser/fileapi/quota/quota_reservation_manager_unittest.cc
@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
+#include "base/files/file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ -31,15 +32,9 @@ int64 GetFileSize(const base::FilePath& path) {
 }
 
 void SetFileSize(const base::FilePath& path, int64 size) {
-  bool created = false;
-  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
-  base::PlatformFile file = CreatePlatformFile(
-      path,
-      base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_WRITE,
-      &created, &error);
-  ASSERT_EQ(base::PLATFORM_FILE_OK, error);
-  ASSERT_TRUE(base::TruncatePlatformFile(file, size));
-  ASSERT_TRUE(base::ClosePlatformFile(file));
+  base::File file(path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE);
+  ASSERT_TRUE(file.IsValid());
+  ASSERT_TRUE(file.SetLength(size));
 }
 
 class FakeBackend : public QuotaReservationManager::QuotaBackend {
@@ -58,7 +53,7 @@ class FakeBackend : public QuotaReservationManager::QuotaBackend {
     on_memory_usage_ += delta;
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
-        base::Bind(base::IgnoreResult(callback), base::PLATFORM_FILE_OK));
+        base::Bind(base::IgnoreResult(callback), base::File::FILE_OK));
   }
 
   virtual void ReleaseReservedQuota(const GURL& origin,
@@ -160,10 +155,10 @@ class FakeWriter {
   bool dirty_;
 };
 
-void ExpectSuccess(bool* done, base::PlatformFileError error) {
+void ExpectSuccess(bool* done, base::File::Error error) {
   EXPECT_FALSE(*done);
   *done = true;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, error);
+  EXPECT_EQ(base::File::FILE_OK, error);
 }
 
 void RefreshReservation(QuotaReservation* reservation, int64 size) {
diff --git a/webkit/browser/fileapi/recursive_operation_delegate.cc b/webkit/browser/fileapi/recursive_operation_delegate.cc
index 7adc596..9ad2a8c 100644
--- a/webkit/browser/fileapi/recursive_operation_delegate.cc
+++ b/webkit/browser/fileapi/recursive_operation_delegate.cc
@@ -54,13 +54,13 @@ void RecursiveOperationDelegate::OnCancel() {
 
 void RecursiveOperationDelegate::DidTryProcessFile(
     const FileSystemURL& root,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   DCHECK(pending_directory_stack_.empty());
   DCHECK(pending_files_.empty());
   DCHECK_EQ(1, inflight_operations_);
 
   --inflight_operations_;
-  if (canceled_ || error != base::PLATFORM_FILE_ERROR_NOT_A_FILE) {
+  if (canceled_ || error != base::File::FILE_ERROR_NOT_A_FILE) {
     Done(error);
     return;
   }
@@ -86,14 +86,14 @@ void RecursiveOperationDelegate::ProcessNextDirectory() {
 }
 
 void RecursiveOperationDelegate::DidProcessDirectory(
-    base::PlatformFileError error) {
+    base::File::Error error) {
   DCHECK(pending_files_.empty());
   DCHECK(!pending_directory_stack_.empty());
   DCHECK(!pending_directory_stack_.top().empty());
   DCHECK_EQ(1, inflight_operations_);
 
   --inflight_operations_;
-  if (canceled_ || error != base::PLATFORM_FILE_OK) {
+  if (canceled_ || error != base::File::FILE_OK) {
     Done(error);
     return;
   }
@@ -108,14 +108,14 @@ void RecursiveOperationDelegate::DidProcessDirectory(
 
 void RecursiveOperationDelegate::DidReadDirectory(
     const FileSystemURL& parent,
-    base::PlatformFileError error,
+    base::File::Error error,
     const FileEntryList& entries,
     bool has_more) {
   DCHECK(pending_files_.empty());
   DCHECK(!pending_directory_stack_.empty());
   DCHECK_EQ(0, inflight_operations_);
 
-  if (canceled_ || error != base::PLATFORM_FILE_OK) {
+  if (canceled_ || error != base::File::FILE_OK) {
     Done(error);
     return;
   }
@@ -167,9 +167,9 @@ void RecursiveOperationDelegate::ProcessPendingFiles() {
 }
 
 void RecursiveOperationDelegate::DidProcessFile(
-    base::PlatformFileError error) {
+    base::File::Error error) {
   --inflight_operations_;
-  if (error != base::PLATFORM_FILE_OK) {
+  if (error != base::File::FILE_OK) {
     // If an error occurs, invoke Done immediately (even if there remain
     // running operations). It is because in the callback, this instance is
     // deleted.
@@ -186,7 +186,7 @@ void RecursiveOperationDelegate::ProcessSubDirectory() {
   DCHECK_EQ(0, inflight_operations_);
 
   if (canceled_) {
-    Done(base::PLATFORM_FILE_ERROR_ABORT);
+    Done(base::File::FILE_ERROR_ABORT);
     return;
   }
 
@@ -200,7 +200,7 @@ void RecursiveOperationDelegate::ProcessSubDirectory() {
   pending_directory_stack_.pop();
   if (pending_directory_stack_.empty()) {
     // All files/directories are processed.
-    Done(base::PLATFORM_FILE_OK);
+    Done(base::File::FILE_OK);
     return;
   }
 
@@ -213,7 +213,7 @@ void RecursiveOperationDelegate::ProcessSubDirectory() {
 }
 
 void RecursiveOperationDelegate::DidPostProcessDirectory(
-    base::PlatformFileError error) {
+    base::File::Error error) {
   DCHECK(pending_files_.empty());
   DCHECK(!pending_directory_stack_.empty());
   DCHECK(!pending_directory_stack_.top().empty());
@@ -221,7 +221,7 @@ void RecursiveOperationDelegate::DidPostProcessDirectory(
 
   --inflight_operations_;
   pending_directory_stack_.top().pop();
-  if (canceled_ || error != base::PLATFORM_FILE_OK) {
+  if (canceled_ || error != base::File::FILE_OK) {
     Done(error);
     return;
   }
@@ -229,9 +229,9 @@ void RecursiveOperationDelegate::DidPostProcessDirectory(
   ProcessSubDirectory();
 }
 
-void RecursiveOperationDelegate::Done(base::PlatformFileError error) {
-  if (canceled_ && error == base::PLATFORM_FILE_OK) {
-    callback_.Run(base::PLATFORM_FILE_ERROR_ABORT);
+void RecursiveOperationDelegate::Done(base::File::Error error) {
+  if (canceled_ && error == base::File::FILE_OK) {
+    callback_.Run(base::File::FILE_ERROR_ABORT);
   } else {
     callback_.Run(error);
   }
diff --git a/webkit/browser/fileapi/recursive_operation_delegate.h b/webkit/browser/fileapi/recursive_operation_delegate.h
index 08e3050..56dad91 100644
--- a/webkit/browser/fileapi/recursive_operation_delegate.h
+++ b/webkit/browser/fileapi/recursive_operation_delegate.h
@@ -121,20 +121,20 @@ class WEBKIT_STORAGE_BROWSER_EXPORT RecursiveOperationDelegate
 
  private:
   void DidTryProcessFile(const FileSystemURL& root,
-                         base::PlatformFileError error);
+                         base::File::Error error);
   void ProcessNextDirectory();
-  void DidProcessDirectory(base::PlatformFileError error);
+  void DidProcessDirectory(base::File::Error error);
   void DidReadDirectory(const FileSystemURL& parent,
-                        base::PlatformFileError error,
+                        base::File::Error error,
                         const FileEntryList& entries,
                         bool has_more);
   void ProcessPendingFiles();
-  void DidProcessFile(base::PlatformFileError error);
+  void DidProcessFile(base::File::Error error);
   void ProcessSubDirectory();
-  void DidPostProcessDirectory(base::PlatformFileError error);
+  void DidPostProcessDirectory(base::File::Error error);
 
   // Called when all recursive operation is done (or an error occurs).
-  void Done(base::PlatformFileError error);
+  void Done(base::File::Error error);
 
   FileSystemContext* file_system_context_;
   StatusCallback callback_;
diff --git a/webkit/browser/fileapi/remove_operation_delegate.cc b/webkit/browser/fileapi/remove_operation_delegate.cc
index 4819f01..6c7b2de 100644
--- a/webkit/browser/fileapi/remove_operation_delegate.cc
+++ b/webkit/browser/fileapi/remove_operation_delegate.cc
@@ -41,7 +41,7 @@ void RemoveOperationDelegate::ProcessFile(const FileSystemURL& url,
 
 void RemoveOperationDelegate::ProcessDirectory(const FileSystemURL& url,
                                                const StatusCallback& callback) {
-  callback.Run(base::PLATFORM_FILE_OK);
+  callback.Run(base::File::FILE_OK);
 }
 
 void RemoveOperationDelegate::PostProcessDirectory(
@@ -49,10 +49,9 @@ void RemoveOperationDelegate::PostProcessDirectory(
   operation_runner()->RemoveDirectory(url, callback);
 }
 
-void RemoveOperationDelegate::DidTryRemoveFile(
-    base::PlatformFileError error) {
-  if (error != base::PLATFORM_FILE_ERROR_NOT_A_FILE &&
-      error != base::PLATFORM_FILE_ERROR_SECURITY) {
+void RemoveOperationDelegate::DidTryRemoveFile(base::File::Error error) {
+  if (error != base::File::FILE_ERROR_NOT_A_FILE &&
+      error != base::File::FILE_ERROR_SECURITY) {
     callback_.Run(error);
     return;
   }
@@ -63,18 +62,18 @@ void RemoveOperationDelegate::DidTryRemoveFile(
 }
 
 void RemoveOperationDelegate::DidTryRemoveDirectory(
-    base::PlatformFileError remove_file_error,
-    base::PlatformFileError remove_directory_error) {
+    base::File::Error remove_file_error,
+    base::File::Error remove_directory_error) {
   callback_.Run(
-      remove_directory_error == base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY ?
+      remove_directory_error == base::File::FILE_ERROR_NOT_A_DIRECTORY ?
       remove_file_error :
       remove_directory_error);
 }
 
 void RemoveOperationDelegate::DidRemoveFile(const StatusCallback& callback,
-                                            base::PlatformFileError error) {
-  if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND) {
-    callback.Run(base::PLATFORM_FILE_OK);
+                                            base::File::Error error) {
+  if (error == base::File::FILE_ERROR_NOT_FOUND) {
+    callback.Run(base::File::FILE_OK);
     return;
   }
   callback.Run(error);
diff --git a/webkit/browser/fileapi/remove_operation_delegate.h b/webkit/browser/fileapi/remove_operation_delegate.h
index 22d25cb..ee0252a 100644
--- a/webkit/browser/fileapi/remove_operation_delegate.h
+++ b/webkit/browser/fileapi/remove_operation_delegate.h
@@ -29,11 +29,11 @@ class RemoveOperationDelegate : public RecursiveOperationDelegate {
                                     const StatusCallback& callback) OVERRIDE;
 
  private:
-  void DidTryRemoveFile(base::PlatformFileError error);
-  void DidTryRemoveDirectory(base::PlatformFileError remove_file_error,
-                             base::PlatformFileError remove_directory_error);
+  void DidTryRemoveFile(base::File::Error error);
+  void DidTryRemoveDirectory(base::File::Error remove_file_error,
+                             base::File::Error remove_directory_error);
   void DidRemoveFile(const StatusCallback& callback,
-                     base::PlatformFileError error);
+                     base::File::Error error);
 
   FileSystemURL url_;
   StatusCallback callback_;
diff --git a/webkit/browser/fileapi/sandbox_directory_database.cc b/webkit/browser/fileapi/sandbox_directory_database.cc
index 1eb23b2..351b67c 100644
--- a/webkit/browser/fileapi/sandbox_directory_database.cc
+++ b/webkit/browser/fileapi/sandbox_directory_database.cc
@@ -518,10 +518,10 @@ bool SandboxDirectoryDatabase::GetFileInfo(FileId file_id, FileInfo* info) {
   return false;
 }
 
-base::PlatformFileError SandboxDirectoryDatabase::AddFileInfo(
+base::File::Error SandboxDirectoryDatabase::AddFileInfo(
     const FileInfo& info, FileId* file_id) {
   if (!Init(REPAIR_ON_CORRUPTION))
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
   DCHECK(file_id);
   std::string child_key = GetChildLookupKey(info.parent_id, info.name);
   std::string child_id_string;
@@ -529,16 +529,16 @@ base::PlatformFileError SandboxDirectoryDatabase::AddFileInfo(
       db_->Get(leveldb::ReadOptions(), child_key, &child_id_string);
   if (status.ok()) {
     LOG(ERROR) << "File exists already!";
-    return base::PLATFORM_FILE_ERROR_EXISTS;
+    return base::File::FILE_ERROR_EXISTS;
   }
   if (!status.IsNotFound()) {
     HandleError(FROM_HERE, status);
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return base::File::FILE_ERROR_NOT_FOUND;
   }
 
   if (!IsDirectory(info.parent_id)) {
     LOG(ERROR) << "New parent directory is a file!";
-    return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
+    return base::File::FILE_ERROR_NOT_A_DIRECTORY;
   }
 
   // This would be a fine place to limit the number of files in a directory, if
@@ -546,21 +546,21 @@ base::PlatformFileError SandboxDirectoryDatabase::AddFileInfo(
 
   FileId temp_id;
   if (!GetLastFileId(&temp_id))
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
   ++temp_id;
 
   leveldb::WriteBatch batch;
   if (!AddFileInfoHelper(info, temp_id, &batch))
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
 
   batch.Put(LastFileIdKey(), base::Int64ToString(temp_id));
   status = db_->Write(leveldb::WriteOptions(), &batch);
   if (!status.ok()) {
     HandleError(FROM_HERE, status);
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
   }
   *file_id = temp_id;
-  return base::PLATFORM_FILE_OK;
+  return base::File::FILE_OK;
 }
 
 bool SandboxDirectoryDatabase::RemoveFileInfo(FileId file_id) {
diff --git a/webkit/browser/fileapi/sandbox_directory_database.h b/webkit/browser/fileapi/sandbox_directory_database.h
index 67be432..a984cc4 100644
--- a/webkit/browser/fileapi/sandbox_directory_database.h
+++ b/webkit/browser/fileapi/sandbox_directory_database.h
@@ -8,9 +8,9 @@
 #include <string>
 #include <vector>
 
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/platform_file.h"
 #include "base/time/time.h"
 #include "webkit/browser/webkit_storage_browser_export.h"
 
@@ -69,7 +69,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE SandboxDirectoryDatabase {
   // exist.
   bool ListChildren(FileId parent_id, std::vector<FileId>* children);
   bool GetFileInfo(FileId file_id, FileInfo* info);
-  base::PlatformFileError AddFileInfo(const FileInfo& info, FileId* file_id);
+  base::File::Error AddFileInfo(const FileInfo& info, FileId* file_id);
   bool RemoveFileInfo(FileId file_id);
   // This does a full update of the FileInfo, and is what you'd use for moves
   // and renames.  If you just want to update the modification_time, use
diff --git a/webkit/browser/fileapi/sandbox_directory_database_unittest.cc b/webkit/browser/fileapi/sandbox_directory_database_unittest.cc
index b43dc23..9b5e9ba 100644
--- a/webkit/browser/fileapi/sandbox_directory_database_unittest.cc
+++ b/webkit/browser/fileapi/sandbox_directory_database_unittest.cc
@@ -8,9 +8,9 @@
 #include <limits>
 
 #include "base/file_util.h"
+#include "base/files/file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/platform_file.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -51,7 +51,7 @@ class SandboxDirectoryDatabaseTest : public testing::Test {
     db_.reset();
   }
 
-  base::PlatformFileError AddFileInfo(
+  base::File::Error AddFileInfo(
       FileId parent_id, const base::FilePath::StringType& name) {
     FileId file_id;
     FileInfo info;
@@ -66,7 +66,7 @@ class SandboxDirectoryDatabaseTest : public testing::Test {
     FileInfo info;
     info.parent_id = parent_id;
     info.name = name;
-    ASSERT_EQ(base::PLATFORM_FILE_OK, db_->AddFileInfo(info, file_id_out));
+    ASSERT_EQ(base::File::FILE_OK, db_->AddFileInfo(info, file_id_out));
   }
 
   void CreateFile(FileId parent_id,
@@ -79,21 +79,16 @@ class SandboxDirectoryDatabaseTest : public testing::Test {
     info.parent_id = parent_id;
     info.name = name;
     info.data_path = base::FilePath(data_path).NormalizePathSeparators();
-    ASSERT_EQ(base::PLATFORM_FILE_OK, db_->AddFileInfo(info, &file_id));
+    ASSERT_EQ(base::File::FILE_OK, db_->AddFileInfo(info, &file_id));
 
     base::FilePath local_path = path().Append(data_path);
     if (!base::DirectoryExists(local_path.DirName()))
       ASSERT_TRUE(base::CreateDirectory(local_path.DirName()));
 
-    bool created = false;
-    base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
-    base::PlatformFile file = base::CreatePlatformFile(
-        local_path,
-        base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE,
-        &created, &error);
-    ASSERT_EQ(base::PLATFORM_FILE_OK, error);
-    ASSERT_TRUE(created);
-    ASSERT_TRUE(base::ClosePlatformFile(file));
+    base::File file(local_path,
+                    base::File::FLAG_CREATE | base::File::FLAG_WRITE);
+    ASSERT_TRUE(file.IsValid());
+    ASSERT_TRUE(file.created());
 
     if (file_id_out)
       *file_id_out = file_id;
@@ -162,7 +157,7 @@ TEST_F(SandboxDirectoryDatabaseTest, TestGetRootFileInfoBeforeCreate) {
 
 TEST_F(SandboxDirectoryDatabaseTest, TestMissingParentAddFileInfo) {
   FileId parent_id = 7;
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_A_DIRECTORY,
             AddFileInfo(parent_id, FILE_PATH_LITERAL("foo")));
 }
 
@@ -171,21 +166,21 @@ TEST_F(SandboxDirectoryDatabaseTest, TestAddNameClash) {
   FileId file_id;
   info.parent_id = 0;
   info.name = FILE_PATH_LITERAL("dir 0");
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id));
 
   // Check for name clash in the root directory.
   base::FilePath::StringType name = info.name;
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, AddFileInfo(0, name));
+  EXPECT_EQ(base::File::FILE_ERROR_EXISTS, AddFileInfo(0, name));
   name = FILE_PATH_LITERAL("dir 1");
-  EXPECT_EQ(base::PLATFORM_FILE_OK, AddFileInfo(0, name));
+  EXPECT_EQ(base::File::FILE_OK, AddFileInfo(0, name));
 
   name = FILE_PATH_LITERAL("subdir 0");
-  EXPECT_EQ(base::PLATFORM_FILE_OK, AddFileInfo(file_id, name));
+  EXPECT_EQ(base::File::FILE_OK, AddFileInfo(file_id, name));
 
   // Check for name clash in a subdirectory.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, AddFileInfo(file_id, name));
+  EXPECT_EQ(base::File::FILE_ERROR_EXISTS, AddFileInfo(file_id, name));
   name = FILE_PATH_LITERAL("subdir 1");
-  EXPECT_EQ(base::PLATFORM_FILE_OK, AddFileInfo(file_id, name));
+  EXPECT_EQ(base::File::FILE_OK, AddFileInfo(file_id, name));
 }
 
 TEST_F(SandboxDirectoryDatabaseTest, TestRenameNoMoveNameClash) {
@@ -196,8 +191,8 @@ TEST_F(SandboxDirectoryDatabaseTest, TestRenameNoMoveNameClash) {
   base::FilePath::StringType name2 = FILE_PATH_LITERAL("bas");
   info.parent_id = 0;
   info.name = name0;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id0));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, AddFileInfo(0, name1));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id0));
+  EXPECT_EQ(base::File::FILE_OK, AddFileInfo(0, name1));
   info.name = name1;
   EXPECT_FALSE(db()->UpdateFileInfo(file_id0, info));
   info.name = name2;
@@ -212,9 +207,9 @@ TEST_F(SandboxDirectoryDatabaseTest, TestMoveSameNameNameClash) {
   base::FilePath::StringType name1 = FILE_PATH_LITERAL("bar");
   info.parent_id = 0;
   info.name = name0;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id0));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id0));
   info.parent_id = file_id0;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id1));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id1));
   info.parent_id = 0;
   EXPECT_FALSE(db()->UpdateFileInfo(file_id1, info));
   info.name = name1;
@@ -230,10 +225,10 @@ TEST_F(SandboxDirectoryDatabaseTest, TestMoveRenameNameClash) {
   base::FilePath::StringType name2 = FILE_PATH_LITERAL("bas");
   info.parent_id = 0;
   info.name = name0;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id0));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id0));
   info.parent_id = file_id0;
   info.name = name1;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id1));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id1));
   info.parent_id = 0;
   info.name = name0;
   EXPECT_FALSE(db()->UpdateFileInfo(file_id1, info));
@@ -251,9 +246,9 @@ TEST_F(SandboxDirectoryDatabaseTest, TestRemoveWithChildren) {
   FileId file_id1;
   info.parent_id = 0;
   info.name = FILE_PATH_LITERAL("foo");
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id0));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id0));
   info.parent_id = file_id0;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id1));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id1));
   EXPECT_FALSE(db()->RemoveFileInfo(file_id0));
   EXPECT_TRUE(db()->RemoveFileInfo(file_id1));
   EXPECT_TRUE(db()->RemoveFileInfo(file_id0));
@@ -267,10 +262,10 @@ TEST_F(SandboxDirectoryDatabaseTest, TestGetChildWithName) {
   base::FilePath::StringType name1 = FILE_PATH_LITERAL("bar");
   info.parent_id = 0;
   info.name = name0;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id0));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id0));
   info.parent_id = file_id0;
   info.name = name1;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id1));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id1));
   EXPECT_NE(file_id0, file_id1);
 
   FileId check_file_id;
@@ -293,14 +288,14 @@ TEST_F(SandboxDirectoryDatabaseTest, TestGetFileWithPath) {
 
   info.parent_id = 0;
   info.name = name0;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id0));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id0));
   info.parent_id = file_id0;
   info.name = name1;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id1));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id1));
   EXPECT_NE(file_id0, file_id1);
   info.parent_id = file_id1;
   info.name = name2;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id2));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id2));
   EXPECT_NE(file_id0, file_id2);
   EXPECT_NE(file_id1, file_id2);
 
@@ -329,7 +324,7 @@ TEST_F(SandboxDirectoryDatabaseTest, TestListChildren) {
   FileInfo info;
   info.parent_id = 0;
   info.name = FILE_PATH_LITERAL("foo");
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id0));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id0));
   EXPECT_TRUE(db()->ListChildren(0, &children));
   EXPECT_EQ(children.size(), 1UL);
   EXPECT_EQ(children[0], file_id0);
@@ -337,7 +332,7 @@ TEST_F(SandboxDirectoryDatabaseTest, TestListChildren) {
   // Two children in the root.
   FileId file_id1;
   info.name = FILE_PATH_LITERAL("bar");
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id1));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id1));
   EXPECT_TRUE(db()->ListChildren(0, &children));
   EXPECT_EQ(2UL, children.size());
   if (children[0] == file_id0) {
@@ -356,14 +351,14 @@ TEST_F(SandboxDirectoryDatabaseTest, TestListChildren) {
   info.name = FILE_PATH_LITERAL("foo");
   FileId file_id2;
   FileId file_id3;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id2));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id2));
   EXPECT_TRUE(db()->ListChildren(file_id0, &children));
   EXPECT_EQ(1UL, children.size());
   EXPECT_EQ(children[0], file_id2);
 
   // Two children in a subdirectory.
   info.name = FILE_PATH_LITERAL("bar");
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info, &file_id3));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info, &file_id3));
   EXPECT_TRUE(db()->ListChildren(file_id0, &children));
   EXPECT_EQ(2UL, children.size());
   if (children[0] == file_id2) {
@@ -381,7 +376,7 @@ TEST_F(SandboxDirectoryDatabaseTest, TestUpdateModificationTime) {
   info0.name = FILE_PATH_LITERAL("name");
   info0.data_path = base::FilePath(FILE_PATH_LITERAL("fake path"));
   info0.modification_time = base::Time::Now();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info0, &file_id));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info0, &file_id));
   FileInfo info1;
   EXPECT_TRUE(db()->GetFileInfo(file_id, &info1));
   EXPECT_EQ(info0.name, info1.name);
@@ -412,7 +407,7 @@ TEST_F(SandboxDirectoryDatabaseTest, TestSimpleFileOperations) {
   info0.data_path = base::FilePath(FILE_PATH_LITERAL("foo"));
   info0.name = FILE_PATH_LITERAL("file name");
   info0.modification_time = base::Time::Now();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info0, &file_id));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info0, &file_id));
   FileInfo info1;
   EXPECT_TRUE(db()->GetFileInfo(file_id, &info1));
   EXPECT_EQ(info0.parent_id, info1.parent_id);
@@ -429,7 +424,7 @@ TEST_F(SandboxDirectoryDatabaseTest, TestOverwritingMoveFileSrcDirectory) {
   info0.parent_id = 0;
   info0.name = FILE_PATH_LITERAL("directory");
   info0.modification_time = base::Time::Now();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info0, &directory_id));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info0, &directory_id));
 
   FileId file_id;
   FileInfo info1;
@@ -437,7 +432,7 @@ TEST_F(SandboxDirectoryDatabaseTest, TestOverwritingMoveFileSrcDirectory) {
   info1.data_path = base::FilePath(FILE_PATH_LITERAL("bar"));
   info1.name = FILE_PATH_LITERAL("file");
   info1.modification_time = base::Time::UnixEpoch();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info1, &file_id));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info1, &file_id));
 
   EXPECT_FALSE(db()->OverwritingMoveFile(directory_id, file_id));
 }
@@ -449,14 +444,14 @@ TEST_F(SandboxDirectoryDatabaseTest, TestOverwritingMoveFileDestDirectory) {
   info0.name = FILE_PATH_LITERAL("file");
   info0.data_path = base::FilePath(FILE_PATH_LITERAL("bar"));
   info0.modification_time = base::Time::Now();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info0, &file_id));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info0, &file_id));
 
   FileId directory_id;
   FileInfo info1;
   info1.parent_id = 0;
   info1.name = FILE_PATH_LITERAL("directory");
   info1.modification_time = base::Time::UnixEpoch();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info1, &directory_id));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info1, &directory_id));
 
   EXPECT_FALSE(db()->OverwritingMoveFile(file_id, directory_id));
 }
@@ -468,13 +463,13 @@ TEST_F(SandboxDirectoryDatabaseTest, TestOverwritingMoveFileSuccess) {
   info0.data_path = base::FilePath(FILE_PATH_LITERAL("foo"));
   info0.name = FILE_PATH_LITERAL("file name 0");
   info0.modification_time = base::Time::Now();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info0, &file_id0));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info0, &file_id0));
 
   FileInfo dir_info;
   FileId dir_id;
   dir_info.parent_id = 0;
   dir_info.name = FILE_PATH_LITERAL("directory name");
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(dir_info, &dir_id));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(dir_info, &dir_id));
 
   FileId file_id1;
   FileInfo info1;
@@ -482,7 +477,7 @@ TEST_F(SandboxDirectoryDatabaseTest, TestOverwritingMoveFileSuccess) {
   info1.data_path = base::FilePath(FILE_PATH_LITERAL("bar"));
   info1.name = FILE_PATH_LITERAL("file name 1");
   info1.modification_time = base::Time::UnixEpoch();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, db()->AddFileInfo(info1, &file_id1));
+  EXPECT_EQ(base::File::FILE_OK, db()->AddFileInfo(info1, &file_id1));
 
   EXPECT_TRUE(db()->OverwritingMoveFile(file_id0, file_id1));
 
@@ -557,15 +552,11 @@ TEST_F(SandboxDirectoryDatabaseTest, TestConsistencyCheck_OrphanFile) {
 
   EXPECT_TRUE(db()->IsFileSystemConsistent());
 
-  bool created = false;
-  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
-  base::PlatformFile file = base::CreatePlatformFile(
-      path().Append(FPL("Orphan File")),
-      base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE,
-      &created, &error);
-  ASSERT_EQ(base::PLATFORM_FILE_OK, error);
-  ASSERT_TRUE(created);
-  ASSERT_TRUE(base::ClosePlatformFile(file));
+  base::File file(path().Append(FPL("Orphan File")),
+                  base::File::FLAG_CREATE | base::File::FLAG_WRITE);
+  ASSERT_TRUE(file.IsValid());
+  ASSERT_TRUE(file.created());
+  file.Close();
 
   EXPECT_TRUE(db()->IsFileSystemConsistent());
 }
diff --git a/webkit/browser/fileapi/sandbox_file_stream_writer.cc b/webkit/browser/fileapi/sandbox_file_stream_writer.cc
index 404bdba..a4e5df1 100644
--- a/webkit/browser/fileapi/sandbox_file_stream_writer.cc
+++ b/webkit/browser/fileapi/sandbox_file_stream_writer.cc
@@ -112,16 +112,16 @@ int SandboxFileStreamWriter::WriteInternal(
 
 void SandboxFileStreamWriter::DidCreateSnapshotFile(
     const net::CompletionCallback& callback,
-    base::PlatformFileError file_error,
-    const base::PlatformFileInfo& file_info,
+    base::File::Error file_error,
+    const base::File::Info& file_info,
     const base::FilePath& platform_path,
     const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
   DCHECK(!file_ref.get());
 
   if (CancelIfRequested())
     return;
-  if (file_error != base::PLATFORM_FILE_OK) {
-    callback.Run(net::PlatformFileErrorToNetError(file_error));
+  if (file_error != base::File::FILE_OK) {
+    callback.Run(net::FileErrorToNetError(file_error));
     return;
   }
   if (file_info.is_directory) {
diff --git a/webkit/browser/fileapi/sandbox_file_stream_writer.h b/webkit/browser/fileapi/sandbox_file_stream_writer.h
index 8112337..53cbb50 100644
--- a/webkit/browser/fileapi/sandbox_file_stream_writer.h
+++ b/webkit/browser/fileapi/sandbox_file_stream_writer.h
@@ -5,9 +5,9 @@
 #ifndef WEBKIT_BROWSER_FILEAPI_SANDBOX_FILE_STREAM_WRITER_H_
 #define WEBKIT_BROWSER_FILEAPI_SANDBOX_FILE_STREAM_WRITER_H_
 
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/platform_file.h"
 #include "url/gurl.h"
 #include "webkit/browser/fileapi/file_stream_writer.h"
 #include "webkit/browser/fileapi/file_system_url.h"
@@ -52,8 +52,8 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE SandboxFileStreamWriter
   // WriteInternal.
   void DidCreateSnapshotFile(
       const net::CompletionCallback& callback,
-      base::PlatformFileError file_error,
-      const base::PlatformFileInfo& file_info,
+      base::File::Error file_error,
+      const base::File::Info& file_info,
       const base::FilePath& platform_path,
       const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref);
   void DidGetUsageAndQuota(const net::CompletionCallback& callback,
diff --git a/webkit/browser/fileapi/sandbox_file_system_backend.cc b/webkit/browser/fileapi/sandbox_file_system_backend.cc
index cc02278..f068a77 100644
--- a/webkit/browser/fileapi/sandbox_file_system_backend.cc
+++ b/webkit/browser/fileapi/sandbox_file_system_backend.cc
@@ -71,7 +71,7 @@ void SandboxFileSystemBackend::OpenFileSystem(
       !(type == kFileSystemTypeTemporary &&
         enable_temporary_file_system_in_incognito_)) {
     // TODO(kinuko): return an isolated temporary directory.
-    callback.Run(GURL(), std::string(), base::PLATFORM_FILE_ERROR_SECURITY);
+    callback.Run(GURL(), std::string(), base::File::FILE_ERROR_SECURITY);
     return;
   }
 
@@ -89,16 +89,16 @@ AsyncFileUtil* SandboxFileSystemBackend::GetAsyncFileUtil(
 CopyOrMoveFileValidatorFactory*
 SandboxFileSystemBackend::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* SandboxFileSystemBackend::CreateFileSystemOperation(
     const FileSystemURL& url,
     FileSystemContext* context,
-    base::PlatformFileError* error_code) const {
+    base::File::Error* error_code) const {
   DCHECK(CanHandleType(url.type()));
   DCHECK(error_code);
 
diff --git a/webkit/browser/fileapi/sandbox_file_system_backend.h b/webkit/browser/fileapi/sandbox_file_system_backend.h
index 8531cf8..c3bde3e 100644
--- a/webkit/browser/fileapi/sandbox_file_system_backend.h
+++ b/webkit/browser/fileapi/sandbox_file_system_backend.h
@@ -43,11 +43,11 @@ class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackend
   virtual AsyncFileUtil* GetAsyncFileUtil(FileSystemType type) OVERRIDE;
   virtual CopyOrMoveFileValidatorFactory* GetCopyOrMoveFileValidatorFactory(
       FileSystemType type,
-      base::PlatformFileError* error_code) OVERRIDE;
+      base::File::Error* error_code) OVERRIDE;
   virtual FileSystemOperation* CreateFileSystemOperation(
       const FileSystemURL& url,
       FileSystemContext* context,
-      base::PlatformFileError* error_code) const OVERRIDE;
+      base::File::Error* error_code) const OVERRIDE;
   virtual scoped_ptr<webkit_blob::FileStreamReader> CreateFileStreamReader(
       const FileSystemURL& url,
       int64 offset,
diff --git a/webkit/browser/fileapi/sandbox_file_system_backend_delegate.cc b/webkit/browser/fileapi/sandbox_file_system_backend_delegate.cc
index ce18afe1..92545a1 100644
--- a/webkit/browser/fileapi/sandbox_file_system_backend_delegate.cc
+++ b/webkit/browser/fileapi/sandbox_file_system_backend_delegate.cc
@@ -112,13 +112,13 @@ void OpenFileSystemOnFileTaskRunner(
     const GURL& origin_url,
     FileSystemType type,
     OpenFileSystemMode mode,
-    base::PlatformFileError* error_ptr) {
+    base::File::Error* error_ptr) {
   DCHECK(error_ptr);
   const bool create = (mode == OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT);
   file_util->GetDirectoryForOriginAndType(
       origin_url, SandboxFileSystemBackendDelegate::GetTypeString(type),
       create, error_ptr);
-  if (*error_ptr != base::PLATFORM_FILE_OK) {
+  if (*error_ptr != base::File::FILE_OK) {
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
                               kCreateDirectoryError,
                               kFileSystemErrorMax);
@@ -132,8 +132,8 @@ void OpenFileSystemOnFileTaskRunner(
 
 void DidOpenFileSystem(
     base::WeakPtr<SandboxFileSystemBackendDelegate> delegate,
-    const base::Callback<void(base::PlatformFileError error)>& callback,
-    base::PlatformFileError* error) {
+    const base::Callback<void(base::File::Error error)>& callback,
+    base::File::Error* error) {
   if (delegate.get())
     delegate.get()->CollectOpenFileSystemMetrics(*error);
   callback.Run(*error);
@@ -236,10 +236,10 @@ SandboxFileSystemBackendDelegate::GetBaseDirectoryForOriginAndType(
     const GURL& origin_url,
     FileSystemType type,
     bool create) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   base::FilePath path = obfuscated_file_util()->GetDirectoryForOriginAndType(
       origin_url, GetTypeString(type), create, &error);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return base::FilePath();
   return path;
 }
@@ -251,13 +251,13 @@ void SandboxFileSystemBackendDelegate::OpenFileSystem(
     const OpenFileSystemCallback& callback,
     const GURL& root_url) {
   if (!IsAllowedScheme(origin_url)) {
-    callback.Run(GURL(), std::string(), base::PLATFORM_FILE_ERROR_SECURITY);
+    callback.Run(GURL(), std::string(), base::File::FILE_ERROR_SECURITY);
     return;
   }
 
   std::string name = GetFileSystemName(origin_url, type);
 
-  base::PlatformFileError* error_ptr = new base::PlatformFileError;
+  base::File::Error* error_ptr = new base::File::Error;
   file_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&OpenFileSystemOnFileTaskRunner,
@@ -276,9 +276,9 @@ scoped_ptr<FileSystemOperationContext>
 SandboxFileSystemBackendDelegate::CreateFileSystemOperationContext(
     const FileSystemURL& url,
     FileSystemContext* context,
-    base::PlatformFileError* error_code) const {
+    base::File::Error* error_code) const {
   if (!IsAccessValid(url)) {
-    *error_code = base::PLATFORM_FILE_ERROR_SECURITY;
+    *error_code = base::File::FILE_ERROR_SECURITY;
     return scoped_ptr<FileSystemOperationContext>();
   }
 
@@ -322,7 +322,7 @@ SandboxFileSystemBackendDelegate::CreateFileStreamWriter(
       new SandboxFileStreamWriter(context, url, offset, *observers));
 }
 
-base::PlatformFileError
+base::File::Error
 SandboxFileSystemBackendDelegate::DeleteOriginDataOnFileTaskRunner(
     FileSystemContext* file_system_context,
     quota::QuotaManagerProxy* proxy,
@@ -343,8 +343,8 @@ SandboxFileSystemBackendDelegate::DeleteOriginDataOnFileTaskRunner(
   }
 
   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 SandboxFileSystemBackendDelegate::GetOriginsForTypeOnFileTaskRunner(
@@ -494,10 +494,10 @@ void SandboxFileSystemBackendDelegate::RegisterQuotaUpdateObserver(
 void SandboxFileSystemBackendDelegate::InvalidateUsageCache(
     const GURL& origin,
     FileSystemType type) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   base::FilePath usage_file_path = GetUsageCachePathForOriginAndType(
       obfuscated_file_util(), origin, type, &error);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return;
   usage_cache()->IncrementDirty(usage_file_path);
 }
@@ -568,10 +568,10 @@ base::FilePath
 SandboxFileSystemBackendDelegate::GetUsageCachePathForOriginAndType(
     const GURL& origin_url,
     FileSystemType type) {
-  base::PlatformFileError error;
+  base::File::Error error;
   base::FilePath path = GetUsageCachePathForOriginAndType(
       obfuscated_file_util(), origin_url, type, &error);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return base::FilePath();
   return path;
 }
@@ -582,12 +582,12 @@ SandboxFileSystemBackendDelegate::GetUsageCachePathForOriginAndType(
     ObfuscatedFileUtil* sandbox_file_util,
     const GURL& origin_url,
     FileSystemType type,
-    base::PlatformFileError* error_out) {
+    base::File::Error* error_out) {
   DCHECK(error_out);
-  *error_out = base::PLATFORM_FILE_OK;
+  *error_out = base::File::FILE_OK;
   base::FilePath base_path = sandbox_file_util->GetDirectoryForOriginAndType(
       origin_url, GetTypeString(type), false /* create */, error_out);
-  if (*error_out != base::PLATFORM_FILE_OK)
+  if (*error_out != base::File::FILE_OK)
     return base::FilePath();
   return base_path.Append(FileSystemUsageCache::kUsageFileName);
 }
@@ -615,7 +615,7 @@ int64 SandboxFileSystemBackendDelegate::RecalculateUsage(
 }
 
 void SandboxFileSystemBackendDelegate::CollectOpenFileSystemMetrics(
-    base::PlatformFileError error_code) {
+    base::File::Error error_code) {
   base::Time now = base::Time::Now();
   bool throttled = now < next_release_time_for_open_filesystem_stat_;
   if (!throttled) {
@@ -634,16 +634,16 @@ void SandboxFileSystemBackendDelegate::CollectOpenFileSystemMetrics(
   }
 
   switch (error_code) {
-    case base::PLATFORM_FILE_OK:
+    case base::File::FILE_OK:
       REPORT(kOK);
       break;
-    case base::PLATFORM_FILE_ERROR_INVALID_URL:
+    case base::File::FILE_ERROR_INVALID_URL:
       REPORT(kInvalidSchemeError);
       break;
-    case base::PLATFORM_FILE_ERROR_NOT_FOUND:
+    case base::File::FILE_ERROR_NOT_FOUND:
       REPORT(kNotFound);
       break;
-    case base::PLATFORM_FILE_ERROR_FAILED:
+    case base::File::FILE_ERROR_FAILED:
     default:
       REPORT(kUnknownError);
       break;
diff --git a/webkit/browser/fileapi/sandbox_file_system_backend_delegate.h b/webkit/browser/fileapi/sandbox_file_system_backend_delegate.h
index 9595cda..2b67cfc 100644
--- a/webkit/browser/fileapi/sandbox_file_system_backend_delegate.h
+++ b/webkit/browser/fileapi/sandbox_file_system_backend_delegate.h
@@ -113,7 +113,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackendDelegate
   scoped_ptr<FileSystemOperationContext> CreateFileSystemOperationContext(
       const FileSystemURL& url,
       FileSystemContext* context,
-      base::PlatformFileError* error_code) const;
+      base::File::Error* error_code) const;
   scoped_ptr<webkit_blob::FileStreamReader> CreateFileStreamReader(
       const FileSystemURL& url,
       int64 offset,
@@ -126,7 +126,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackendDelegate
       FileSystemType type) const;
 
   // FileSystemQuotaUtil overrides.
-  virtual base::PlatformFileError DeleteOriginDataOnFileTaskRunner(
+  virtual base::File::Error DeleteOriginDataOnFileTaskRunner(
       FileSystemContext* context,
       quota::QuotaManagerProxy* proxy,
       const GURL& origin_url,
@@ -173,7 +173,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackendDelegate
   void StickyInvalidateUsageCache(const GURL& origin_url,
                                   FileSystemType type);
 
-  void CollectOpenFileSystemMetrics(base::PlatformFileError error_code);
+  void CollectOpenFileSystemMetrics(base::File::Error error_code);
 
   base::SequencedTaskRunner* file_task_runner() {
     return file_task_runner_.get();
@@ -217,7 +217,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackendDelegate
       ObfuscatedFileUtil* sandbox_file_util,
       const GURL& origin_url,
       FileSystemType type,
-      base::PlatformFileError* error_out);
+      base::File::Error* error_out);
 
   int64 RecalculateUsage(FileSystemContext* context,
                          const GURL& origin,
diff --git a/webkit/browser/fileapi/sandbox_quota_observer.cc b/webkit/browser/fileapi/sandbox_quota_observer.cc
index e81e440..42b6d08 100644
--- a/webkit/browser/fileapi/sandbox_quota_observer.cc
+++ b/webkit/browser/fileapi/sandbox_quota_observer.cc
@@ -105,11 +105,11 @@ void SandboxQuotaObserver::SetUsageCacheEnabled(
 base::FilePath SandboxQuotaObserver::GetUsageCachePath(
     const FileSystemURL& url) {
   DCHECK(sandbox_file_util_);
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   base::FilePath path =
       SandboxFileSystemBackendDelegate::GetUsageCachePathForOriginAndType(
           sandbox_file_util_, url.origin(), url.type(), &error);
-  if (error != base::PLATFORM_FILE_OK) {
+  if (error != base::File::FILE_OK) {
     LOG(WARNING) << "Could not get usage cache path for: "
                  << url.DebugString();
     return base::FilePath();
diff --git a/webkit/browser/fileapi/transient_file_util.cc b/webkit/browser/fileapi/transient_file_util.cc
index 74c2dbea..4cac5ca 100644
--- a/webkit/browser/fileapi/transient_file_util.cc
+++ b/webkit/browser/fileapi/transient_file_util.cc
@@ -28,14 +28,14 @@ void RevokeFileSystem(const std::string& filesystem_id,
 ScopedFile TransientFileUtil::CreateSnapshotFile(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
-    base::PlatformFileError* error,
-    base::PlatformFileInfo* file_info,
+    base::File::Error* error,
+    base::File::Info* file_info,
     base::FilePath* platform_path) {
   DCHECK(file_info);
   *error = GetFileInfo(context, url, file_info, platform_path);
-  if (*error == base::PLATFORM_FILE_OK && file_info->is_directory)
-    *error = base::PLATFORM_FILE_ERROR_NOT_A_FILE;
-  if (*error != base::PLATFORM_FILE_OK)
+  if (*error == base::File::FILE_OK && file_info->is_directory)
+    *error = base::File::FILE_ERROR_NOT_A_FILE;
+  if (*error != base::File::FILE_OK)
     return ScopedFile();
 
   // Sets-up a transient filesystem.
diff --git a/webkit/browser/fileapi/transient_file_util.h b/webkit/browser/fileapi/transient_file_util.h
index 1e67c85..6ffb48c 100644
--- a/webkit/browser/fileapi/transient_file_util.h
+++ b/webkit/browser/fileapi/transient_file_util.h
@@ -23,8 +23,8 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE TransientFileUtil
   virtual webkit_blob::ScopedFile CreateSnapshotFile(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
-      base::PlatformFileError* error,
-      base::PlatformFileInfo* file_info,
+      base::File::Error* error,
+      base::File::Info* file_info,
       base::FilePath* platform_path) OVERRIDE;
 
  private: