Convert Media Galleries to use base::File

content/browser/fileapi/dragged_file_util_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 <set>
 #include <string>
 #include <vector>
 
@@ skipping 38 matching lines @@
 };
 
 base::FilePath GetTopLevelPath(const base::FilePath& path) {
   std::vector<base::FilePath::StringType> components;
   path.GetComponents(&components);
   return base::FilePath(components[0]);
 }
 
 bool IsDirectoryEmpty(FileSystemContext* context, const FileSystemURL& url) {
   FileEntryList entries;
-  EXPECT_EQ(base::PLATFORM_FILE_OK,
+  EXPECT_EQ(base::File::FILE_OK,
             AsyncFileTestHelper::ReadDirectory(context, url, &entries));
   return entries.empty();
 }
 
 FileSystemURL GetEntryURL(FileSystemContext* file_system_context,
                           const FileSystemURL& dir,
                           const base::FilePath::StringType& name) {
   return file_system_context->CreateCrackedFileSystemURL(
       dir.origin(),
       dir.mount_type(),
@@ skipping 85 matching lines @@
   FileSystemURL GetOtherFileSystemURL(const base::FilePath& path) const {
     return file_system_context()->CreateCrackedFileSystemURL(
         GURL("http://example.com"),
         fileapi::kFileSystemTypeTemporary,
         base::FilePath().AppendASCII("dest").Append(path));
   }
 
   void VerifyFilesHaveSameContent(const FileSystemURL& url1,
                                   const FileSystemURL& url2) {
     // Get the file info and the platform path for url1.
-    base::PlatformFileInfo info1;
-    ASSERT_EQ(base::PLATFORM_FILE_OK,
+    base::File::Info info1;
+    ASSERT_EQ(base::File::FILE_OK,
               AsyncFileTestHelper::GetMetadata(
                   file_system_context(), url1, &info1));
     base::FilePath platform_path1;
-    ASSERT_EQ(base::PLATFORM_FILE_OK,
+    ASSERT_EQ(base::File::FILE_OK,
               AsyncFileTestHelper::GetPlatformPath(
                   file_system_context(), url1, &platform_path1));
 
     // Get the file info and the platform path  for url2.
-    base::PlatformFileInfo info2;
-    ASSERT_EQ(base::PLATFORM_FILE_OK,
+    base::File::Info info2;
+    ASSERT_EQ(base::File::FILE_OK,
               AsyncFileTestHelper::GetMetadata(
                   file_system_context(), url2, &info2));
     base::FilePath platform_path2;
-    ASSERT_EQ(base::PLATFORM_FILE_OK,
+    ASSERT_EQ(base::File::FILE_OK,
               AsyncFileTestHelper::GetPlatformPath(
                   file_system_context(), url2, &platform_path2));
 
     // See if file info matches with the other one.
     EXPECT_EQ(info1.is_directory, info2.is_directory);
     EXPECT_EQ(info1.size, info2.size);
     EXPECT_EQ(info1.is_symbolic_link, info2.is_symbolic_link);
     EXPECT_NE(platform_path1, platform_path2);
 
     std::string content1, content2;
     EXPECT_TRUE(base::ReadFileToString(platform_path1, &content1));
     EXPECT_TRUE(base::ReadFileToString(platform_path2, &content2));
     EXPECT_EQ(content1, content2);
   }
 
   void VerifyDirectoriesHaveSameContent(const FileSystemURL& root1,
                                         const FileSystemURL& root2) {
     base::FilePath root_path1 = root1.path();
     base::FilePath root_path2 = root2.path();
 
     FileEntryList entries;
     std::queue<FileSystemURL> directories;
 
     directories.push(root1);
     std::set<base::FilePath> file_set1;
     while (!directories.empty()) {
       FileSystemURL dir = directories.front();
       directories.pop();
 
-      ASSERT_EQ(base::PLATFORM_FILE_OK,
+      ASSERT_EQ(base::File::FILE_OK,
                 AsyncFileTestHelper::ReadDirectory(
                     file_system_context(), dir, &entries));
       for (size_t i = 0; i < entries.size(); ++i) {
         FileSystemURL url = GetEntryURL(file_system_context(),
                                         dir, entries[i].name);
         if (entries[i].is_directory) {
           directories.push(url);
           continue;
         }
         file_set1.insert(GetRelativeVirtualPath(root1, url));
       }
     }
 
     directories.push(root2);
     while (!directories.empty()) {
       FileSystemURL dir = directories.front();
       directories.pop();
 
-      ASSERT_EQ(base::PLATFORM_FILE_OK,
+      ASSERT_EQ(base::File::FILE_OK,
                 AsyncFileTestHelper::ReadDirectory(
                     file_system_context(), dir, &entries));
       for (size_t i = 0; i < entries.size(); ++i) {
         FileSystemURL url2 = GetEntryURL(file_system_context(),
                                          dir, entries[i].name);
         FileSystemURL url1 = GetOtherURL(file_system_context(),
                                          root2, root1, url2);
         if (entries[i].is_directory) {
           directories.push(url2);
           EXPECT_EQ(IsDirectoryEmpty(file_system_context(), url1),
@@ skipping 54 matching lines @@
   for (size_t i = 0; i < fileapi::test::kRegularTestCaseSize; ++i) {
     SCOPED_TRACE(testing::Message() << "Testing RegularTestCases " << i);
     const fileapi::test::TestCaseRecord& test_case =
         fileapi::test::kRegularTestCases[i];
 
     FileSystemURL url = GetFileSystemURL(base::FilePath(test_case.path));
 
     // See if we can query the file info via the isolated FileUtil.
     // (This should succeed since we have registered all the top-level
     // entries of the test cases in SetUp())
-    base::PlatformFileInfo info;
+    base::File::Info info;
     base::FilePath platform_path;
     FileSystemOperationContext context(file_system_context());
-    ASSERT_EQ(base::PLATFORM_FILE_OK,
+    ASSERT_EQ(base::File::FILE_OK,
               file_util()->GetFileInfo(&context, url, &info, &platform_path));
 
     // See if the obtained file info is correct.
     if (!test_case.is_directory)
       ASSERT_EQ(test_case.data_file_size, info.size);
     ASSERT_EQ(test_case.is_directory, info.is_directory);
     ASSERT_EQ(GetTestCasePlatformPath(test_case.path),
               platform_path.NormalizePathSeparators());
   }
 }
@@ skipping 68 matching lines @@
       base::CreateSymbolicLink(
           current,
           dir_path.Append(current.BaseName().AddExtension(
               FILE_PATH_LITERAL("link"))));
 #endif
     }
 
     // Perform ReadDirectory in the isolated filesystem.
     FileSystemURL url = GetFileSystemURL(base::FilePath(test_case.path));
     FileEntryList entries;
-    ASSERT_EQ(base::PLATFORM_FILE_OK,
+    ASSERT_EQ(base::File::FILE_OK,
               AsyncFileTestHelper::ReadDirectory(
                   file_system_context(), url, &entries));
 
     EXPECT_EQ(expected_entry_map.size(), entries.size());
     for (size_t i = 0; i < entries.size(); ++i) {
       const fileapi::DirectoryEntry& entry = entries[i];
       EntryMap::iterator found = expected_entry_map.find(entry.name);
       EXPECT_TRUE(found != expected_entry_map.end());
       EXPECT_EQ(found->second.name, entry.name);
       EXPECT_EQ(found->second.is_directory, entry.is_directory);
       EXPECT_EQ(found->second.size, entry.size);
       EXPECT_EQ(found->second.last_modified_time.ToDoubleT(),
                 entry.last_modified_time.ToDoubleT());
     }
   }
 }
 
 TEST_F(DraggedFileUtilTest, GetLocalFilePathTest) {
   for (size_t i = 0; i < fileapi::test::kRegularTestCaseSize; ++i) {
     const fileapi::test::TestCaseRecord& test_case =
         fileapi::test::kRegularTestCases[i];
     FileSystemURL url = GetFileSystemURL(base::FilePath(test_case.path));
 
     FileSystemOperationContext context(file_system_context());
 
     base::FilePath local_file_path;
-    EXPECT_EQ(base::PLATFORM_FILE_OK,
+    EXPECT_EQ(base::File::FILE_OK,
               file_util()->GetLocalFilePath(&context, url, &local_file_path));
     EXPECT_EQ(GetTestCasePlatformPath(test_case.path).value(),
               local_file_path.value());
   }
 }
 
 TEST_F(DraggedFileUtilTest, CopyOutFileTest) {
   FileSystemURL src_root = GetFileSystemURL(base::FilePath());
   FileSystemURL dest_root = GetOtherFileSystemURL(base::FilePath());
 
   FileEntryList entries;
   std::queue<FileSystemURL> directories;
   directories.push(src_root);
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             AsyncFileTestHelper::CreateDirectory(file_system_context(),
                                                  dest_root));
 
   while (!directories.empty()) {
     FileSystemURL dir = directories.front();
     directories.pop();
-    ASSERT_EQ(base::PLATFORM_FILE_OK,
+    ASSERT_EQ(base::File::FILE_OK,
               AsyncFileTestHelper::ReadDirectory(file_system_context(),
                                                  dir, &entries));
     for (size_t i = 0; i < entries.size(); ++i) {
       FileSystemURL src_url = GetEntryURL(file_system_context(),
                                           dir, entries[i].name);
       FileSystemURL dest_url = GetOtherURL(file_system_context(),
                                            src_root, dest_root, src_url);
 
       if (entries[i].is_directory) {
-        ASSERT_EQ(base::PLATFORM_FILE_OK,
+        ASSERT_EQ(base::File::FILE_OK,
                   AsyncFileTestHelper::CreateDirectory(file_system_context(),
                                                        dest_url));
         directories.push(src_url);
         continue;
       }
       SCOPED_TRACE(testing::Message() << "Testing file copy "
                    << src_url.path().value());
-      ASSERT_EQ(base::PLATFORM_FILE_OK,
+      ASSERT_EQ(base::File::FILE_OK,
                 AsyncFileTestHelper::Copy(file_system_context(),
                                           src_url, dest_url));
       VerifyFilesHaveSameContent(src_url, dest_url);
     }
   }
 }
 
 TEST_F(DraggedFileUtilTest, CopyOutDirectoryTest) {
   FileSystemURL src_root = GetFileSystemURL(base::FilePath());
   FileSystemURL dest_root = GetOtherFileSystemURL(base::FilePath());
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             AsyncFileTestHelper::CreateDirectory(file_system_context(),
                                                  dest_root));
 
   FileEntryList entries;
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             AsyncFileTestHelper::ReadDirectory(file_system_context(),
                                                src_root, &entries));
   for (size_t i = 0; i < entries.size(); ++i) {
     if (!entries[i].is_directory)
       continue;
     FileSystemURL src_url = GetEntryURL(file_system_context(),
                                         src_root, entries[i].name);
     FileSystemURL dest_url = GetOtherURL(file_system_context(),
                                          src_root, dest_root, src_url);
     SCOPED_TRACE(testing::Message() << "Testing file copy "
                  << src_url.path().value());
-    ASSERT_EQ(base::PLATFORM_FILE_OK,
+    ASSERT_EQ(base::File::FILE_OK,
               AsyncFileTestHelper::Copy(file_system_context(),
                                         src_url, dest_url));
     VerifyDirectoriesHaveSameContent(src_url, dest_url);
   }
 }
 
 TEST_F(DraggedFileUtilTest, TouchTest) {
   for (size_t i = 0; i < fileapi::test::kRegularTestCaseSize; ++i) {
     const fileapi::test::TestCaseRecord& test_case =
         fileapi::test::kRegularTestCases[i];
     if (test_case.is_directory)
       continue;
     SCOPED_TRACE(testing::Message() << test_case.path);
     FileSystemURL url = GetFileSystemURL(base::FilePath(test_case.path));
 
     base::Time last_access_time = base::Time::FromTimeT(1000);
     base::Time last_modified_time = base::Time::FromTimeT(2000);
 
-    EXPECT_EQ(base::PLATFORM_FILE_OK,
+    EXPECT_EQ(base::File::FILE_OK,
               file_util()->Touch(GetOperationContext().get(), url,
                                  last_access_time,
                                  last_modified_time));
 
     // Verification.
-    base::PlatformFileInfo info;
+    base::File::Info info;
     base::FilePath platform_path;
-    ASSERT_EQ(base::PLATFORM_FILE_OK,
+    ASSERT_EQ(base::File::FILE_OK,
               file_util()->GetFileInfo(GetOperationContext().get(), url,
                                        &info, &platform_path));
     EXPECT_EQ(last_access_time.ToTimeT(), info.last_accessed.ToTimeT());
     EXPECT_EQ(last_modified_time.ToTimeT(), info.last_modified.ToTimeT());
   }
 }
 
 TEST_F(DraggedFileUtilTest, TruncateTest) {
   for (size_t i = 0; i < fileapi::test::kRegularTestCaseSize; ++i) {
     const fileapi::test::TestCaseRecord& test_case =
         fileapi::test::kRegularTestCases[i];
     if (test_case.is_directory)
       continue;
 
     SCOPED_TRACE(testing::Message() << test_case.path);
     FileSystemURL url = GetFileSystemURL(base::FilePath(test_case.path));
 
     // Truncate to 0.
-    base::PlatformFileInfo info;
+    base::File::Info info;
     base::FilePath platform_path;
-    EXPECT_EQ(base::PLATFORM_FILE_OK,
+    EXPECT_EQ(base::File::FILE_OK,
               file_util()->Truncate(GetOperationContext().get(), url, 0));
-    ASSERT_EQ(base::PLATFORM_FILE_OK,
+    ASSERT_EQ(base::File::FILE_OK,
               file_util()->GetFileInfo(GetOperationContext().get(), url,
                                        &info, &platform_path));
     EXPECT_EQ(0, info.size);
 
     // Truncate (extend) to 999.
-    EXPECT_EQ(base::PLATFORM_FILE_OK,
+    EXPECT_EQ(base::File::FILE_OK,
               file_util()->Truncate(GetOperationContext().get(), url, 999));
-    ASSERT_EQ(base::PLATFORM_FILE_OK,
+    ASSERT_EQ(base::File::FILE_OK,
               file_util()->GetFileInfo(GetOperationContext().get(), url,
                                        &info, &platform_path));
     EXPECT_EQ(999, info.size);
   }
 }
 
 }  // namespace content