FileAPI: Copy base::FileUtilProxy::Entry to fileapi::DirectoryEntry

webkit/fileapi/isolated_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 <map>
 #include <queue>
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 342 matching lines @@
 TEST_F(IsolatedFileUtilTest, ReadDirectoryTest) {
   for (size_t i = 0; i < test::kRegularTestCaseSize; ++i) {
     const test::TestCaseRecord& test_case = test::kRegularTestCases[i];
     if (!test_case.is_directory)
       continue;
 
     SCOPED_TRACE(testing::Message() << "Testing RegularTestCases " << i
                  << ": " << test_case.path);
 
     // Read entries in the directory to construct the expected results map.
-    typedef std::map<base::FilePath::StringType,
-                     base::FileUtilProxy::Entry> EntryMap;
+    typedef std::map<base::FilePath::StringType, DirectoryEntry> EntryMap;
     EntryMap expected_entry_map;
 
     base::FilePath dir_path = GetTestCasePlatformPath(test_case.path);
     FileEnumerator file_enum(
         dir_path, false /* not recursive */,
         FileEnumerator::FILES | FileEnumerator::DIRECTORIES);
     base::FilePath current;
     while (!(current = file_enum.Next()).empty()) {
       FileEnumerator::FindInfo file_info;
       file_enum.GetFindInfo(&file_info);
-      base::FileUtilProxy::Entry entry;
+      DirectoryEntry entry;
       entry.is_directory = FileEnumerator::IsDirectory(file_info);
       entry.name = current.BaseName().value();
       entry.size = FileEnumerator::GetFilesize(file_info);
       entry.last_modified_time = FileEnumerator::GetLastModifiedTime(file_info);
       expected_entry_map[entry.name] = entry;
 
 #if defined(OS_POSIX)
       // Creates a symlink for each file/directory.
       // They should be ignored by ReadDirectory, so we don't add them
       // to expected_entry_map.
       file_util::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,
               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 base::FileUtilProxy::Entry& entry = entries[i];
+      const 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());
     }
   }
 }
@@ skipping 132 matching lines @@
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               file_util()->Truncate(GetOperationContext().get(), url, 999));
     ASSERT_EQ(base::PLATFORM_FILE_OK,
               file_util()->GetFileInfo(GetOperationContext().get(), url,
                                        &info, &platform_path));
     EXPECT_EQ(999, info.size);
   }
 }
 
 }  // namespace fileapi