Convert Media Galleries to use base::File

chrome/browser/media_galleries/fileapi/native_media_file_util_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 47 matching lines @@
   { FPL("bar.jpg"), false, true, true, "\xFF\xD8\xFF" },
   // Unsupported masquerading file.
   { FPL("sna.jpg"), false, true, false, "abc" },
   // Non-media file.
   { FPL("baz.txt"), false, false, false, "abc" },
   // Unsupported media file.
   { FPL("foobar.cod"), false, false, false, "abc" },
 };
 
 void ExpectEqHelper(const std::string& test_name,
-                    base::PlatformFileError expected,
-                    base::PlatformFileError actual) {
+                    base::File::Error expected,
+                    base::File::Error actual) {
   EXPECT_EQ(expected, actual) << test_name;
 }
 
 void ExpectMetadataEqHelper(const std::string& test_name,
-                            base::PlatformFileError expected,
+                            base::File::Error expected,
                             bool expected_is_directory,
-                            base::PlatformFileError actual,
-                            const base::PlatformFileInfo& file_info) {
+                            base::File::Error actual,
+                            const base::File::Info& file_info) {
   EXPECT_EQ(expected, actual) << test_name;
-  if (actual == base::PLATFORM_FILE_OK)
+  if (actual == base::File::FILE_OK)
     EXPECT_EQ(expected_is_directory, file_info.is_directory) << test_name;
 }
 
 void DidReadDirectory(std::set<base::FilePath::StringType>* content,
                       bool* completed,
-                      base::PlatformFileError error,
+                      base::File::Error error,
                       const FileEntryList& file_list,
                       bool has_more) {
   EXPECT_TRUE(!*completed);
   *completed = !has_more;
   for (FileEntryList::const_iterator itr = file_list.begin();
        itr != file_list.end(); ++itr)
     EXPECT_TRUE(content->insert(itr->name).second);
 }
 
 void PopulateDirectoryWithTestCases(const base::FilePath& dir,
@@ skipping 103 matching lines @@
 };
 
 TEST_F(NativeMediaFileUtilTest, DirectoryExistsAndFileExistsFiltering) {
   PopulateDirectoryWithTestCases(root_path(),
                                  kFilteringTestCases,
                                  arraysize(kFilteringTestCases));
 
   for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
     FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
-    base::PlatformFileError expectation =
+    base::File::Error expectation =
         kFilteringTestCases[i].visible ?
-        base::PLATFORM_FILE_OK :
-        base::PLATFORM_FILE_ERROR_NOT_FOUND;
+        base::File::FILE_OK :
+        base::File::FILE_ERROR_NOT_FOUND;
 
     std::string test_name =
         base::StringPrintf("DirectoryExistsAndFileExistsFiltering %" PRIuS, i);
     if (kFilteringTestCases[i].is_directory) {
       operation_runner()->DirectoryExists(
           url, base::Bind(&ExpectEqHelper, test_name, expectation));
     } else {
       operation_runner()->FileExists(
           url, base::Bind(&ExpectEqHelper, test_name, expectation));
     }
@@ skipping 29 matching lines @@
   // pre-existing. Though the result should be the same.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
       if (kFilteringTestCases[i].is_directory) {
         FileSystemURL root_url = CreateURL(FPL(""));
         FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
         std::string test_name = base::StringPrintf(
             "CreateFileAndCreateDirectoryFiltering run %d, test %" PRIuS,
             loop_count, i);
-        base::PlatformFileError expectation =
+        base::File::Error expectation =
             kFilteringTestCases[i].visible ?
-            base::PLATFORM_FILE_OK :
-            base::PLATFORM_FILE_ERROR_SECURITY;
+            base::File::FILE_OK :
+            base::File::FILE_ERROR_SECURITY;
         operation_runner()->CreateDirectory(
             url, false, false,
             base::Bind(&ExpectEqHelper, test_name, expectation));
       }
       base::MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, CopySourceFiltering) {
@@ skipping 11 matching lines @@
       // Always start with an empty destination directory.
       // Copying to a non-empty destination directory is an invalid operation.
       ASSERT_TRUE(base::DeleteFile(dest_path, true));
       ASSERT_TRUE(base::CreateDirectory(dest_path));
 
       FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "CopySourceFiltering run %d test %" PRIuS, loop_count, i);
-      base::PlatformFileError expectation = base::PLATFORM_FILE_OK;
+      base::File::Error expectation = base::File::FILE_OK;
       if (loop_count == 0 || !kFilteringTestCases[i].visible) {
         // If the source does not exist or is not visible.
-        expectation = base::PLATFORM_FILE_ERROR_NOT_FOUND;
+        expectation = base::File::FILE_ERROR_NOT_FOUND;
       } else if (!kFilteringTestCases[i].is_directory) {
         // Cannot copy a visible file to a directory.
-        expectation = base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+        expectation = base::File::FILE_ERROR_INVALID_OPERATION;
       }
       operation_runner()->Copy(
           url, dest_url,
           fileapi::FileSystemOperation::OPTION_NONE,
           fileapi::FileSystemOperationRunner::CopyProgressCallback(),
           base::Bind(&ExpectEqHelper, test_name, expectation));
       base::MessageLoop::current()->RunUntilIdle();
     }
   }
 }
@@ skipping 22 matching lines @@
       if (loop_count == 0 && kFilteringTestCases[i].is_directory) {
         // These directories do not exist in this case, so Copy() will not
         // treat them as directories. Thus invalidating these test cases.
         continue;
       }
       FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "CopyDestFiltering run %d test %" PRIuS, loop_count, i);
-      base::PlatformFileError expectation;
+      base::File::Error expectation;
       if (loop_count == 0) {
         // The destination path is a file here. The directory case has been
         // handled above.
         // If the destination path does not exist and is not visible, then
         // creating it would be a security violation.
         expectation =
             kFilteringTestCases[i].visible ?
-            base::PLATFORM_FILE_OK :
-            base::PLATFORM_FILE_ERROR_SECURITY;
+            base::File::FILE_OK :
+            base::File::FILE_ERROR_SECURITY;
       } else {
         if (!kFilteringTestCases[i].visible) {
           // If the destination path exist and is not visible, then to the copy
           // operation, it looks like the file needs to be created, which is a
           // security violation.
-          expectation = base::PLATFORM_FILE_ERROR_SECURITY;
+          expectation = base::File::FILE_ERROR_SECURITY;
         } else if (kFilteringTestCases[i].is_directory) {
           // Cannot copy a file to a directory.
-          expectation = base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+          expectation = base::File::FILE_ERROR_INVALID_OPERATION;
         } else {
           // Copying from a file to a visible file that exists is ok.
-          expectation = base::PLATFORM_FILE_OK;
+          expectation = base::File::FILE_OK;
         }
       }
       operation_runner()->Copy(
           src_url, url,
           fileapi::FileSystemOperation::OPTION_NONE,
           fileapi::FileSystemOperationRunner::CopyProgressCallback(),
           base::Bind(&ExpectEqHelper, test_name, expectation));
       base::MessageLoop::current()->RunUntilIdle();
     }
   }
@@ skipping 14 matching lines @@
       // Always start with an empty destination directory.
       // Moving to a non-empty destination directory is an invalid operation.
       ASSERT_TRUE(base::DeleteFile(dest_path, true));
       ASSERT_TRUE(base::CreateDirectory(dest_path));
 
       FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "MoveSourceFiltering run %d test %" PRIuS, loop_count, i);
-      base::PlatformFileError expectation = base::PLATFORM_FILE_OK;
+      base::File::Error expectation = base::File::FILE_OK;
       if (loop_count == 0 || !kFilteringTestCases[i].visible) {
         // If the source does not exist or is not visible.
-        expectation = base::PLATFORM_FILE_ERROR_NOT_FOUND;
+        expectation = base::File::FILE_ERROR_NOT_FOUND;
       } else if (!kFilteringTestCases[i].is_directory) {
         // Cannot move a visible file to a directory.
-        expectation = base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+        expectation = base::File::FILE_ERROR_INVALID_OPERATION;
       }
       operation_runner()->Move(
           url, dest_url, fileapi::FileSystemOperation::OPTION_NONE,
           base::Bind(&ExpectEqHelper, test_name, expectation));
       base::MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, MoveDestFiltering) {
@@ skipping 22 matching lines @@
       FileSystemURL src_url = CreateURL(FPL("foo.jpg"));
       static const char kDummyData[] = "dummy";
       ASSERT_TRUE(
           file_util::WriteFile(src_path, kDummyData, strlen(kDummyData)));
 
       FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "MoveDestFiltering run %d test %" PRIuS, loop_count, i);
-      base::PlatformFileError expectation;
+      base::File::Error expectation;
       if (loop_count == 0) {
         // The destination path is a file here. The directory case has been
         // handled above.
         // If the destination path does not exist and is not visible, then
         // creating it would be a security violation.
         expectation =
             kFilteringTestCases[i].visible ?
-            base::PLATFORM_FILE_OK :
-            base::PLATFORM_FILE_ERROR_SECURITY;
+            base::File::FILE_OK :
+            base::File::FILE_ERROR_SECURITY;
       } else {
         if (!kFilteringTestCases[i].visible) {
           // If the destination path exist and is not visible, then to the move
           // operation, it looks like the file needs to be created, which is a
           // security violation.
-          expectation = base::PLATFORM_FILE_ERROR_SECURITY;
+          expectation = base::File::FILE_ERROR_SECURITY;
         } else if (kFilteringTestCases[i].is_directory) {
           // Cannot move a file to a directory.
-          expectation = base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+          expectation = base::File::FILE_ERROR_INVALID_OPERATION;
         } else {
           // Moving from a file to a visible file that exists is ok.
-          expectation = base::PLATFORM_FILE_OK;
+          expectation = base::File::FILE_OK;
         }
       }
       operation_runner()->Move(
           src_url, url, fileapi::FileSystemOperation::OPTION_NONE,
           base::Bind(&ExpectEqHelper, test_name, expectation));
       base::MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, GetMetadataFiltering) {
   // Run the loop twice. The first run has no files. The second run does.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     if (loop_count == 1) {
       PopulateDirectoryWithTestCases(root_path(),
                                      kFilteringTestCases,
                                      arraysize(kFilteringTestCases));
     }
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
       FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "GetMetadataFiltering run %d test %" PRIuS, loop_count, i);
-      base::PlatformFileError expectation = base::PLATFORM_FILE_OK;
+      base::File::Error expectation = base::File::FILE_OK;
       if (loop_count == 0 || !kFilteringTestCases[i].visible) {
         // Cannot get metadata from files that do not exist or are not visible.
-        expectation = base::PLATFORM_FILE_ERROR_NOT_FOUND;
+        expectation = base::File::FILE_ERROR_NOT_FOUND;
       }
       operation_runner()->GetMetadata(
           url,
           base::Bind(&ExpectMetadataEqHelper,
                      test_name,
                      expectation,
                      kFilteringTestCases[i].is_directory));
       base::MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, RemoveFileFiltering) {
   // Run the loop twice. The first run has no files. The second run does.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     if (loop_count == 1) {
       PopulateDirectoryWithTestCases(root_path(),
                                      kFilteringTestCases,
                                      arraysize(kFilteringTestCases));
     }
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
       FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "RemoveFiltering run %d test %" PRIuS, loop_count, i);
-      base::PlatformFileError expectation = base::PLATFORM_FILE_OK;
+      base::File::Error expectation = base::File::FILE_OK;
       if (loop_count == 0 || !kFilteringTestCases[i].visible) {
         // Cannot remove files that do not exist or are not visible.
-        expectation = base::PLATFORM_FILE_ERROR_NOT_FOUND;
+        expectation = base::File::FILE_ERROR_NOT_FOUND;
       } else if (kFilteringTestCases[i].is_directory) {
-        expectation = base::PLATFORM_FILE_ERROR_NOT_A_FILE;
+        expectation = base::File::FILE_ERROR_NOT_A_FILE;
       }
       operation_runner()->RemoveFile(
           url, base::Bind(&ExpectEqHelper, test_name, expectation));
       base::MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
-void CreateSnapshotCallback(base::PlatformFileError* error,
-    base::PlatformFileError result, const base::PlatformFileInfo&,
+void CreateSnapshotCallback(
+    base::File::Error* error,
+    base::File::Error result,
+    const base::File::Info&,
     const base::FilePath&,
     const scoped_refptr<webkit_blob::ShareableFileReference>&) {
   *error = result;
 }
 
 TEST_F(NativeMediaFileUtilTest, CreateSnapshot) {
   PopulateDirectoryWithTestCases(root_path(),
                                  kFilteringTestCases,
                                  arraysize(kFilteringTestCases));
   for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
     if (kFilteringTestCases[i].is_directory ||
         !kFilteringTestCases[i].visible) {
       continue;
     }
     FileSystemURL root_url = CreateURL(FPL(""));
     FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
-    base::PlatformFileError expected_error, error;
+    base::File::Error expected_error, error;
     if (kFilteringTestCases[i].media_file)
-      expected_error = base::PLATFORM_FILE_OK;
+      expected_error = base::File::FILE_OK;
     else
-      expected_error = base::PLATFORM_FILE_ERROR_SECURITY;
-    error = base::PLATFORM_FILE_ERROR_FAILED;
+      expected_error = base::File::FILE_ERROR_SECURITY;
+    error = base::File::FILE_ERROR_FAILED;
     operation_runner()->CreateSnapshotFile(url,
         base::Bind(CreateSnapshotCallback, &error));
     base::MessageLoop::current()->RunUntilIdle();
     ASSERT_EQ(expected_error, error);
   }
 }