Move file enumeration to filepaths.

base/file_util_unittest.cc

 // Copyright (c) 2006-2008 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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
@@ skipping 37 matching lines @@
 
   // the path to temporary directory used to contain the test operations
   FilePath test_dir_;
 };
 
 // Collects all the results from the given file enumerator, and provides an
 // interface to query whether a given file is present.
 class FindResultCollector {
  public:
   FindResultCollector(file_util::FileEnumerator& enumerator) {
-    std::wstring cur_file;
-    while (!(cur_file = enumerator.Next()).empty()) {
-      FilePath::StringType path = FilePath::FromWStringHack(cur_file).value();
+    FilePath cur_file;
+    while (!(cur_file = enumerator.Next()).value().empty()) {
+      FilePath::StringType path = cur_file.value();
       // The file should not be returned twice.
       EXPECT_TRUE(files_.end() == files_.find(path))
           << "Same file returned twice";
 
       // Save for later.
       files_.insert(path);
     }
   }
 
   // Returns true if the enumerator found the file.
@@ skipping 752 matching lines @@
   path = path.Append(FILE_PATH_LITERAL("foo.bar"));
   path = path.Append(FILE_PATH_LITERAL("foo"));
   // '/foo.bar/foo' with extension '.baz'
   FilePath result_path = path;
   file_util::ReplaceExtension(&result_path, FILE_PATH_LITERAL(".baz"));
   EXPECT_EQ(path.ToWStringHack() + L".baz", result_path.ToWStringHack());
 }
 
 TEST_F(FileUtilTest, FileEnumeratorTest) {
   // Test an empty directory.
-  file_util::FileEnumerator f0(test_dir_.ToWStringHack(), true,
+  file_util::FileEnumerator f0(test_dir_, true,
       file_util::FileEnumerator::FILES_AND_DIRECTORIES);
-  EXPECT_EQ(f0.Next(), L"");
-  EXPECT_EQ(f0.Next(), L"");
+  EXPECT_EQ(f0.Next().value(), FILE_PATH_LITERAL(""));
+  EXPECT_EQ(f0.Next().value(), FILE_PATH_LITERAL(""));
 
   // create the directories
   FilePath dir1 = test_dir_.Append(FILE_PATH_LITERAL("dir1"));
   EXPECT_TRUE(file_util::CreateDirectory(dir1));
   FilePath dir2 = test_dir_.Append(FILE_PATH_LITERAL("dir2"));
   EXPECT_TRUE(file_util::CreateDirectory(dir2));
   FilePath dir2inner = dir2.Append(FILE_PATH_LITERAL("inner"));
   EXPECT_TRUE(file_util::CreateDirectory(dir2inner));
 
   // create the files
   FilePath dir2file = dir2.Append(FILE_PATH_LITERAL("dir2file.txt"));
   CreateTextFile(dir2file, L"");
   FilePath dir2innerfile = dir2inner.Append(FILE_PATH_LITERAL("innerfile.txt"));
   CreateTextFile(dir2innerfile, L"");
   FilePath file1 = test_dir_.Append(FILE_PATH_LITERAL("file1.txt"));
   CreateTextFile(file1, L"");
   FilePath file2_rel =
       dir2.Append(FilePath::kParentDirectory)
           .Append(FILE_PATH_LITERAL("file2.txt"));
   CreateTextFile(file2_rel, L"");
   FilePath file2_abs = test_dir_.Append(FILE_PATH_LITERAL("file2.txt"));
 
   // Only enumerate files.
-  file_util::FileEnumerator f1(test_dir_.ToWStringHack(), true,
+  file_util::FileEnumerator f1(test_dir_, true,
                                file_util::FileEnumerator::FILES);
   FindResultCollector c1(f1);
   EXPECT_TRUE(c1.HasFile(file1));
   EXPECT_TRUE(c1.HasFile(file2_abs));
   EXPECT_TRUE(c1.HasFile(dir2file));
   EXPECT_TRUE(c1.HasFile(dir2innerfile));
   EXPECT_EQ(c1.size(), 4);
 
   // Only enumerate directories.
-  file_util::FileEnumerator f2(test_dir_.ToWStringHack(), true,
+  file_util::FileEnumerator f2(test_dir_, true,
                                file_util::FileEnumerator::DIRECTORIES);
   FindResultCollector c2(f2);
   EXPECT_TRUE(c2.HasFile(dir1));
   EXPECT_TRUE(c2.HasFile(dir2));
   EXPECT_TRUE(c2.HasFile(dir2inner));
   EXPECT_EQ(c2.size(), 3);
 
   // Only enumerate directories non-recursively.
   file_util::FileEnumerator f2_non_recursive(
-      test_dir_.ToWStringHack(), false, file_util::FileEnumerator::DIRECTORIES);
+      test_dir_, false, file_util::FileEnumerator::DIRECTORIES);
   FindResultCollector c2_non_recursive(f2_non_recursive);
   EXPECT_TRUE(c2_non_recursive.HasFile(dir1));
   EXPECT_TRUE(c2_non_recursive.HasFile(dir2));
   EXPECT_EQ(c2_non_recursive.size(), 2);
 
   // Enumerate files and directories.
-  file_util::FileEnumerator f3(test_dir_.ToWStringHack(), true,
+  file_util::FileEnumerator f3(test_dir_, true,
       file_util::FileEnumerator::FILES_AND_DIRECTORIES);
   FindResultCollector c3(f3);
   EXPECT_TRUE(c3.HasFile(dir1));
   EXPECT_TRUE(c3.HasFile(dir2));
   EXPECT_TRUE(c3.HasFile(file1));
   EXPECT_TRUE(c3.HasFile(file2_abs));
   EXPECT_TRUE(c3.HasFile(dir2file));
   EXPECT_TRUE(c3.HasFile(dir2inner));
   EXPECT_TRUE(c3.HasFile(dir2innerfile));
   EXPECT_EQ(c3.size(), 7);
 
   // Non-recursive operation.
-  file_util::FileEnumerator f4(test_dir_.ToWStringHack(), false,
+  file_util::FileEnumerator f4(test_dir_, false,
       file_util::FileEnumerator::FILES_AND_DIRECTORIES);
   FindResultCollector c4(f4);
   EXPECT_TRUE(c4.HasFile(dir2));
   EXPECT_TRUE(c4.HasFile(dir2));
   EXPECT_TRUE(c4.HasFile(file1));
   EXPECT_TRUE(c4.HasFile(file2_abs));
   EXPECT_EQ(c4.size(), 4);
 
   // Enumerate with a pattern.
-  file_util::FileEnumerator f5(test_dir_.ToWStringHack(), true,
-      file_util::FileEnumerator::FILES_AND_DIRECTORIES, L"dir*");
+  file_util::FileEnumerator f5(test_dir_, true,
+      file_util::FileEnumerator::FILES_AND_DIRECTORIES,
+      FILE_PATH_LITERAL("dir*"));
   FindResultCollector c5(f5);
   EXPECT_TRUE(c5.HasFile(dir1));
   EXPECT_TRUE(c5.HasFile(dir2));
   EXPECT_TRUE(c5.HasFile(dir2file));
   EXPECT_TRUE(c5.HasFile(dir2inner));
   EXPECT_TRUE(c5.HasFile(dir2innerfile));
   EXPECT_EQ(c5.size(), 5);
 
   // Make sure the destructor closes the find handle while in the middle of a
   // query to allow TearDown to delete the directory.
-  file_util::FileEnumerator f6(test_dir_.ToWStringHack(), true,
+  file_util::FileEnumerator f6(test_dir_, true,
       file_util::FileEnumerator::FILES_AND_DIRECTORIES);
-  EXPECT_FALSE(f6.Next().empty());  // Should have found something
-                                    // (we don't care what).
+  EXPECT_FALSE(f6.Next().value().empty());  // Should have found something
+                                            // (we don't care what).
 }
 
 
 void PathComponents(const std::wstring& path,
                     std::vector<std::wstring>* components) {
   DCHECK(components != NULL);
   if (components == NULL)
     return;
   std::wstring::size_type start = 0;
   std::wstring::size_type end = path.find('/', start);
@@ skipping 35 matching lines @@
     for (size_t j = 0; j < comps.size(); ++j) {
       result.append(comps[j]);
       if (j < comps.size() - 1)
         result.append(FILE_PATH_LITERAL("|"), 1);
     }
     EXPECT_EQ(kPathComponents[i].result, result);
   }
 }
 
 }  // namespace