Move FileEnumerator to its own file, do some refactoring.

base/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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
 #include <tchar.h>
 #include <winioctl.h>
 #endif
 
 #include <algorithm>
 #include <fstream>
 #include <set>
 
 #include "base/base_paths.h"
 #include "base/file_util.h"
+#include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/test/test_file_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif
 
 // This macro helps avoid wrapped lines in the test structs.
 #define FPL(x) FILE_PATH_LITERAL(x)
 
+using base::FileEnumerator;
 using base::FilePath;
 
 namespace {
 
 // To test that file_util::Normalize FilePath() deals with NTFS reparse points
 // correctly, we need functions to create and delete reparse points.
 #if defined(OS_WIN)
 typedef struct _REPARSE_DATA_BUFFER {
   ULONG  ReparseTag;
   USHORT  ReparseDataLength;
@@ skipping 80 matching lines @@
   ASSERT_TRUE(file_util::GetPosixFilePermissions(path, &mode));
   mode |= mode_bits_to_set;
   mode &= ~mode_bits_to_clear;
   ASSERT_TRUE(file_util::SetPosixFilePermissions(path, mode));
 }
 #endif  // defined(OS_POSIX)
 
 const wchar_t bogus_content[] = L"I'm cannon fodder.";
 
 const int FILES_AND_DIRECTORIES =
-    file_util::FileEnumerator::FILES | file_util::FileEnumerator::DIRECTORIES;
+    FileEnumerator::FILES | FileEnumerator::DIRECTORIES;
 
 // file_util winds up using autoreleased objects on the Mac, so this needs
 // to be a PlatformTest
 class FileUtilTest : public PlatformTest {
  protected:
   virtual void SetUp() OVERRIDE {
     PlatformTest::SetUp();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
   base::ScopedTempDir temp_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:
-  explicit FindResultCollector(file_util::FileEnumerator& enumerator) {
+  explicit FindResultCollector(FileEnumerator& enumerator) {
     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);
     }
@@ skipping 744 matching lines @@
   EXPECT_TRUE(file_util::GetPosixFilePermissions(subdir_path, &mode));
   EXPECT_EQ(file_util::FILE_PERMISSION_USER_MASK,
             mode & file_util::FILE_PERMISSION_USER_MASK);
 
   // Get rid of the permissions from the directory.
   EXPECT_TRUE(file_util::SetPosixFilePermissions(subdir_path, 0u));
   EXPECT_TRUE(file_util::GetPosixFilePermissions(subdir_path, &mode));
   EXPECT_FALSE(mode & file_util::FILE_PERMISSION_USER_MASK);
 
   // Make sure the file in the directory can't be enumerated.
-  file_util::FileEnumerator f1(subdir_path, true,
-                               file_util::FileEnumerator::FILES);
+  FileEnumerator f1(subdir_path, true, FileEnumerator::FILES);
   EXPECT_TRUE(file_util::PathExists(subdir_path));
   FindResultCollector c1(f1);
   EXPECT_EQ(c1.size(), 0);
   EXPECT_FALSE(file_util::GetPosixFilePermissions(file_name, &mode));
 
   // Give the permissions to the directory.
   EXPECT_TRUE(file_util::SetPosixFilePermissions(
       subdir_path,
       file_util::FILE_PERMISSION_USER_MASK));
   EXPECT_TRUE(file_util::GetPosixFilePermissions(subdir_path, &mode));
   EXPECT_EQ(file_util::FILE_PERMISSION_USER_MASK,
             mode & file_util::FILE_PERMISSION_USER_MASK);
 
   // Make sure the file in the directory can be enumerated.
-  file_util::FileEnumerator f2(subdir_path, true,
-                               file_util::FileEnumerator::FILES);
+  FileEnumerator f2(subdir_path, true, FileEnumerator::FILES);
   FindResultCollector c2(f2);
   EXPECT_TRUE(c2.HasFile(file_name));
   EXPECT_EQ(c2.size(), 1);
 
   // Delete the file.
   EXPECT_TRUE(file_util::Delete(subdir_path, true));
   EXPECT_FALSE(file_util::PathExists(subdir_path));
 }
 
 #endif  // defined(OS_POSIX)
@@ skipping 869 matching lines @@
   CreateTextFile(test_path, L"test file");
   EXPECT_TRUE(file_util::PathExists(test_path));
   EXPECT_FALSE(file_util::DirectoryExists(test_path));
   EXPECT_TRUE(file_util::Delete(test_path, false));
 
   EXPECT_TRUE(file_util::Delete(test_root, true));
 }
 
 TEST_F(FileUtilTest, FileEnumeratorTest) {
   // Test an empty directory.
-  file_util::FileEnumerator f0(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
+  FileEnumerator f0(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
   EXPECT_EQ(f0.Next().value(), FILE_PATH_LITERAL(""));
   EXPECT_EQ(f0.Next().value(), FILE_PATH_LITERAL(""));
 
   // Test an empty directory, non-recursively, including "..".
-  file_util::FileEnumerator f0_dotdot(temp_dir_.path(), false,
-      FILES_AND_DIRECTORIES | file_util::FileEnumerator::INCLUDE_DOT_DOT);
+  FileEnumerator f0_dotdot(temp_dir_.path(), false,
+      FILES_AND_DIRECTORIES | FileEnumerator::INCLUDE_DOT_DOT);
   EXPECT_EQ(temp_dir_.path().Append(FILE_PATH_LITERAL("..")).value(),
             f0_dotdot.Next().value());
   EXPECT_EQ(FILE_PATH_LITERAL(""),
             f0_dotdot.Next().value());
 
   // create the directories
   FilePath dir1 = temp_dir_.path().Append(FILE_PATH_LITERAL("dir1"));
   EXPECT_TRUE(file_util::CreateDirectory(dir1));
   FilePath dir2 = temp_dir_.path().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, std::wstring());
   FilePath dir2innerfile = dir2inner.Append(FILE_PATH_LITERAL("innerfile.txt"));
   CreateTextFile(dir2innerfile, std::wstring());
   FilePath file1 = temp_dir_.path().Append(FILE_PATH_LITERAL("file1.txt"));
   CreateTextFile(file1, std::wstring());
   FilePath file2_rel = dir2.Append(FilePath::kParentDirectory)
       .Append(FILE_PATH_LITERAL("file2.txt"));
   CreateTextFile(file2_rel, std::wstring());
   FilePath file2_abs = temp_dir_.path().Append(FILE_PATH_LITERAL("file2.txt"));
 
   // Only enumerate files.
-  file_util::FileEnumerator f1(temp_dir_.path(), true,
-                               file_util::FileEnumerator::FILES);
+  FileEnumerator f1(temp_dir_.path(), true, 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(temp_dir_.path(), true,
-                               file_util::FileEnumerator::DIRECTORIES);
+  FileEnumerator f2(temp_dir_.path(), true, 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(
-      temp_dir_.path(), false, file_util::FileEnumerator::DIRECTORIES);
+  FileEnumerator f2_non_recursive(
+      temp_dir_.path(), false, 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);
 
   // Only enumerate directories, non-recursively, including "..".
-  file_util::FileEnumerator f2_dotdot(temp_dir_.path(), false,
-      file_util::FileEnumerator::DIRECTORIES |
-      file_util::FileEnumerator::INCLUDE_DOT_DOT);
+  FileEnumerator f2_dotdot(temp_dir_.path(), false,
+                           FileEnumerator::DIRECTORIES |
+                           FileEnumerator::INCLUDE_DOT_DOT);
   FindResultCollector c2_dotdot(f2_dotdot);
   EXPECT_TRUE(c2_dotdot.HasFile(dir1));
   EXPECT_TRUE(c2_dotdot.HasFile(dir2));
   EXPECT_TRUE(c2_dotdot.HasFile(
       temp_dir_.path().Append(FILE_PATH_LITERAL(".."))));
   EXPECT_EQ(c2_dotdot.size(), 3);
 
   // Enumerate files and directories.
-  file_util::FileEnumerator f3(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
+  FileEnumerator f3(temp_dir_.path(), true, 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(temp_dir_.path(), false, FILES_AND_DIRECTORIES);
+  FileEnumerator f4(temp_dir_.path(), false, 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(temp_dir_.path(), true, FILES_AND_DIRECTORIES,
+  FileEnumerator f5(temp_dir_.path(), true, 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(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
+  FileEnumerator f6(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
   EXPECT_FALSE(f6.Next().value().empty());  // Should have found something
                                             // (we don't care what).
 }
 
 TEST_F(FileUtilTest, AppendToFile) {
   FilePath data_dir =
       temp_dir_.path().Append(FILE_PATH_LITERAL("FilePathTest"));
 
   // Create a fresh, empty copy of this directory.
   if (file_util::PathExists(data_dir)) {
@@ skipping 436 matching lines @@
       file_util::VerifyPathControlledByUser(
           base_dir_, text_file_, uid_, ok_gids_));
   EXPECT_TRUE(
       file_util::VerifyPathControlledByUser(
           sub_dir_, text_file_, uid_, ok_gids_));
 }
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace