Convert Media Galleries to use base::File

content/browser/fileapi/file_system_operation_impl_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/browser/fileapi/file_system_operation_impl.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
@@ skipping 27 matching lines @@
 using quota::QuotaManagerProxy;
 using webkit_blob::ShareableFileReference;
 
 namespace content {
 
 namespace {
 
 const int kFileOperationStatusNotSet = 1;
 
 void AssertFileErrorEq(const tracked_objects::Location& from_here,
-                       base::PlatformFileError expected,
-                       base::PlatformFileError actual) {
+                       base::File::Error expected,
+                       base::File::Error actual) {
   ASSERT_EQ(expected, actual) << from_here.ToString();
 }
 
 }  // namespace
 
 // Test class for FileSystemOperationImpl.
 class FileSystemOperationImplTest
     : public testing::Test {
  public:
   FileSystemOperationImplTest()
@@ skipping 25 matching lines @@
     quota_manager_ = NULL;
     quota_manager_proxy_ = NULL;
     sandbox_file_system_.TearDown();
   }
 
   FileSystemOperationRunner* operation_runner() {
     return sandbox_file_system_.operation_runner();
   }
 
   int status() const { return status_; }
-  const base::PlatformFileInfo& info() const { return info_; }
+  const base::File::Info& info() const { return info_; }
   const base::FilePath& path() const { return path_; }
   const std::vector<fileapi::DirectoryEntry>& entries() const {
     return entries_;
   }
 
   const ShareableFileReference* shareable_file_ref() const {
     return shareable_file_ref_.get();
   }
 
   quota::MockQuotaManager* quota_manager() {
@@ skipping 37 matching lines @@
   }
 
   bool DirectoryExists(const std::string& path) {
     return AsyncFileTestHelper::DirectoryExists(
         sandbox_file_system_.file_system_context(), URLForPath(path));
   }
 
   FileSystemURL CreateFile(const std::string& path) {
     FileSystemURL url = URLForPath(path);
     bool created = false;
-    EXPECT_EQ(base::PLATFORM_FILE_OK,
+    EXPECT_EQ(base::File::FILE_OK,
               file_util()->EnsureFileExists(NewContext().get(),
                                             url, &created));
     EXPECT_TRUE(created);
     return url;
   }
 
   FileSystemURL CreateDirectory(const std::string& path) {
     FileSystemURL url = URLForPath(path);
-    EXPECT_EQ(base::PLATFORM_FILE_OK,
+    EXPECT_EQ(base::File::FILE_OK,
               file_util()->CreateDirectory(NewContext().get(), url,
                                            false /* exclusive */, true));
     return url;
   }
 
   int64 GetFileSize(const std::string& path) {
     base::File::Info info;
     EXPECT_TRUE(base::GetFileInfo(PlatformPath(path), &info));
     return info.size;
   }
@@ skipping 13 matching lines @@
   FileSystemOperation::GetMetadataCallback RecordMetadataCallback() {
     return base::Bind(&FileSystemOperationImplTest::DidGetMetadata,
                       weak_factory_.GetWeakPtr());
   }
 
   FileSystemOperation::SnapshotFileCallback RecordSnapshotFileCallback() {
     return base::Bind(&FileSystemOperationImplTest::DidCreateSnapshotFile,
                       weak_factory_.GetWeakPtr());
   }
 
-  void DidFinish(base::PlatformFileError status) {
+  void DidFinish(base::File::Error status) {
     status_ = status;
   }
 
   void DidReadDirectory(
-      base::PlatformFileError status,
+      base::File::Error status,
       const std::vector<fileapi::DirectoryEntry>& entries,
       bool /* has_more */) {
     entries_ = entries;
     status_ = status;
   }
 
-  void DidGetMetadata(base::PlatformFileError status,
-                      const base::PlatformFileInfo& info) {
+  void DidGetMetadata(base::File::Error status,
+                      const base::File::Info& info) {
     info_ = info;
     status_ = status;
   }
 
   void DidCreateSnapshotFile(
-      base::PlatformFileError status,
-      const base::PlatformFileInfo& info,
+      base::File::Error status,
+      const base::File::Info& info,
       const base::FilePath& platform_path,
       const scoped_refptr<ShareableFileReference>& shareable_file_ref) {
     info_ = info;
     path_ = platform_path;
     status_ = status;
     shareable_file_ref_ = shareable_file_ref;
   }
 
   int64 GetDataSizeOnDisk() {
     return sandbox_file_system_.ComputeCurrentOriginUsage() -
@@ skipping 12 matching lines @@
   }
 
   int64 ComputePathCost(const FileSystemURL& url) {
     int64 base_usage;
     GetUsageAndQuota(&base_usage, NULL);
 
     AsyncFileTestHelper::CreateFile(
         sandbox_file_system_.file_system_context(), url);
     operation_runner()->Remove(url, false /* recursive */,
                                base::Bind(&AssertFileErrorEq, FROM_HERE,
-                                          base::PLATFORM_FILE_OK));
+                                          base::File::FILE_OK));
     base::RunLoop().RunUntilIdle();
     change_observer()->ResetCount();
 
     int64 total_usage;
     GetUsageAndQuota(&total_usage, NULL);
     return total_usage - base_usage;
   }
 
   void GrantQuotaForCurrentUsage() {
     int64 usage;
@@ skipping 22 matching lines @@
   scoped_refptr<QuotaManager> quota_manager_;
   scoped_refptr<QuotaManagerProxy> quota_manager_proxy_;
 
   // Common temp base for nondestructive uses.
   base::ScopedTempDir base_;
 
   SandboxFileSystemTestHelper sandbox_file_system_;
 
   // For post-operation status.
   int status_;
-  base::PlatformFileInfo info_;
+  base::File::Info info_;
   base::FilePath path_;
   std::vector<fileapi::DirectoryEntry> entries_;
   scoped_refptr<ShareableFileReference> shareable_file_ref_;
 
   fileapi::MockFileChangeObserver change_observer_;
   fileapi::ChangeObserverList change_observers_;
 
   base::WeakPtrFactory<FileSystemOperationImplTest> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemOperationImplTest);
 };
 
 TEST_F(FileSystemOperationImplTest, TestMoveFailureSrcDoesntExist) {
   change_observer()->ResetCount();
   operation_runner()->Move(URLForPath("a"), URLForPath("b"),
                            FileSystemOperation::OPTION_NONE,
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestMoveFailureContainsPath) {
   FileSystemURL src_dir(CreateDirectory("src"));
   FileSystemURL dest_dir(CreateDirectory("src/dest"));
 
   operation_runner()->Move(src_dir, dest_dir,
                            FileSystemOperation::OPTION_NONE,
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, status());
+  EXPECT_EQ(base::File::FILE_ERROR_INVALID_OPERATION, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestMoveFailureSrcDirExistsDestFile) {
   // Src exists and is dir. Dest is a file.
   FileSystemURL src_dir(CreateDirectory("src"));
   FileSystemURL dest_dir(CreateDirectory("dest"));
   FileSystemURL dest_file(CreateFile("dest/file"));
 
   operation_runner()->Move(src_dir, dest_file,
                            FileSystemOperation::OPTION_NONE,
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, status());
+  EXPECT_EQ(base::File::FILE_ERROR_INVALID_OPERATION, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest,
        TestMoveFailureSrcFileExistsDestNonEmptyDir) {
   // Src exists and is a directory. Dest is a non-empty directory.
   FileSystemURL src_dir(CreateDirectory("src"));
   FileSystemURL dest_dir(CreateDirectory("dest"));
   FileSystemURL dest_file(CreateFile("dest/file"));
 
   operation_runner()->Move(src_dir, dest_dir,
                            FileSystemOperation::OPTION_NONE,
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_EMPTY, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_EMPTY, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestMoveFailureSrcFileExistsDestDir) {
   // Src exists and is a file. Dest is a directory.
   FileSystemURL src_dir(CreateDirectory("src"));
   FileSystemURL src_file(CreateFile("src/file"));
   FileSystemURL dest_dir(CreateDirectory("dest"));
 
   operation_runner()->Move(src_file, dest_dir,
                            FileSystemOperation::OPTION_NONE,
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, status());
+  EXPECT_EQ(base::File::FILE_ERROR_INVALID_OPERATION, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestMoveFailureDestParentDoesntExist) {
   // Dest. parent path does not exist.
   FileSystemURL src_dir(CreateDirectory("src"));
   operation_runner()->Move(src_dir, URLForPath("nonexistent/deset"),
                            FileSystemOperation::OPTION_NONE,
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestMoveSuccessSrcFileAndOverwrite) {
   FileSystemURL src_file(CreateFile("src"));
   FileSystemURL dest_file(CreateFile("dest"));
 
   operation_runner()->Move(src_file, dest_file,
                            FileSystemOperation::OPTION_NONE,
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(FileExists("dest"));
 
   EXPECT_EQ(1, change_observer()->get_and_reset_modify_file_count());
   EXPECT_EQ(1, change_observer()->get_and_reset_remove_file_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 
   EXPECT_EQ(1, quota_manager_proxy()->notify_storage_accessed_count());
 }
 
 TEST_F(FileSystemOperationImplTest, TestMoveSuccessSrcFileAndNew) {
   FileSystemURL src_file(CreateFile("src"));
 
   operation_runner()->Move(src_file, URLForPath("new"),
                            FileSystemOperation::OPTION_NONE,
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(FileExists("new"));
 
   EXPECT_EQ(1, change_observer()->get_and_reset_create_file_from_count());
   EXPECT_EQ(1, change_observer()->get_and_reset_remove_file_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestMoveSuccessSrcDirAndOverwrite) {
   FileSystemURL src_dir(CreateDirectory("src"));
   FileSystemURL dest_dir(CreateDirectory("dest"));
 
   operation_runner()->Move(src_dir, dest_dir,
                            FileSystemOperation::OPTION_NONE,
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_FALSE(DirectoryExists("src"));
 
   EXPECT_EQ(1, change_observer()->get_and_reset_create_directory_count());
   EXPECT_EQ(2, change_observer()->get_and_reset_remove_directory_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 
   // Make sure we've overwritten but not moved the source under the |dest_dir|.
   EXPECT_TRUE(DirectoryExists("dest"));
   EXPECT_FALSE(DirectoryExists("dest/src"));
 }
 
 TEST_F(FileSystemOperationImplTest, TestMoveSuccessSrcDirAndNew) {
   FileSystemURL src_dir(CreateDirectory("src"));
   FileSystemURL dest_dir(CreateDirectory("dest"));
 
   operation_runner()->Move(src_dir, URLForPath("dest/new"),
                            FileSystemOperation::OPTION_NONE,
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_FALSE(DirectoryExists("src"));
   EXPECT_TRUE(DirectoryExists("dest/new"));
 
   EXPECT_EQ(1, change_observer()->get_and_reset_remove_directory_count());
   EXPECT_EQ(1, change_observer()->get_and_reset_create_directory_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestMoveSuccessSrcDirRecursive) {
   FileSystemURL src_dir(CreateDirectory("src"));
   CreateDirectory("src/dir");
   CreateFile("src/dir/sub");
 
   FileSystemURL dest_dir(CreateDirectory("dest"));
 
   operation_runner()->Move(src_dir, dest_dir,
                            FileSystemOperation::OPTION_NONE,
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(DirectoryExists("dest/dir"));
   EXPECT_TRUE(FileExists("dest/dir/sub"));
 
   EXPECT_EQ(3, change_observer()->get_and_reset_remove_directory_count());
   EXPECT_EQ(2, change_observer()->get_and_reset_create_directory_count());
   EXPECT_EQ(1, change_observer()->get_and_reset_remove_file_count());
   EXPECT_EQ(1, change_observer()->get_and_reset_create_file_from_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestMoveSuccessSamePath) {
   FileSystemURL src_dir(CreateDirectory("src"));
   CreateDirectory("src/dir");
   CreateFile("src/dir/sub");
 
   operation_runner()->Move(src_dir, src_dir,
                            FileSystemOperation::OPTION_NONE,
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(DirectoryExists("src/dir"));
   EXPECT_TRUE(FileExists("src/dir/sub"));
 
   EXPECT_EQ(0, change_observer()->get_and_reset_remove_directory_count());
   EXPECT_EQ(0, change_observer()->get_and_reset_create_directory_count());
   EXPECT_EQ(0, change_observer()->get_and_reset_remove_file_count());
   EXPECT_EQ(0, change_observer()->get_and_reset_create_file_from_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopyFailureSrcDoesntExist) {
   operation_runner()->Copy(URLForPath("a"), URLForPath("b"),
                            FileSystemOperation::OPTION_NONE,
                            FileSystemOperationRunner::CopyProgressCallback(),
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopyFailureContainsPath) {
   FileSystemURL src_dir(CreateDirectory("src"));
   FileSystemURL dest_dir(CreateDirectory("src/dir"));
 
   operation_runner()->Copy(src_dir, dest_dir,
                            FileSystemOperation::OPTION_NONE,
                            FileSystemOperationRunner::CopyProgressCallback(),
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, status());
+  EXPECT_EQ(base::File::FILE_ERROR_INVALID_OPERATION, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopyFailureSrcDirExistsDestFile) {
   // Src exists and is dir. Dest is a file.
   FileSystemURL src_dir(CreateDirectory("src"));
   FileSystemURL dest_dir(CreateDirectory("dest"));
   FileSystemURL dest_file(CreateFile("dest/file"));
 
   operation_runner()->Copy(src_dir, dest_file,
                            FileSystemOperation::OPTION_NONE,
                            FileSystemOperationRunner::CopyProgressCallback(),
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, status());
+  EXPECT_EQ(base::File::FILE_ERROR_INVALID_OPERATION, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest,
        TestCopyFailureSrcFileExistsDestNonEmptyDir) {
   // Src exists and is a directory. Dest is a non-empty directory.
   FileSystemURL src_dir(CreateDirectory("src"));
   FileSystemURL dest_dir(CreateDirectory("dest"));
   FileSystemURL dest_file(CreateFile("dest/file"));
 
   operation_runner()->Copy(src_dir, dest_dir,
                            FileSystemOperation::OPTION_NONE,
                            FileSystemOperationRunner::CopyProgressCallback(),
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_EMPTY, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_EMPTY, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopyFailureSrcFileExistsDestDir) {
   // Src exists and is a file. Dest is a directory.
   FileSystemURL src_file(CreateFile("src"));
   FileSystemURL dest_dir(CreateDirectory("dest"));
 
   operation_runner()->Copy(src_file, dest_dir,
                            FileSystemOperation::OPTION_NONE,
                            FileSystemOperationRunner::CopyProgressCallback(),
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, status());
+  EXPECT_EQ(base::File::FILE_ERROR_INVALID_OPERATION, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopyFailureDestParentDoesntExist) {
   // Dest. parent path does not exist.
   FileSystemURL src_dir(CreateDirectory("src"));
 
   operation_runner()->Copy(src_dir, URLForPath("nonexistent/dest"),
                            FileSystemOperation::OPTION_NONE,
                            FileSystemOperationRunner::CopyProgressCallback(),
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopyFailureByQuota) {
   FileSystemURL src_dir(CreateDirectory("src"));
   FileSystemURL src_file(CreateFile("src/file"));
   FileSystemURL dest_dir(CreateDirectory("dest"));
   operation_runner()->Truncate(src_file, 6, RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_EQ(6, GetFileSize("src/file"));
 
   FileSystemURL dest_file(URLForPath("dest/file"));
   int64 dest_path_cost = ComputePathCost(dest_file);
   GrantQuotaForCurrentUsage();
   AddQuota(6 + dest_path_cost - 1);
 
   operation_runner()->Copy(src_file, dest_file,
                            FileSystemOperation::OPTION_NONE,
                            FileSystemOperationRunner::CopyProgressCallback(),
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, status());
   EXPECT_FALSE(FileExists("dest/file"));
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopySuccessSrcFileAndOverwrite) {
   FileSystemURL src_file(CreateFile("src"));
   FileSystemURL dest_file(CreateFile("dest"));
 
   operation_runner()->Copy(src_file, dest_file,
                            FileSystemOperation::OPTION_NONE,
                            FileSystemOperationRunner::CopyProgressCallback(),
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(FileExists("dest"));
   EXPECT_EQ(2, quota_manager_proxy()->notify_storage_accessed_count());
 
   EXPECT_EQ(1, change_observer()->get_and_reset_modify_file_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopySuccessSrcFileAndNew) {
   FileSystemURL src_file(CreateFile("src"));
 
   operation_runner()->Copy(src_file, URLForPath("new"),
                            FileSystemOperation::OPTION_NONE,
                            FileSystemOperationRunner::CopyProgressCallback(),
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(FileExists("new"));
   EXPECT_EQ(2, quota_manager_proxy()->notify_storage_accessed_count());
 
   EXPECT_EQ(1, change_observer()->get_and_reset_create_file_from_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopySuccessSrcDirAndOverwrite) {
   FileSystemURL src_dir(CreateDirectory("src"));
   FileSystemURL dest_dir(CreateDirectory("dest"));
 
   operation_runner()->Copy(src_dir, dest_dir,
                            FileSystemOperation::OPTION_NONE,
                            FileSystemOperationRunner::CopyProgressCallback(),
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
 
   // Make sure we've overwritten but not copied the source under the |dest_dir|.
   EXPECT_TRUE(DirectoryExists("dest"));
   EXPECT_FALSE(DirectoryExists("dest/src"));
   EXPECT_GE(quota_manager_proxy()->notify_storage_accessed_count(), 3);
 
   EXPECT_EQ(1, change_observer()->get_and_reset_remove_directory_count());
   EXPECT_EQ(1, change_observer()->get_and_reset_create_directory_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopySuccessSrcDirAndNew) {
   FileSystemURL src_dir(CreateDirectory("src"));
   FileSystemURL dest_dir_new(URLForPath("dest"));
 
   operation_runner()->Copy(src_dir, dest_dir_new,
                            FileSystemOperation::OPTION_NONE,
                            FileSystemOperationRunner::CopyProgressCallback(),
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(DirectoryExists("dest"));
   EXPECT_GE(quota_manager_proxy()->notify_storage_accessed_count(), 2);
 
   EXPECT_EQ(1, change_observer()->get_and_reset_create_directory_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopySuccessSrcDirRecursive) {
   FileSystemURL src_dir(CreateDirectory("src"));
   CreateDirectory("src/dir");
   CreateFile("src/dir/sub");
 
   FileSystemURL dest_dir(CreateDirectory("dest"));
 
   operation_runner()->Copy(src_dir, dest_dir,
                            FileSystemOperation::OPTION_NONE,
                            FileSystemOperationRunner::CopyProgressCallback(),
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(DirectoryExists("dest/dir"));
   EXPECT_TRUE(FileExists("dest/dir/sub"));
 
   // For recursive copy we may record multiple read access.
   EXPECT_GE(quota_manager_proxy()->notify_storage_accessed_count(), 1);
 
   EXPECT_EQ(2, change_observer()->get_and_reset_create_directory_count());
   EXPECT_EQ(1, change_observer()->get_and_reset_remove_directory_count());
   EXPECT_EQ(1, change_observer()->get_and_reset_create_file_from_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopySuccessSamePath) {
   FileSystemURL src_dir(CreateDirectory("src"));
   CreateDirectory("src/dir");
   CreateFile("src/dir/sub");
 
   operation_runner()->Copy(src_dir, src_dir,
                            FileSystemOperation::OPTION_NONE,
                            FileSystemOperationRunner::CopyProgressCallback(),
                            RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(DirectoryExists("src/dir"));
   EXPECT_TRUE(FileExists("src/dir/sub"));
 
   EXPECT_EQ(0, change_observer()->get_and_reset_create_directory_count());
   EXPECT_EQ(0, change_observer()->get_and_reset_remove_file_count());
   EXPECT_EQ(0, change_observer()->get_and_reset_create_file_from_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopyInForeignFileSuccess) {
   base::FilePath src_local_disk_file_path;
   base::CreateTemporaryFile(&src_local_disk_file_path);
   const char test_data[] = "foo";
   int data_size = ARRAYSIZE_UNSAFE(test_data);
   file_util::WriteFile(src_local_disk_file_path, test_data, data_size);
 
   FileSystemURL dest_dir(CreateDirectory("dest"));
 
   int64 before_usage;
   GetUsageAndQuota(&before_usage, NULL);
 
   // Check that the file copied and corresponding usage increased.
   operation_runner()->CopyInForeignFile(src_local_disk_file_path,
                                         URLForPath("dest/file"),
                                         RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1, change_observer()->create_file_count());
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(FileExists("dest/file"));
   int64 after_usage;
   GetUsageAndQuota(&after_usage, NULL);
   EXPECT_GT(after_usage, before_usage);
 
   // Compare contents of src and copied file.
   char buffer[100];
   EXPECT_EQ(data_size, base::ReadFile(PlatformPath("dest/file"),
                                       buffer, data_size));
   for (int i = 0; i < data_size; ++i)
@@ skipping 10 matching lines @@
   FileSystemURL dest_dir(CreateDirectory("dest"));
 
   GrantQuotaForCurrentUsage();
   operation_runner()->CopyInForeignFile(src_local_disk_file_path,
                                         URLForPath("dest/file"),
                                         RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(FileExists("dest/file"));
   EXPECT_EQ(0, change_observer()->create_file_count());
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, status());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCreateFileFailure) {
   // Already existing file and exclusive true.
   FileSystemURL file(CreateFile("file"));
   operation_runner()->CreateFile(file, true, RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, status());
+  EXPECT_EQ(base::File::FILE_ERROR_EXISTS, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCreateFileSuccessFileExists) {
   // Already existing file and exclusive false.
   FileSystemURL file(CreateFile("file"));
   operation_runner()->CreateFile(file, false, RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(FileExists("file"));
 
   // The file was already there; did nothing.
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCreateFileSuccessExclusive) {
   // File doesn't exist but exclusive is true.
   operation_runner()->CreateFile(URLForPath("new"), true,
                                  RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(FileExists("new"));
   EXPECT_EQ(1, change_observer()->get_and_reset_create_file_count());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCreateFileSuccessFileDoesntExist) {
   // Non existing file.
   operation_runner()->CreateFile(URLForPath("nonexistent"), false,
                                  RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_EQ(1, change_observer()->get_and_reset_create_file_count());
 }
 
 TEST_F(FileSystemOperationImplTest,
        TestCreateDirFailureDestParentDoesntExist) {
   // Dest. parent path does not exist.
   operation_runner()->CreateDirectory(
       URLForPath("nonexistent/dir"), false, false,
       RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCreateDirFailureDirExists) {
   // Exclusive and dir existing at path.
   FileSystemURL dir(CreateDirectory("dir"));
   operation_runner()->CreateDirectory(dir, true, false,
                                       RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, status());
+  EXPECT_EQ(base::File::FILE_ERROR_EXISTS, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCreateDirFailureFileExists) {
   // Exclusive true and file existing at path.
   FileSystemURL file(CreateFile("file"));
   operation_runner()->CreateDirectory(file, true, false,
                                       RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, status());
+  EXPECT_EQ(base::File::FILE_ERROR_EXISTS, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCreateDirSuccess) {
   // Dir exists and exclusive is false.
   FileSystemURL dir(CreateDirectory("dir"));
   operation_runner()->CreateDirectory(dir, false, false,
                                       RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 
   // Dir doesn't exist.
   operation_runner()->CreateDirectory(URLForPath("new"), false, false,
                                       RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(DirectoryExists("new"));
   EXPECT_EQ(1, change_observer()->get_and_reset_create_directory_count());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCreateDirSuccessExclusive) {
   // Dir doesn't exist.
   operation_runner()->CreateDirectory(URLForPath("new"), true, false,
                                       RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(DirectoryExists("new"));
   EXPECT_EQ(1, change_observer()->get_and_reset_create_directory_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestExistsAndMetadataFailure) {
   operation_runner()->GetMetadata(URLForPath("nonexistent"),
                                   RecordMetadataCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, status());
 
   operation_runner()->FileExists(URLForPath("nonexistent"),
                                  RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, status());
 
   operation_runner()->DirectoryExists(URLForPath("nonexistent"),
                                       RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestExistsAndMetadataSuccess) {
   FileSystemURL dir(CreateDirectory("dir"));
   FileSystemURL file(CreateFile("dir/file"));
   int read_access = 0;
 
   operation_runner()->DirectoryExists(dir, RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   ++read_access;
 
   operation_runner()->GetMetadata(dir, RecordMetadataCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(info().is_directory);
   ++read_access;
 
   operation_runner()->FileExists(file, RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   ++read_access;
 
   operation_runner()->GetMetadata(file, RecordMetadataCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_FALSE(info().is_directory);
   ++read_access;
 
   EXPECT_EQ(read_access,
             quota_manager_proxy()->notify_storage_accessed_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestTypeMismatchErrors) {
   FileSystemURL dir(CreateDirectory("dir"));
   operation_runner()->FileExists(dir, RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_FILE, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_A_FILE, status());
 
   FileSystemURL file(CreateFile("file"));
   operation_runner()->DirectoryExists(file, RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_A_DIRECTORY, status());
 }
 
 TEST_F(FileSystemOperationImplTest, TestReadDirFailure) {
   // Path doesn't exist
   operation_runner()->ReadDirectory(URLForPath("nonexistent"),
                                     RecordReadDirectoryCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, status());
 
   // File exists.
   FileSystemURL file(CreateFile("file"));
   operation_runner()->ReadDirectory(file, RecordReadDirectoryCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_A_DIRECTORY, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestReadDirSuccess) {
   //      parent_dir
   //       |       |
   //  child_dir  child_file
   // Verify reading parent_dir.
   FileSystemURL parent_dir(CreateDirectory("dir"));
   FileSystemURL child_dir(CreateDirectory("dir/child_dir"));
   FileSystemURL child_file(CreateFile("dir/child_file"));
 
   operation_runner()->ReadDirectory(parent_dir, RecordReadDirectoryCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_EQ(2u, entries().size());
 
   for (size_t i = 0; i < entries().size(); ++i) {
     if (entries()[i].is_directory)
       EXPECT_EQ(FILE_PATH_LITERAL("child_dir"), entries()[i].name);
     else
       EXPECT_EQ(FILE_PATH_LITERAL("child_file"), entries()[i].name);
   }
   EXPECT_EQ(1, quota_manager_proxy()->notify_storage_accessed_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestRemoveFailure) {
   // Path doesn't exist.
   operation_runner()->Remove(URLForPath("nonexistent"), false /* recursive */,
                              RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, status());
 
   // It's an error to try to remove a non-empty directory if recursive flag
   // is false.
   //      parent_dir
   //       |       |
   //  child_dir  child_file
   // Verify deleting parent_dir.
   FileSystemURL parent_dir(CreateDirectory("dir"));
   FileSystemURL child_dir(CreateDirectory("dir/child_dir"));
   FileSystemURL child_file(CreateFile("dir/child_file"));
 
   operation_runner()->Remove(parent_dir, false /* recursive */,
                              RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_EMPTY, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_EMPTY, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestRemoveSuccess) {
   FileSystemURL empty_dir(CreateDirectory("empty_dir"));
   EXPECT_TRUE(DirectoryExists("empty_dir"));
   operation_runner()->Remove(empty_dir, false /* recursive */,
                              RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_FALSE(DirectoryExists("empty_dir"));
 
   EXPECT_EQ(1, change_observer()->get_and_reset_remove_directory_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestRemoveSuccessRecursive) {
   // Removing a non-empty directory with recursive flag == true should be ok.
   //      parent_dir
   //       |       |
   //  child_dir  child_files
   //       |
   //  child_files
   //
   // Verify deleting parent_dir.
   FileSystemURL parent_dir(CreateDirectory("dir"));
   for (int i = 0; i < 8; ++i)
     CreateFile(base::StringPrintf("dir/file-%d", i));
   FileSystemURL child_dir(CreateDirectory("dir/child_dir"));
   for (int i = 0; i < 8; ++i)
     CreateFile(base::StringPrintf("dir/child_dir/file-%d", i));
 
   operation_runner()->Remove(parent_dir, true /* recursive */,
                              RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_FALSE(DirectoryExists("parent_dir"));
 
   EXPECT_EQ(2, change_observer()->get_and_reset_remove_directory_count());
   EXPECT_EQ(16, change_observer()->get_and_reset_remove_file_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(FileSystemOperationImplTest, TestTruncate) {
   FileSystemURL file(CreateFile("file"));
   base::FilePath platform_path = PlatformPath("file");
 
   char test_data[] = "test data";
   int data_size = static_cast<int>(sizeof(test_data));
   EXPECT_EQ(data_size,
             file_util::WriteFile(platform_path, test_data, data_size));
 
   // Check that its length is the size of the data written.
   operation_runner()->GetMetadata(file, RecordMetadataCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_FALSE(info().is_directory);
   EXPECT_EQ(data_size, info().size);
 
   // Extend the file by truncating it.
   int length = 17;
   operation_runner()->Truncate(file, length, RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
 
   EXPECT_EQ(1, change_observer()->get_and_reset_modify_file_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 
   // Check that its length is now 17 and that it's all zeroes after the test
   // data.
   EXPECT_EQ(length, GetFileSize("file"));
   char data[100];
   EXPECT_EQ(length, base::ReadFile(platform_path, data, length));
   for (int i = 0; i < length; ++i) {
     if (i < static_cast<int>(sizeof(test_data)))
       EXPECT_EQ(test_data[i], data[i]);
     else
       EXPECT_EQ(0, data[i]);
   }
 
   // Shorten the file by truncating it.
   length = 3;
   operation_runner()->Truncate(file, length, RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
 
   EXPECT_EQ(1, change_observer()->get_and_reset_modify_file_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 
   // Check that its length is now 3 and that it contains only bits of test data.
   EXPECT_EQ(length, GetFileSize("file"));
   EXPECT_EQ(length, base::ReadFile(platform_path, data, length));
   for (int i = 0; i < length; ++i)
     EXPECT_EQ(test_data[i], data[i]);
 
   // Truncate is not a 'read' access.  (Here expected access count is 1
   // since we made 1 read access for GetMetadata.)
   EXPECT_EQ(1, quota_manager_proxy()->notify_storage_accessed_count());
 }
 
 TEST_F(FileSystemOperationImplTest, TestTruncateFailureByQuota) {
   FileSystemURL dir(CreateDirectory("dir"));
   FileSystemURL file(CreateFile("dir/file"));
 
   GrantQuotaForCurrentUsage();
   AddQuota(10);
 
   operation_runner()->Truncate(file, 10, RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_EQ(1, change_observer()->get_and_reset_modify_file_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 
   EXPECT_EQ(10, GetFileSize("dir/file"));
 
   operation_runner()->Truncate(file, 11, RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, status());
+  EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 
   EXPECT_EQ(10, GetFileSize("dir/file"));
 }
 
 TEST_F(FileSystemOperationImplTest, TestTouchFile) {
   FileSystemURL file(CreateFile("file"));
   base::FilePath platform_path = PlatformPath("file");
 
   base::File::Info info;
   EXPECT_TRUE(base::GetFileInfo(platform_path, &info));
   EXPECT_FALSE(info.is_directory);
   EXPECT_EQ(0, info.size);
   const base::Time last_modified = info.last_modified;
   const base::Time last_accessed = info.last_accessed;
 
   const base::Time new_modified_time = base::Time::UnixEpoch();
   const base::Time new_accessed_time = new_modified_time +
       base::TimeDelta::FromHours(77);
   ASSERT_NE(last_modified, new_modified_time);
   ASSERT_NE(last_accessed, new_accessed_time);
 
   operation_runner()->TouchFile(file, new_accessed_time, new_modified_time,
                                 RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_TRUE(change_observer()->HasNoChange());
 
   EXPECT_TRUE(base::GetFileInfo(platform_path, &info));
   // We compare as time_t here to lower our resolution, to avoid false
   // negatives caused by conversion to the local filesystem's native
   // representation and back.
   EXPECT_EQ(new_modified_time.ToTimeT(), info.last_modified.ToTimeT());
   EXPECT_EQ(new_accessed_time.ToTimeT(), info.last_accessed.ToTimeT());
 }
 
 TEST_F(FileSystemOperationImplTest, TestCreateSnapshotFile) {
   FileSystemURL dir(CreateDirectory("dir"));
 
   // Create a file for the testing.
   operation_runner()->DirectoryExists(dir, RecordStatusCallback());
   FileSystemURL file(CreateFile("dir/file"));
   operation_runner()->FileExists(file, RecordStatusCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
 
   // See if we can get a 'snapshot' file info for the file.
   // Since FileSystemOperationImpl assumes the file exists in the local
   // directory it should just returns the same metadata and platform_path
   // as the file itself.
   operation_runner()->CreateSnapshotFile(file, RecordSnapshotFileCallback());
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(base::PLATFORM_FILE_OK, status());
+  EXPECT_EQ(base::File::FILE_OK, status());
   EXPECT_FALSE(info().is_directory);
   EXPECT_EQ(PlatformPath("dir/file"), path());
   EXPECT_TRUE(change_observer()->HasNoChange());
 
   // The FileSystemOpration implementation does not create a
   // shareable file reference.
   EXPECT_EQ(NULL, shareable_file_ref());
 }
 
 TEST_F(FileSystemOperationImplTest,
        TestMoveSuccessSrcDirRecursiveWithQuota) {
   FileSystemURL src(CreateDirectory("src"));
   int src_path_cost = GetUsage();
 
   FileSystemURL dest(CreateDirectory("dest"));
   FileSystemURL child_file1(CreateFile("src/file1"));
   FileSystemURL child_file2(CreateFile("src/file2"));
   FileSystemURL child_dir(CreateDirectory("src/dir"));
   FileSystemURL grandchild_file1(CreateFile("src/dir/file1"));
   FileSystemURL grandchild_file2(CreateFile("src/dir/file2"));
 
   int total_path_cost = GetUsage();
   EXPECT_EQ(0, GetDataSizeOnDisk());
 
   operation_runner()->Truncate(
       child_file1, 5000,
-      base::Bind(&AssertFileErrorEq, FROM_HERE, base::PLATFORM_FILE_OK));
+      base::Bind(&AssertFileErrorEq, FROM_HERE, base::File::FILE_OK));
   operation_runner()->Truncate(
       child_file2, 400,
-      base::Bind(&AssertFileErrorEq, FROM_HERE, base::PLATFORM_FILE_OK));
+      base::Bind(&AssertFileErrorEq, FROM_HERE, base::File::FILE_OK));
   operation_runner()->Truncate(
       grandchild_file1, 30,
-      base::Bind(&AssertFileErrorEq, FROM_HERE, base::PLATFORM_FILE_OK));
+      base::Bind(&AssertFileErrorEq, FROM_HERE, base::File::FILE_OK));
   operation_runner()->Truncate(
       grandchild_file2, 2,
-      base::Bind(&AssertFileErrorEq, FROM_HERE, base::PLATFORM_FILE_OK));
+      base::Bind(&AssertFileErrorEq, FROM_HERE, base::File::FILE_OK));
   base::RunLoop().RunUntilIdle();
 
   const int64 all_file_size = 5000 + 400 + 30 + 2;
   EXPECT_EQ(all_file_size, GetDataSizeOnDisk());
   EXPECT_EQ(all_file_size + total_path_cost, GetUsage());
 
   operation_runner()->Move(
       src, dest, FileSystemOperation::OPTION_NONE,
-      base::Bind(&AssertFileErrorEq, FROM_HERE, base::PLATFORM_FILE_OK));
+      base::Bind(&AssertFileErrorEq, FROM_HERE, base::File::FILE_OK));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(DirectoryExists("src/dir"));
   EXPECT_FALSE(FileExists("src/dir/file2"));
   EXPECT_TRUE(DirectoryExists("dest/dir"));
   EXPECT_TRUE(FileExists("dest/dir/file2"));
 
   EXPECT_EQ(all_file_size, GetDataSizeOnDisk());
   EXPECT_EQ(all_file_size + total_path_cost - src_path_cost,
             GetUsage());
@@ skipping 14 matching lines @@
 
   FileSystemURL grandchild_file1(CreateFile("src/dir/file1"));
   FileSystemURL grandchild_file2(CreateFile("src/dir/file2"));
   int64 total_path_cost = GetUsage();
   int64 grandchild_path_cost = total_path_cost - usage;
 
   EXPECT_EQ(0, GetDataSizeOnDisk());
 
   operation_runner()->Truncate(
       child_file1, 8000,
-      base::Bind(&AssertFileErrorEq, FROM_HERE, base::PLATFORM_FILE_OK));
+      base::Bind(&AssertFileErrorEq, FROM_HERE, base::File::FILE_OK));
   operation_runner()->Truncate(
       child_file2, 700,
-      base::Bind(&AssertFileErrorEq, FROM_HERE, base::PLATFORM_FILE_OK));
+      base::Bind(&AssertFileErrorEq, FROM_HERE, base::File::FILE_OK));
   operation_runner()->Truncate(
       grandchild_file1, 60,
-      base::Bind(&AssertFileErrorEq, FROM_HERE, base::PLATFORM_FILE_OK));
+      base::Bind(&AssertFileErrorEq, FROM_HERE, base::File::FILE_OK));
   operation_runner()->Truncate(
       grandchild_file2, 5,
-      base::Bind(&AssertFileErrorEq, FROM_HERE, base::PLATFORM_FILE_OK));
+      base::Bind(&AssertFileErrorEq, FROM_HERE, base::File::FILE_OK));
   base::RunLoop().RunUntilIdle();
 
   const int64 child_file_size = 8000 + 700;
   const int64 grandchild_file_size = 60 + 5;
   const int64 all_file_size = child_file_size + grandchild_file_size;
   int64 expected_usage = all_file_size + total_path_cost;
 
   usage = GetUsage();
   EXPECT_EQ(all_file_size, GetDataSizeOnDisk());
   EXPECT_EQ(expected_usage, usage);
 
   // Copy src to dest1.
   operation_runner()->Copy(
       src, dest1, FileSystemOperation::OPTION_NONE,
       FileSystemOperationRunner::CopyProgressCallback(),
-      base::Bind(&AssertFileErrorEq, FROM_HERE, base::PLATFORM_FILE_OK));
+      base::Bind(&AssertFileErrorEq, FROM_HERE, base::File::FILE_OK));
   base::RunLoop().RunUntilIdle();
 
   expected_usage += all_file_size + child_path_cost + grandchild_path_cost;
   EXPECT_TRUE(DirectoryExists("src/dir"));
   EXPECT_TRUE(FileExists("src/dir/file2"));
   EXPECT_TRUE(DirectoryExists("dest1/dir"));
   EXPECT_TRUE(FileExists("dest1/dir/file2"));
 
   EXPECT_EQ(2 * all_file_size, GetDataSizeOnDisk());
   EXPECT_EQ(expected_usage, GetUsage());
 
   // Copy src/dir to dest2.
   operation_runner()->Copy(
       child_dir, dest2, FileSystemOperation::OPTION_NONE,
       FileSystemOperationRunner::CopyProgressCallback(),
-      base::Bind(&AssertFileErrorEq, FROM_HERE, base::PLATFORM_FILE_OK));
+      base::Bind(&AssertFileErrorEq, FROM_HERE, base::File::FILE_OK));
   base::RunLoop().RunUntilIdle();
 
   expected_usage += grandchild_file_size + grandchild_path_cost;
   usage = GetUsage();
   EXPECT_EQ(2 * child_file_size + 3 * grandchild_file_size,
             GetDataSizeOnDisk());
   EXPECT_EQ(expected_usage, usage);
 }
 
 }  // namespace content