Convert Media Galleries to use base::File

chrome/browser/sync_file_system/local/local_file_sync_context_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 "chrome/browser/sync_file_system/local/local_file_sync_context.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 37 matching lines @@
 const char kOrigin2[] = "http://chromium.org";
 }
 
 class LocalFileSyncContextTest : public testing::Test {
  protected:
   LocalFileSyncContextTest()
       : thread_bundle_(
             content::TestBrowserThreadBundle::REAL_FILE_THREAD |
             content::TestBrowserThreadBundle::REAL_IO_THREAD),
         status_(SYNC_FILE_ERROR_FAILED),
-        file_error_(base::PLATFORM_FILE_ERROR_FAILED),
+        file_error_(base::File::FILE_ERROR_FAILED),
         async_modify_finished_(false),
         has_inflight_prepare_for_sync_(false) {}
 
   virtual void SetUp() OVERRIDE {
     RegisterSyncableFileSystem();
     ASSERT_TRUE(dir_.CreateUniqueTempDir());
 
     ui_task_runner_ = base::MessageLoop::current()->message_loop_proxy();
     io_task_runner_ = BrowserThread::GetMessageLoopProxyForThread(
         BrowserThread::IO);
@@ skipping 107 matching lines @@
     if (!io_task_runner_->RunsTasksOnCurrentThread()) {
       async_modify_finished_ = false;
       ASSERT_TRUE(ui_task_runner_->RunsTasksOnCurrentThread());
       io_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&LocalFileSyncContextTest::StartModifyFileOnIOThread,
                      base::Unretained(this), file_system, url));
       return;
     }
     ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
-    file_error_ = base::PLATFORM_FILE_ERROR_FAILED;
+    file_error_ = base::File::FILE_ERROR_FAILED;
     file_system->operation_runner()->Truncate(
         url, 1, base::Bind(&LocalFileSyncContextTest::DidModifyFile,
                            base::Unretained(this)));
   }
 
-  base::PlatformFileError WaitUntilModifyFileIsDone() {
+  base::File::Error WaitUntilModifyFileIsDone() {
     while (!async_modify_finished_)
       base::MessageLoop::current()->RunUntilIdle();
     return file_error_;
   }
 
-  void DidModifyFile(base::PlatformFileError error) {
+  void DidModifyFile(base::File::Error error) {
     if (!ui_task_runner_->RunsTasksOnCurrentThread()) {
       ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
       ui_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&LocalFileSyncContextTest::DidModifyFile,
                      base::Unretained(this), error));
       return;
     }
     ASSERT_TRUE(ui_task_runner_->RunsTasksOnCurrentThread());
     file_error_ = error;
@@ skipping 20 matching lines @@
                             SyncStatusCode simulate_sync_finish_status) {
     CannedSyncableFileSystem file_system(GURL(kOrigin1),
                                          io_task_runner_.get(),
                                          file_task_runner_.get());
     file_system.SetUp();
     sync_context_ = new LocalFileSyncContext(
         dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
     ASSERT_EQ(SYNC_STATUS_OK,
               file_system.MaybeInitializeFileSystemContext(
                   sync_context_.get()));
-    ASSERT_EQ(base::PLATFORM_FILE_OK, file_system.OpenFileSystem());
+    ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
     const FileSystemURL kFile(file_system.URL("file"));
-    EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.CreateFile(kFile));
+    EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kFile));
 
     SyncFileMetadata metadata;
     FileChangeList changes;
     EXPECT_EQ(SYNC_STATUS_OK,
               PrepareForSync(file_system.file_system_context(), kFile,
                              sync_mode, &metadata, &changes, NULL));
     EXPECT_EQ(1U, changes.size());
     EXPECT_TRUE(changes.list().back().IsFile());
     EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
 
@@ skipping 26 matching lines @@
       LocalFileSyncContext::SyncMode sync_mode) {
     CannedSyncableFileSystem file_system(GURL(kOrigin1),
                                          io_task_runner_.get(),
                                          file_task_runner_.get());
     file_system.SetUp();
     sync_context_ = new LocalFileSyncContext(
         dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
     ASSERT_EQ(SYNC_STATUS_OK,
               file_system.MaybeInitializeFileSystemContext(
                   sync_context_.get()));
-    ASSERT_EQ(base::PLATFORM_FILE_OK, file_system.OpenFileSystem());
+    ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
     const FileSystemURL kFile(file_system.URL("file"));
-    EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.CreateFile(kFile));
+    EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kFile));
 
     SyncFileMetadata metadata;
     FileChangeList changes;
     webkit_blob::ScopedFile snapshot;
     EXPECT_EQ(SYNC_STATUS_OK,
               PrepareForSync(file_system.file_system_context(), kFile,
                              sync_mode, &metadata, &changes, &snapshot));
     EXPECT_EQ(1U, changes.size());
     EXPECT_TRUE(changes.list().back().IsFile());
     EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
 
     EXPECT_EQ(sync_mode == LocalFileSyncContext::SYNC_SNAPSHOT,
               !snapshot.path().empty());
 
     // Tracker keeps same set of changes.
     file_system.GetChangesForURLInTracker(kFile, &changes);
     EXPECT_EQ(1U, changes.size());
     EXPECT_TRUE(changes.list().back().IsFile());
     EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
 
     StartModifyFileOnIOThread(&file_system, kFile);
 
     if (sync_mode == LocalFileSyncContext::SYNC_SNAPSHOT) {
       // Write should succeed.
-      EXPECT_EQ(base::PLATFORM_FILE_OK, WaitUntilModifyFileIsDone());
+      EXPECT_EQ(base::File::FILE_OK, WaitUntilModifyFileIsDone());
     } else {
       base::MessageLoop::current()->RunUntilIdle();
       EXPECT_FALSE(async_modify_finished_);
     }
 
     SimulateFinishSync(file_system.file_system_context(), kFile,
                        SYNC_STATUS_OK, sync_mode);
 
-    EXPECT_EQ(base::PLATFORM_FILE_OK, WaitUntilModifyFileIsDone());
+    EXPECT_EQ(base::File::FILE_OK, WaitUntilModifyFileIsDone());
 
     // Sync succeeded, but the other change that was made during or
     // after sync is recorded.
     file_system.GetChangesForURLInTracker(kFile, &changes);
     EXPECT_EQ(1U, changes.size());
     EXPECT_TRUE(changes.list().back().IsFile());
     EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
 
     sync_context_->ShutdownOnUIThread();
     sync_context_ = NULL;
 
     file_system.TearDown();
   }
 
   ScopedEnableSyncFSDirectoryOperation enable_directory_operation_;
 
   base::ScopedTempDir dir_;
 
   // These need to remain until the very end.
   content::TestBrowserThreadBundle thread_bundle_;
 
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
 
   scoped_refptr<LocalFileSyncContext> sync_context_;
 
   SyncStatusCode status_;
-  base::PlatformFileError file_error_;
+  base::File::Error file_error_;
   bool async_modify_finished_;
   bool has_inflight_prepare_for_sync_;
 };
 
 TEST_F(LocalFileSyncContextTest, ConstructAndDestruct) {
   sync_context_ =
       new LocalFileSyncContext(
           dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
   sync_context_->ShutdownOnUIThread();
 }
@@ skipping 17 matching lines @@
   EXPECT_TRUE(file_system.backend()->change_tracker() != NULL);
   EXPECT_EQ(sync_context_.get(), file_system.backend()->sync_context());
 
   // Calling MaybeInitialize for the same context multiple times must be ok.
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
   EXPECT_EQ(sync_context_.get(), file_system.backend()->sync_context());
 
   // Opens the file_system, perform some operation and see if the change tracker
   // correctly captures the change.
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.OpenFileSystem());
+  EXPECT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
   const FileSystemURL kURL(file_system.URL("foo"));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.CreateFile(kURL));
+  EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kURL));
 
   FileSystemURLSet urls;
   file_system.GetChangedURLsInTracker(&urls);
   ASSERT_EQ(1U, urls.size());
   EXPECT_TRUE(ContainsKey(urls, kURL));
 
   // Finishing the test.
   sync_context_->ShutdownOnUIThread();
   file_system.TearDown();
 }
@@ skipping 10 matching lines @@
 
   sync_context_ = new LocalFileSyncContext(
       dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
 
   // Initializes file_system1 and file_system2.
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system1.MaybeInitializeFileSystemContext(sync_context_.get()));
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system2.MaybeInitializeFileSystemContext(sync_context_.get()));
 
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system1.OpenFileSystem());
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system2.OpenFileSystem());
+  EXPECT_EQ(base::File::FILE_OK, file_system1.OpenFileSystem());
+  EXPECT_EQ(base::File::FILE_OK, file_system2.OpenFileSystem());
 
   const FileSystemURL kURL1(file_system1.URL("foo"));
   const FileSystemURL kURL2(file_system2.URL("bar"));
 
   // Creates a file in file_system1.
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system1.CreateFile(kURL1));
+  EXPECT_EQ(base::File::FILE_OK, file_system1.CreateFile(kURL1));
 
   // file_system1's tracker must have recorded the change.
   FileSystemURLSet urls;
   file_system1.GetChangedURLsInTracker(&urls);
   ASSERT_EQ(1U, urls.size());
   EXPECT_TRUE(ContainsKey(urls, kURL1));
 
   // file_system1's tracker must have no change.
   urls.clear();
   file_system2.GetChangedURLsInTracker(&urls);
   ASSERT_TRUE(urls.empty());
 
   // Creates a directory in file_system2.
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system2.CreateDirectory(kURL2));
+  EXPECT_EQ(base::File::FILE_OK, file_system2.CreateDirectory(kURL2));
 
   // file_system1's tracker must have the change for kURL1 as before.
   urls.clear();
   file_system1.GetChangedURLsInTracker(&urls);
   ASSERT_EQ(1U, urls.size());
   EXPECT_TRUE(ContainsKey(urls, kURL1));
 
   // file_system2's tracker now must have the change for kURL2.
   urls.clear();
   file_system2.GetChangedURLsInTracker(&urls);
@@ skipping 65 matching lines @@
 TEST_F(LocalFileSyncContextTest, DISABLED_PrepareSyncWhileWriting) {
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
                                        io_task_runner_.get(),
                                        file_task_runner_.get());
   file_system.SetUp();
   sync_context_ = new LocalFileSyncContext(
       dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
 
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.OpenFileSystem());
+  EXPECT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
   const FileSystemURL kURL1(file_system.URL("foo"));
 
   // Creates a file in file_system.
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.CreateFile(kURL1));
+  EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kURL1));
 
   // Kick file write on IO thread.
   StartModifyFileOnIOThread(&file_system, kURL1);
 
   // Until the operation finishes PrepareForSync should return BUSY error.
   SyncFileMetadata metadata;
   metadata.file_type = SYNC_FILE_TYPE_UNKNOWN;
   FileChangeList changes;
   EXPECT_EQ(SYNC_STATUS_FILE_BUSY,
             PrepareForSync(file_system.file_system_context(), kURL1,
                            LocalFileSyncContext::SYNC_EXCLUSIVE,
                            &metadata, &changes, NULL));
   EXPECT_EQ(SYNC_FILE_TYPE_FILE, metadata.file_type);
 
   // Register PrepareForSync method to be invoked when kURL1 becomes
   // syncable. (Actually this may be done after all operations are done
   // on IO thread in this test.)
   metadata.file_type = SYNC_FILE_TYPE_UNKNOWN;
   changes.clear();
   sync_context_->RegisterURLForWaitingSync(
       kURL1, GetPrepareForSyncClosure(file_system.file_system_context(), kURL1,
                                       LocalFileSyncContext::SYNC_EXCLUSIVE,
                                       &metadata, &changes, NULL));
 
   // Wait for the completion.
-  EXPECT_EQ(base::PLATFORM_FILE_OK, WaitUntilModifyFileIsDone());
+  EXPECT_EQ(base::File::FILE_OK, WaitUntilModifyFileIsDone());
 
   // The PrepareForSync must have been started; wait until DidPrepareForSync
   // is done.
   base::MessageLoop::current()->Run();
   ASSERT_FALSE(has_inflight_prepare_for_sync_);
 
   // Now PrepareForSync should have run and returned OK.
   EXPECT_EQ(SYNC_STATUS_OK, status_);
   EXPECT_EQ(1U, changes.size());
   EXPECT_TRUE(changes.list().back().IsFile());
   EXPECT_TRUE(changes.list().back().IsAddOrUpdate());
   EXPECT_EQ(SYNC_FILE_TYPE_FILE, metadata.file_type);
   EXPECT_EQ(1, metadata.size);
 
   sync_context_->ShutdownOnUIThread();
   sync_context_ = NULL;
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForDeletion) {
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
                                        io_task_runner_.get(),
                                        file_task_runner_.get());
   file_system.SetUp();
 
   sync_context_ = new LocalFileSyncContext(
       dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
   ASSERT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
-  ASSERT_EQ(base::PLATFORM_FILE_OK, file_system.OpenFileSystem());
+  ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
   // Record the initial usage (likely 0).
   int64 initial_usage = -1;
   int64 quota = -1;
   EXPECT_EQ(quota::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&initial_usage, &quota));
 
   // Create a file and directory in the file_system.
   const FileSystemURL kFile(file_system.URL("file"));
   const FileSystemURL kDir(file_system.URL("dir"));
   const FileSystemURL kChild(file_system.URL("dir/child"));
 
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.CreateFile(kFile));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.CreateDirectory(kDir));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.CreateFile(kChild));
+  EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kFile));
+  EXPECT_EQ(base::File::FILE_OK, file_system.CreateDirectory(kDir));
+  EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kChild));
 
   // file_system's change tracker must have recorded the creation.
   FileSystemURLSet urls;
   file_system.GetChangedURLsInTracker(&urls);
   ASSERT_EQ(3U, urls.size());
   ASSERT_TRUE(ContainsKey(urls, kFile));
   ASSERT_TRUE(ContainsKey(urls, kDir));
   ASSERT_TRUE(ContainsKey(urls, kChild));
   for (FileSystemURLSet::iterator iter = urls.begin();
        iter != urls.end(); ++iter) {
@@ skipping 17 matching lines @@
   // The implementation doesn't check file type for deletion, and it must be ok
   // even if we don't know if the deletion change was for a file or a directory.
   change = FileChange(FileChange::FILE_CHANGE_DELETE,
                       SYNC_FILE_TYPE_UNKNOWN);
   EXPECT_EQ(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change, base::FilePath(), kDir,
                               SYNC_FILE_TYPE_DIRECTORY));
 
   // Check the directory/files are deleted successfully.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             file_system.FileExists(kFile));
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             file_system.DirectoryExists(kDir));
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             file_system.FileExists(kChild));
 
   // The changes applied by ApplyRemoteChange should not be recorded in
   // the change tracker.
   urls.clear();
   file_system.GetChangedURLsInTracker(&urls);
   EXPECT_TRUE(urls.empty());
 
   // The quota usage data must have reflected the deletion.
   EXPECT_EQ(quota::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&new_usage, &quota));
   EXPECT_EQ(new_usage, initial_usage);
 
   sync_context_->ShutdownOnUIThread();
   sync_context_ = NULL;
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForDeletion_ForRoot) {
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
                                        io_task_runner_.get(),
                                        file_task_runner_.get());
   file_system.SetUp();
 
   sync_context_ = new LocalFileSyncContext(
       dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
   ASSERT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
-  ASSERT_EQ(base::PLATFORM_FILE_OK, file_system.OpenFileSystem());
+  ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
   // Record the initial usage (likely 0).
   int64 initial_usage = -1;
   int64 quota = -1;
   EXPECT_EQ(quota::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&initial_usage, &quota));
 
   // Create a file and directory in the file_system.
   const FileSystemURL kFile(file_system.URL("file"));
   const FileSystemURL kDir(file_system.URL("dir"));
   const FileSystemURL kChild(file_system.URL("dir/child"));
 
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.CreateFile(kFile));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.CreateDirectory(kDir));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.CreateFile(kChild));
+  EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kFile));
+  EXPECT_EQ(base::File::FILE_OK, file_system.CreateDirectory(kDir));
+  EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kChild));
 
   // At this point the usage must be greater than the initial usage.
   int64 new_usage = -1;
   EXPECT_EQ(quota::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&new_usage, &quota));
   EXPECT_GT(new_usage, initial_usage);
 
   const FileSystemURL kRoot(file_system.URL(""));
 
   // Now let's apply remote deletion changes for the root.
   FileChange change(FileChange::FILE_CHANGE_DELETE, SYNC_FILE_TYPE_DIRECTORY);
   EXPECT_EQ(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change, base::FilePath(), kRoot,
                               SYNC_FILE_TYPE_DIRECTORY));
 
   // Check the directory/files are deleted successfully.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             file_system.FileExists(kFile));
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             file_system.DirectoryExists(kDir));
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             file_system.FileExists(kChild));
 
   // All changes made for the previous creation must have been also reset.
   FileSystemURLSet urls;
   file_system.GetChangedURLsInTracker(&urls);
   EXPECT_TRUE(urls.empty());
 
   // The quota usage data must have reflected the deletion.
   EXPECT_EQ(quota::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&new_usage, &quota));
@@ skipping 10 matching lines @@
 
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
                                        io_task_runner_.get(),
                                        file_task_runner_.get());
   file_system.SetUp();
 
   sync_context_ = new LocalFileSyncContext(
       dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
   ASSERT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
-  ASSERT_EQ(base::PLATFORM_FILE_OK, file_system.OpenFileSystem());
+  ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
   const FileSystemURL kFile1(file_system.URL("file1"));
   const FileSystemURL kFile2(file_system.URL("file2"));
   const FileSystemURL kDir(file_system.URL("dir"));
 
   const char kTestFileData0[] = "0123456789";
   const char kTestFileData1[] = "Lorem ipsum!";
   const char kTestFileData2[] = "This is sample test data.";
 
   // Create kFile1 and populate it with kTestFileData0.
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.CreateFile(kFile1));
+  EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kFile1));
   EXPECT_EQ(static_cast<int64>(arraysize(kTestFileData0) - 1),
             file_system.WriteString(kFile1, kTestFileData0));
 
   // kFile2 and kDir are not there yet.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             file_system.FileExists(kFile2));
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             file_system.DirectoryExists(kDir));
 
   // file_system's change tracker must have recorded the creation.
   FileSystemURLSet urls;
   file_system.GetChangedURLsInTracker(&urls);
   ASSERT_EQ(1U, urls.size());
   EXPECT_TRUE(ContainsKey(urls, kFile1));
   file_system.ClearChangeForURLInTracker(*urls.begin());
 
   // Prepare temporary files which represent the remote file data.
@@ skipping 63 matching lines @@
   // Calling ApplyRemoteChange with different file type should be handled as
   // overwrite.
   change =
       FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE, SYNC_FILE_TYPE_FILE);
   EXPECT_EQ(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change,
                               kFilePath1,
                               kDir,
                               SYNC_FILE_TYPE_DIRECTORY));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.FileExists(kDir));
+  EXPECT_EQ(base::File::FILE_OK, file_system.FileExists(kDir));
 
   change = FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                       SYNC_FILE_TYPE_DIRECTORY);
   EXPECT_EQ(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change,
                               kFilePath1,
                               kDir,
                               SYNC_FILE_TYPE_FILE));
 
   // Creating a file/directory must have increased the usage more than
   // the size of kTestFileData2.
   new_usage = usage;
   EXPECT_EQ(quota::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&new_usage, &quota));
   EXPECT_GT(new_usage,
             static_cast<int64>(usage + arraysize(kTestFileData2) - 1));
 
   // The changes applied by ApplyRemoteChange should not be recorded in
   // the change tracker.
   urls.clear();
   file_system.GetChangedURLsInTracker(&urls);
   EXPECT_TRUE(urls.empty());
 
   // Make sure all three files/directory exist.
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.FileExists(kFile1));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.FileExists(kFile2));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.DirectoryExists(kDir));
+  EXPECT_EQ(base::File::FILE_OK, file_system.FileExists(kFile1));
+  EXPECT_EQ(base::File::FILE_OK, file_system.FileExists(kFile2));
+  EXPECT_EQ(base::File::FILE_OK, file_system.DirectoryExists(kDir));
 
   sync_context_->ShutdownOnUIThread();
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForAddOrUpdate_NoParent) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
                                        io_task_runner_.get(),
                                        file_task_runner_.get());
   file_system.SetUp();
 
   sync_context_ = new LocalFileSyncContext(
       dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
   ASSERT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
-  ASSERT_EQ(base::PLATFORM_FILE_OK, file_system.OpenFileSystem());
+  ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
   const char kTestFileData[] = "Lorem ipsum!";
   const FileSystemURL kDir(file_system.URL("dir"));
   const FileSystemURL kFile(file_system.URL("dir/file"));
 
   // Either kDir or kFile not exist yet.
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, file_system.FileExists(kDir));
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, file_system.FileExists(kFile));
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, file_system.FileExists(kDir));
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, file_system.FileExists(kFile));
 
   // Prepare a temporary file which represents remote file data.
   const base::FilePath kFilePath(temp_dir.path().Append(FPL("file")));
   ASSERT_EQ(static_cast<int>(arraysize(kTestFileData) - 1),
             file_util::WriteFile(kFilePath, kTestFileData,
                                  arraysize(kTestFileData) - 1));
 
   // Calling ApplyChange's with kFilePath should create
   // kFile along with kDir.
   FileChange change(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                     SYNC_FILE_TYPE_FILE);
   EXPECT_EQ(SYNC_STATUS_OK,
             ApplyRemoteChange(file_system.file_system_context(),
                               change, kFilePath, kFile,
                               SYNC_FILE_TYPE_UNKNOWN));
 
   // The changes applied by ApplyRemoteChange should not be recorded in
   // the change tracker.
   FileSystemURLSet urls;
   urls.clear();
   file_system.GetChangedURLsInTracker(&urls);
   EXPECT_TRUE(urls.empty());
 
   // Make sure kDir and kFile are created by ApplyRemoteChange.
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.FileExists(kFile));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system.DirectoryExists(kDir));
+  EXPECT_EQ(base::File::FILE_OK, file_system.FileExists(kFile));
+  EXPECT_EQ(base::File::FILE_OK, file_system.DirectoryExists(kDir));
 
   sync_context_->ShutdownOnUIThread();
   file_system.TearDown();
 }
 
 }  // namespace sync_file_system