Convert Media Galleries to use base::File

content/browser/fileapi/copy_or_move_operation_delegate_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 <map>
 #include <queue>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 28 matching lines @@
 using fileapi::test::TestCaseRecord;
 
 namespace content {
 
 typedef fileapi::FileSystemOperation::FileEntryList FileEntryList;
 
 namespace {
 
 void ExpectOk(const GURL& origin_url,
               const std::string& name,
-              base::PlatformFileError error) {
-  ASSERT_EQ(base::PLATFORM_FILE_OK, error);
+              base::File::Error error) {
+  ASSERT_EQ(base::File::FILE_OK, error);
 }
 
 class TestValidatorFactory : public fileapi::CopyOrMoveFileValidatorFactory {
  public:
   // A factory that creates validators that accept everything or nothing.
   TestValidatorFactory() {}
   virtual ~TestValidatorFactory() {}
 
   virtual fileapi::CopyOrMoveFileValidator* CreateCopyOrMoveFileValidator(
       const FileSystemURL& /*src_url*/,
       const base::FilePath& /*platform_path*/) OVERRIDE {
     // Move arg management to TestValidator?
     return new TestValidator(true, true, std::string("2"));
   }
 
  private:
   class TestValidator : public fileapi::CopyOrMoveFileValidator {
    public:
     explicit TestValidator(bool pre_copy_valid,
                            bool post_copy_valid,
                            const std::string& reject_string)
-        : result_(pre_copy_valid ? base::PLATFORM_FILE_OK
-                                 : base::PLATFORM_FILE_ERROR_SECURITY),
-          write_result_(post_copy_valid ? base::PLATFORM_FILE_OK
-                                        : base::PLATFORM_FILE_ERROR_SECURITY),
+        : result_(pre_copy_valid ? base::File::FILE_OK :
+                                   base::File::FILE_ERROR_SECURITY),
+          write_result_(post_copy_valid ? base::File::FILE_OK :
+                                          base::File::FILE_ERROR_SECURITY),
           reject_string_(reject_string) {
     }
     virtual ~TestValidator() {}
 
     virtual void StartPreWriteValidation(
         const ResultCallback& result_callback) OVERRIDE {
       // Post the result since a real validator must do work asynchronously.
       base::MessageLoop::current()->PostTask(
           FROM_HERE, base::Bind(result_callback, result_));
     }
 
     virtual void StartPostWriteValidation(
         const base::FilePath& dest_platform_path,
         const ResultCallback& result_callback) OVERRIDE {
-      base::PlatformFileError result = write_result_;
+      base::File::Error result = write_result_;
       std::string unsafe = dest_platform_path.BaseName().AsUTF8Unsafe();
       if (unsafe.find(reject_string_) != std::string::npos) {
-        result = base::PLATFORM_FILE_ERROR_SECURITY;
+        result = base::File::FILE_ERROR_SECURITY;
       }
       // Post the result since a real validator must do work asynchronously.
       base::MessageLoop::current()->PostTask(
           FROM_HERE, base::Bind(result_callback, result));
     }
 
    private:
-    base::PlatformFileError result_;
-    base::PlatformFileError write_result_;
+    base::File::Error result_;
+    base::File::Error write_result_;
     std::string reject_string_;
 
     DISALLOW_COPY_AND_ASSIGN(TestValidator);
   };
 };
 
 // Records CopyProgressCallback invocations.
 struct ProgressRecord {
   fileapi::FileSystemOperation::CopyProgressType type;
   FileSystemURL source_url;
@@ skipping 13 matching lines @@
   record.size = size;
   records->push_back(record);
 }
 
 void RecordFileProgressCallback(std::vector<int64>* records,
                                 int64 progress) {
   records->push_back(progress);
 }
 
 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();
 }
 
 class ScopedThreadStopper {
  public:
   ScopedThreadStopper(base::Thread* thread) : thread_(thread) {
   }
 
   ~ScopedThreadStopper() {
@@ skipping 105 matching lines @@
   FileSystemURL SourceURL(const std::string& path) {
     return file_system_context_->CreateCrackedFileSystemURL(
         origin_, src_type_, base::FilePath::FromUTF8Unsafe(path));
   }
 
   FileSystemURL DestURL(const std::string& path) {
     return file_system_context_->CreateCrackedFileSystemURL(
         origin_, dest_type_, base::FilePath::FromUTF8Unsafe(path));
   }
 
-  base::PlatformFileError Copy(const FileSystemURL& src,
-                               const FileSystemURL& dest) {
+  base::File::Error Copy(const FileSystemURL& src,
+                         const FileSystemURL& dest) {
     return AsyncFileTestHelper::Copy(file_system_context_.get(), src, dest);
   }
 
-  base::PlatformFileError CopyWithProgress(
+  base::File::Error CopyWithProgress(
       const FileSystemURL& src,
       const FileSystemURL& dest,
       const AsyncFileTestHelper::CopyProgressCallback& progress_callback) {
     return AsyncFileTestHelper::CopyWithProgress(
         file_system_context_.get(), src, dest, progress_callback);
   }
 
-  base::PlatformFileError Move(const FileSystemURL& src,
-                               const FileSystemURL& dest) {
+  base::File::Error Move(const FileSystemURL& src,
+                         const FileSystemURL& dest) {
     return AsyncFileTestHelper::Move(file_system_context_.get(), src, dest);
   }
 
-  base::PlatformFileError SetUpTestCaseFiles(
+  base::File::Error SetUpTestCaseFiles(
       const FileSystemURL& root,
       const TestCaseRecord* const test_cases,
       size_t test_case_size) {
-    base::PlatformFileError result = base::PLATFORM_FILE_ERROR_FAILED;
+    base::File::Error result = base::File::FILE_ERROR_FAILED;
     for (size_t i = 0; i < test_case_size; ++i) {
       const TestCaseRecord& test_case = test_cases[i];
       FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
           root.origin(),
           root.mount_type(),
           root.virtual_path().Append(test_case.path));
       if (test_case.is_directory)
         result = CreateDirectory(url);
       else
         result = CreateFile(url, test_case.data_file_size);
-      EXPECT_EQ(base::PLATFORM_FILE_OK, result) << url.DebugString();
-      if (result != base::PLATFORM_FILE_OK)
+      EXPECT_EQ(base::File::FILE_OK, result) << url.DebugString();
+      if (result != base::File::FILE_OK)
         return result;
     }
     return result;
   }
 
   void VerifyTestCaseFiles(
       const FileSystemURL& root,
       const TestCaseRecord* const test_cases,
       size_t test_case_size) {
     std::map<base::FilePath, const TestCaseRecord*> test_case_map;
     for (size_t i = 0; i < test_case_size; ++i) {
       test_case_map[
           base::FilePath(test_cases[i].path).NormalizePathSeparators()] =
               &test_cases[i];
     }
 
     std::queue<FileSystemURL> directories;
     FileEntryList entries;
     directories.push(root);
     while (!directories.empty()) {
       FileSystemURL dir = directories.front();
       directories.pop();
-      ASSERT_EQ(base::PLATFORM_FILE_OK, ReadDirectory(dir, &entries));
+      ASSERT_EQ(base::File::FILE_OK, ReadDirectory(dir, &entries));
       for (size_t i = 0; i < entries.size(); ++i) {
         FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
             dir.origin(),
             dir.mount_type(),
             dir.virtual_path().Append(entries[i].name));
         base::FilePath relative;
         root.virtual_path().AppendRelativePath(url.virtual_path(), &relative);
         relative = relative.NormalizePathSeparators();
         ASSERT_TRUE(ContainsKey(test_case_map, relative));
         if (entries[i].is_directory) {
           EXPECT_TRUE(test_case_map[relative]->is_directory);
           directories.push(url);
         } else {
           EXPECT_FALSE(test_case_map[relative]->is_directory);
           EXPECT_TRUE(FileExists(url, test_case_map[relative]->data_file_size));
         }
         test_case_map.erase(relative);
       }
     }
     EXPECT_TRUE(test_case_map.empty());
     std::map<base::FilePath, const TestCaseRecord*>::const_iterator it;
     for (it = test_case_map.begin(); it != test_case_map.end(); ++it) {
       LOG(ERROR) << "Extra entry: " << it->first.LossyDisplayName();
     }
   }
 
-  base::PlatformFileError ReadDirectory(const FileSystemURL& url,
-                                        FileEntryList* entries) {
+  base::File::Error ReadDirectory(const FileSystemURL& url,
+                                  FileEntryList* entries) {
     return AsyncFileTestHelper::ReadDirectory(
         file_system_context_.get(), url, entries);
   }
 
-  base::PlatformFileError CreateDirectory(const FileSystemURL& url) {
+  base::File::Error CreateDirectory(const FileSystemURL& url) {
     return AsyncFileTestHelper::CreateDirectory(file_system_context_.get(),
                                                 url);
   }
 
-  base::PlatformFileError CreateFile(const FileSystemURL& url, size_t size) {
-    base::PlatformFileError result =
+  base::File::Error CreateFile(const FileSystemURL& url, size_t size) {
+    base::File::Error result =
         AsyncFileTestHelper::CreateFile(file_system_context_.get(), url);
-    if (result != base::PLATFORM_FILE_OK)
+    if (result != base::File::FILE_OK)
       return result;
     return AsyncFileTestHelper::TruncateFile(
         file_system_context_.get(), url, size);
   }
 
   bool FileExists(const FileSystemURL& url, int64 expected_size) {
     return AsyncFileTestHelper::FileExists(
         file_system_context_.get(), url, expected_size);
   }
 
@@ skipping 29 matching lines @@
                                        fileapi::kFileSystemTypeTemporary,
                                        fileapi::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
   int64 src_initial_usage = helper.GetSourceUsage();
   int64 dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source file.
-  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateFile(src, 10));
+  ASSERT_EQ(base::File::FILE_OK, helper.CreateFile(src, 10));
   int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Copy it.
-  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.Copy(src, dest));
+  ASSERT_EQ(base::File::FILE_OK, helper.Copy(src, dest));
 
   // Verify.
   ASSERT_TRUE(helper.FileExists(src, 10));
   ASSERT_TRUE(helper.FileExists(dest, 10));
 
   int64 src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage + src_increase, src_new_usage);
 
   int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, MoveSingleFile) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
                                        fileapi::kFileSystemTypeTemporary,
                                        fileapi::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
   int64 src_initial_usage = helper.GetSourceUsage();
   int64 dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source file.
-  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateFile(src, 10));
+  ASSERT_EQ(base::File::FILE_OK, helper.CreateFile(src, 10));
   int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Move it.
-  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.Move(src, dest));
+  ASSERT_EQ(base::File::FILE_OK, helper.Move(src, dest));
 
   // Verify.
   ASSERT_FALSE(helper.FileExists(src, AsyncFileTestHelper::kDontCheckSize));
   ASSERT_TRUE(helper.FileExists(dest, 10));
 
   int64 src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage, src_new_usage);
 
   int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, CopySingleDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
                                        fileapi::kFileSystemTypeTemporary,
                                        fileapi::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
   int64 src_initial_usage = helper.GetSourceUsage();
   int64 dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source directory.
-  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateDirectory(src));
+  ASSERT_EQ(base::File::FILE_OK, helper.CreateDirectory(src));
   int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Copy it.
-  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.Copy(src, dest));
+  ASSERT_EQ(base::File::FILE_OK, helper.Copy(src, dest));
 
   // Verify.
   ASSERT_TRUE(helper.DirectoryExists(src));
   ASSERT_TRUE(helper.DirectoryExists(dest));
 
   int64 src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage + src_increase, src_new_usage);
 
   int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, MoveSingleDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
                                        fileapi::kFileSystemTypeTemporary,
                                        fileapi::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
   int64 src_initial_usage = helper.GetSourceUsage();
   int64 dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source directory.
-  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateDirectory(src));
+  ASSERT_EQ(base::File::FILE_OK, helper.CreateDirectory(src));
   int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Move it.
-  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.Move(src, dest));
+  ASSERT_EQ(base::File::FILE_OK, helper.Move(src, dest));
 
   // Verify.
   ASSERT_FALSE(helper.DirectoryExists(src));
   ASSERT_TRUE(helper.DirectoryExists(dest));
 
   int64 src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage, src_new_usage);
 
   int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, CopyDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
                                        fileapi::kFileSystemTypeTemporary,
                                        fileapi::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
   int64 src_initial_usage = helper.GetSourceUsage();
   int64 dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source directory.
-  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateDirectory(src));
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK, helper.CreateDirectory(src));
+  ASSERT_EQ(base::File::FILE_OK,
             helper.SetUpTestCaseFiles(src,
                                       fileapi::test::kRegularTestCases,
                                       fileapi::test::kRegularTestCaseSize));
   int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Copy it.
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             helper.CopyWithProgress(
                 src, dest,
                 AsyncFileTestHelper::CopyProgressCallback()));
 
   // Verify.
   ASSERT_TRUE(helper.DirectoryExists(src));
   ASSERT_TRUE(helper.DirectoryExists(dest));
 
   helper.VerifyTestCaseFiles(dest,
                              fileapi::test::kRegularTestCases,
@@ skipping 11 matching lines @@
                                        fileapi::kFileSystemTypeTemporary,
                                        fileapi::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
   int64 src_initial_usage = helper.GetSourceUsage();
   int64 dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source directory.
-  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateDirectory(src));
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK, helper.CreateDirectory(src));
+  ASSERT_EQ(base::File::FILE_OK,
             helper.SetUpTestCaseFiles(src,
                                       fileapi::test::kRegularTestCases,
                                       fileapi::test::kRegularTestCaseSize));
   int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Move it.
-  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.Move(src, dest));
+  ASSERT_EQ(base::File::FILE_OK, helper.Move(src, dest));
 
   // Verify.
   ASSERT_FALSE(helper.DirectoryExists(src));
   ASSERT_TRUE(helper.DirectoryExists(dest));
 
   helper.VerifyTestCaseFiles(dest,
                              fileapi::test::kRegularTestCases,
                              fileapi::test::kRegularTestCaseSize);
 
   int64 src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage, src_new_usage);
 
   int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest,
      MoveDirectoryFailPostWriteValidation) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
                                        fileapi::kFileSystemTypeTemporary,
                                        fileapi::kFileSystemTypeTest);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
 
   // Set up a source directory.
-  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateDirectory(src));
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK, helper.CreateDirectory(src));
+  ASSERT_EQ(base::File::FILE_OK,
             helper.SetUpTestCaseFiles(src,
                                       fileapi::test::kRegularTestCases,
                                       fileapi::test::kRegularTestCaseSize));
 
   // Move it.
   helper.Move(src, dest);
 
   // Verify.
   ASSERT_TRUE(helper.DirectoryExists(src));
   ASSERT_TRUE(helper.DirectoryExists(dest));
@@ skipping 11 matching lines @@
 TEST(LocalFileSystemCopyOrMoveOperationTest, CopySingleFileNoValidator) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
                                        fileapi::kFileSystemTypeTemporary,
                                        fileapi::kFileSystemTypeTest);
   helper.SetUpNoValidator();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
 
   // Set up a source file.
-  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateFile(src, 10));
+  ASSERT_EQ(base::File::FILE_OK, helper.CreateFile(src, 10));
 
   // The copy attempt should fail with a security error -- getting
   // the factory returns a security error, and the copy operation must
   // respect that.
-  ASSERT_EQ(base::PLATFORM_FILE_ERROR_SECURITY, helper.Copy(src, dest));
+  ASSERT_EQ(base::File::FILE_ERROR_SECURITY, helper.Copy(src, dest));
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, ProgressCallback) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
                                        fileapi::kFileSystemTypeTemporary,
                                        fileapi::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
 
   // Set up a source directory.
-  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateDirectory(src));
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK, helper.CreateDirectory(src));
+  ASSERT_EQ(base::File::FILE_OK,
             helper.SetUpTestCaseFiles(src,
                                       fileapi::test::kRegularTestCases,
                                       fileapi::test::kRegularTestCaseSize));
 
   std::vector<ProgressRecord> records;
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             helper.CopyWithProgress(src, dest,
                                     base::Bind(&RecordProgressCallback,
                                                base::Unretained(&records))));
 
   // Verify progress callback.
   for (size_t i = 0; i < fileapi::test::kRegularTestCaseSize; ++i) {
     const TestCaseRecord& test_case = fileapi::test::kRegularTestCases[i];
 
     FileSystemURL src_url = helper.SourceURL(
         std::string("a/") + base::FilePath(test_case.path).AsUTF8Unsafe());
@@ skipping 69 matching lines @@
       FileStreamWriter::CreateForLocalFile(task_runner.get(), dest_path, 0));
 
   std::vector<int64> progress;
   CopyOrMoveOperationDelegate::StreamCopyHelper helper(
       reader.Pass(), writer.Pass(),
       false,  // don't need flush
       10,  // buffer size
       base::Bind(&RecordFileProgressCallback, base::Unretained(&progress)),
       base::TimeDelta());  // For testing, we need all the progress.
 
-  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error error = base::File::FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   helper.Run(base::Bind(&AssignAndQuit, &run_loop, &error));
   run_loop.Run();
 
-  EXPECT_EQ(base::PLATFORM_FILE_OK, error);
+  EXPECT_EQ(base::File::FILE_OK, error);
   ASSERT_EQ(5U, progress.size());
   EXPECT_EQ(0, progress[0]);
   EXPECT_EQ(10, progress[1]);
   EXPECT_EQ(20, progress[2]);
   EXPECT_EQ(30, progress[3]);
   EXPECT_EQ(36, progress[4]);
 
   std::string content;
   ASSERT_TRUE(base::ReadFileToString(dest_path, &content));
   EXPECT_EQ(kTestData, content);
@@ skipping 32 matching lines @@
       FileStreamWriter::CreateForLocalFile(task_runner.get(), dest_path, 0));
 
   std::vector<int64> progress;
   CopyOrMoveOperationDelegate::StreamCopyHelper helper(
       reader.Pass(), writer.Pass(),
       true,  // need flush
       10,  // buffer size
       base::Bind(&RecordFileProgressCallback, base::Unretained(&progress)),
       base::TimeDelta());  // For testing, we need all the progress.
 
-  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error error = base::File::FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   helper.Run(base::Bind(&AssignAndQuit, &run_loop, &error));
   run_loop.Run();
 
-  EXPECT_EQ(base::PLATFORM_FILE_OK, error);
+  EXPECT_EQ(base::File::FILE_OK, error);
   ASSERT_EQ(5U, progress.size());
   EXPECT_EQ(0, progress[0]);
   EXPECT_EQ(10, progress[1]);
   EXPECT_EQ(20, progress[2]);
   EXPECT_EQ(30, progress[3]);
   EXPECT_EQ(36, progress[4]);
 
   std::string content;
   ASSERT_TRUE(base::ReadFileToString(dest_path, &content));
   EXPECT_EQ(kTestData, content);
@@ skipping 34 matching lines @@
       10,  // buffer size
       base::Bind(&RecordFileProgressCallback, base::Unretained(&progress)),
       base::TimeDelta());  // For testing, we need all the progress.
 
   // Call Cancel() later.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&CopyOrMoveOperationDelegate::StreamCopyHelper::Cancel,
                  base::Unretained(&helper)));
 
-  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+  base::File::Error error = base::File::FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   helper.Run(base::Bind(&AssignAndQuit, &run_loop, &error));
   run_loop.Run();
 
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_ABORT, error);
+  EXPECT_EQ(base::File::FILE_ERROR_ABORT, error);
 }
 
 }  // namespace content