Move FileEnumerator to its own file, do some refactoring.

base/file_util.h

 // 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.
 
 // This file contains utility functions for dealing with the local
 // filesystem.
 
 #ifndef BASE_FILE_UTIL_H_
 #define BASE_FILE_UTIL_H_
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #elif defined(OS_POSIX)
 #include <sys/stat.h>
 #include <unistd.h>
 #endif
 
 #include <stdio.h>
 
 #include <set>
-#include <stack>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
 #include "base/string16.h"
 
@@ skipping 82 matching lines @@
 BASE_EXPORT bool CopyFile(const base::FilePath& from_path,
                           const base::FilePath& to_path);
 
 // Same as CopyFile but allows paths with traversal components.
 // Use only with extreme care.
 BASE_EXPORT bool CopyFileUnsafe(const base::FilePath& from_path,
                                 const base::FilePath& to_path);
 
 // Copies the given path, and optionally all subdirectories and their contents
 // as well.
-// If there are files existing under to_path, always overwrite.
-// Returns true if successful, false otherwise.
-// Don't use wildcards on the names, it may stop working without notice.
+//
+// If there are files existing under to_path, always overwrite. Returns true
+// if successful, false otherwise. Wildcards on the names are not supported.
 //
 // If you only need to copy a file use CopyFile, it's faster.
 BASE_EXPORT bool CopyDirectory(const base::FilePath& from_path,
                                const base::FilePath& to_path,
                                bool recursive);
 
 // Returns true if the given path exists on the local filesystem,
 // false otherwise.
 BASE_EXPORT bool PathExists(const base::FilePath& path);
 
@@ skipping 282 matching lines @@
     if (x && *x >= 0) {
       if (HANDLE_EINTR(close(*x)) < 0)
         DPLOG(ERROR) << "close";
     }
   }
 };
 
 typedef scoped_ptr_malloc<int, ScopedFDClose> ScopedFD;
 #endif  // OS_POSIX
 
-// A class for enumerating the files in a provided path. The order of the
-// results is not guaranteed.
-//
-// DO NOT USE FROM THE MAIN THREAD of your application unless it is a test
-// program where latency does not matter. This class is blocking.
-class BASE_EXPORT FileEnumerator {
- public:
-#if defined(OS_WIN)
-  typedef WIN32_FIND_DATA FindInfo;
-#elif defined(OS_POSIX)
-  typedef struct {
-    struct stat stat;
-    std::string filename;
-  } FindInfo;
-#endif
-
-  enum FileType {
-    FILES                 = 1 << 0,
-    DIRECTORIES           = 1 << 1,
-    INCLUDE_DOT_DOT       = 1 << 2,
-#if defined(OS_POSIX)
-    SHOW_SYM_LINKS        = 1 << 4,
-#endif
-  };
-
-  // |root_path| is the starting directory to search for. It may or may not end
-  // in a slash.
-  //
-  // If |recursive| is true, this will enumerate all matches in any
-  // subdirectories matched as well. It does a breadth-first search, so all
-  // files in one directory will be returned before any files in a
-  // subdirectory.
-  //
-  // |file_type|, a bit mask of FileType, specifies whether the enumerator
-  // should match files, directories, or both.
-  //
-  // |pattern| is an optional pattern for which files to match. This
-  // works like shell globbing. For example, "*.txt" or "Foo???.doc".
-  // However, be careful in specifying patterns that aren't cross platform
-  // since the underlying code uses OS-specific matching routines.  In general,
-  // Windows matching is less featureful than others, so test there first.
-  // If unspecified, this will match all files.
-  // NOTE: the pattern only matches the contents of root_path, not files in
-  // recursive subdirectories.
-  // TODO(erikkay): Fix the pattern matching to work at all levels.
-  FileEnumerator(const base::FilePath& root_path,
-                 bool recursive,
-                 int file_type);
-  FileEnumerator(const base::FilePath& root_path,
-                 bool recursive,
-                 int file_type,
-                 const base::FilePath::StringType& pattern);
-  ~FileEnumerator();
-
-  // Returns an empty string if there are no more results.
-  base::FilePath Next();
-
-  // Write the file info into |info|.
-  void GetFindInfo(FindInfo* info);
-
-  // Looks inside a FindInfo and determines if it's a directory.
-  static bool IsDirectory(const FindInfo& info);
-
-  static base::FilePath GetFilename(const FindInfo& find_info);
-  static int64 GetFilesize(const FindInfo& find_info);
-  static base::Time GetLastModifiedTime(const FindInfo& find_info);
-
- private:
-  // Returns true if the given path should be skipped in enumeration.
-  bool ShouldSkip(const base::FilePath& path);
-
-
-#if defined(OS_WIN)
-  // True when find_data_ is valid.
-  bool has_find_data_;
-  WIN32_FIND_DATA find_data_;
-  HANDLE find_handle_;
-#elif defined(OS_POSIX)
-  struct DirectoryEntryInfo {
-    base::FilePath filename;
-    struct stat stat;
-  };
-
-  // Read the filenames in source into the vector of DirectoryEntryInfo's
-  static bool ReadDirectory(std::vector<DirectoryEntryInfo>* entries,
-                            const base::FilePath& source, bool show_links);
-
-  // The files in the current directory
-  std::vector<DirectoryEntryInfo> directory_entries_;
-
-  // The next entry to use from the directory_entries_ vector
-  size_t current_directory_entry_;
-#endif
-
-  base::FilePath root_path_;
-  bool recursive_;
-  int file_type_;
-  base::FilePath::StringType pattern_;  // Empty when we want to find
-                                        // everything.
-
-  // A stack that keeps track of which subdirectories we still need to
-  // enumerate in the breadth-first search.
-  std::stack<base::FilePath> pending_paths_;
-
-  DISALLOW_COPY_AND_ASSIGN(FileEnumerator);
-};
-
 #if defined(OS_LINUX)
 // Broad categories of file systems as returned by statfs() on Linux.
 enum FileSystemType {
   FILE_SYSTEM_UNKNOWN,  // statfs failed.
   FILE_SYSTEM_0,        // statfs.f_type == 0 means unknown, may indicate AFS.
   FILE_SYSTEM_ORDINARY,       // on-disk filesystem like ext2
   FILE_SYSTEM_NFS,
   FILE_SYSTEM_SMB,
   FILE_SYSTEM_CODA,
   FILE_SYSTEM_MEMORY,         // in-memory file system
   FILE_SYSTEM_CGROUP,         // cgroup control.
   FILE_SYSTEM_OTHER,          // any other value.
   FILE_SYSTEM_TYPE_COUNT
 };
 
 // Attempts determine the FileSystemType for |path|.
 // Returns false if |path| doesn't exist.
 BASE_EXPORT bool GetFileSystemType(const base::FilePath& path,
                                    FileSystemType* type);
 #endif
 
 }  // namespace file_util
 
 #endif  // BASE_FILE_UTIL_H_