Move file enumeration to filepaths.

base/file_util_win.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 "base/file_util.h"
 
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
 #include <time.h>
@@ skipping 353 matching lines @@
     return false;
   }
 
   HRESULT result = i_persist_file->Save(destination, TRUE);
   i_persist_file->Release();
   i_shell_link->Release();
   return SUCCEEDED(result);
 }
 
 bool IsDirectoryEmpty(const std::wstring& dir_path) {
-  FileEnumerator files(dir_path, false, FileEnumerator::FILES_AND_DIRECTORIES);
-  if (files.Next().empty())
+  FileEnumerator files(FilePath(dir_path),
+                       false, FileEnumerator::FILES_AND_DIRECTORIES);
+  if (files.Next().value().empty())
     return true;
   return false;
 }
 
 bool GetTempDir(FilePath* path) {
   wchar_t temp_path[MAX_PATH + 1];
   DWORD path_len = ::GetTempPath(MAX_PATH, temp_path);
   if (path_len >= MAX_PATH || path_len <= 0)
     return false;
   // TODO(evanm): the old behavior of this function was to always strip the
@@ skipping 203 matching lines @@
 
 // Sets the current working directory for the process.
 bool SetCurrentDirectory(const FilePath& directory) {
   BOOL ret = ::SetCurrentDirectory(directory.value().c_str());
   return ret != 0;
 }
 
 ///////////////////////////////////////////////
 
 
-FileEnumerator::FileEnumerator(const std::wstring& root_path,
+FileEnumerator::FileEnumerator(const FilePath& root_path,
                                bool recursive,
                                FileEnumerator::FILE_TYPE file_type)
     : recursive_(recursive),
       file_type_(file_type),
       is_in_find_op_(false),
       find_handle_(INVALID_HANDLE_VALUE) {
   pending_paths_.push(root_path);
 }
 
-FileEnumerator::FileEnumerator(const std::wstring& root_path,
+FileEnumerator::FileEnumerator(const FilePath& root_path,
                                bool recursive,
                                FileEnumerator::FILE_TYPE file_type,
-                               const std::wstring& pattern)
+                               const FilePath::StringType& pattern)
     : recursive_(recursive),
       file_type_(file_type),
       is_in_find_op_(false),
       pattern_(pattern),
       find_handle_(INVALID_HANDLE_VALUE) {
   pending_paths_.push(root_path);
 }
 
 FileEnumerator::~FileEnumerator() {
   if (find_handle_ != INVALID_HANDLE_VALUE)
     FindClose(find_handle_);
 }
 
 void FileEnumerator::GetFindInfo(FindInfo* info) {
   DCHECK(info);
 
   if (!is_in_find_op_)
     return;
 
   memcpy(info, &find_data_, sizeof(*info));
 }
 
-std::wstring FileEnumerator::Next() {
+FilePath FileEnumerator::Next() {
   if (!is_in_find_op_) {
     if (pending_paths_.empty())
-      return std::wstring();
+      return FilePath();
 
     // The last find FindFirstFile operation is done, prepare a new one.
-    // root_path_ must have the trailing directory character.
     root_path_ = pending_paths_.top();
-    file_util::AppendToPath(&root_path_, std::wstring());
     pending_paths_.pop();
 
     // Start a new find operation.
-    std::wstring src(root_path_);
+    FilePath src = root_path_;
 
-    if (pattern_.empty())
-      file_util::AppendToPath(&src, L"*");  // No pattern = match everything.
+    if (pattern_.value().empty())
+      src = src.Append(L"*");  // No pattern = match everything.
     else
-      file_util::AppendToPath(&src, pattern_);
+      src = src.Append(pattern_);
 
-    find_handle_ = FindFirstFile(src.c_str(), &find_data_);
+    find_handle_ = FindFirstFile(src.value().c_str(), &find_data_);
     is_in_find_op_ = true;
 
   } else {
     // Search for the next file/directory.
     if (!FindNextFile(find_handle_, &find_data_)) {
       FindClose(find_handle_);
       find_handle_ = INVALID_HANDLE_VALUE;
     }
   }
 
   if (INVALID_HANDLE_VALUE == find_handle_) {
     is_in_find_op_ = false;
 
     // This is reached when we have finished a directory and are advancing to
     // the next one in the queue. We applied the pattern (if any) to the files
     // in the root search directory, but for those directories which were
     // matched, we want to enumerate all files inside them. This will happen
     // when the handle is empty.
-    pattern_.clear();
+    pattern_ = FilePath();
 
     return Next();
   }
 
-  std::wstring cur_file(find_data_.cFileName);
+  FilePath cur_file(find_data_.cFileName);
   // Skip over . and ..
-  if (L"." == cur_file || L".." == cur_file)
+  if (L"." == cur_file.value() || L".." == cur_file.value())
     return Next();
 
   // Construct the absolute filename.
-  cur_file.insert(0, root_path_);
+  cur_file = root_path_.Append(cur_file);
 
   if (find_data_.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
     if (recursive_) {
       // If |cur_file| is a directory, and we are doing recursive searching, add
       // it to pending_paths_ so we scan it after we finish scanning this
       // directory.
       pending_paths_.push(cur_file);
     }
     return (file_type_ & FileEnumerator::DIRECTORIES) ? cur_file : Next();
   }
@@ skipping 11 matching lines @@
 void PathComponents(const std::wstring& path,
                     std::vector<std::wstring>* components) {
   PathComponents(FilePath(path), components);
 }
 void ReplaceExtension(std::wstring* file_name, const std::wstring& extension) {
   FilePath path(*file_name);
   ReplaceExtension(&path, extension);
   file_name->assign(path.value());
 }
 }  // namespace file_util