Move FileEnumerator to its own file, do some refactoring.

chrome/browser/chromeos/drive/file_cache.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 "chrome/browser/chromeos/drive/file_cache.h"
 
 #include <vector>
 
 #include "base/file_util.h"
+#include "base/files/file_enumerator.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/file_cache_metadata.h"
 #include "chrome/browser/chromeos/drive/file_cache_observer.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/google_apis/task_util.h"
@@ skipping 34 matching lines @@
       file_util::FILE_PERMISSION_EXECUTE_BY_GROUP |
       file_util::FILE_PERMISSION_EXECUTE_BY_OTHERS);
 
   return true;
 }
 
 // Remove all files under the given directory, non-recursively.
 // Do not remove recursively as we don't want to touch <gcache>/tmp/downloads,
 // which is used for user initiated downloads like "Save As"
 void RemoveAllFiles(const base::FilePath& directory) {
-  using file_util::FileEnumerator;
-
-  FileEnumerator enumerator(directory, false /* recursive */,
-                            FileEnumerator::FILES);
+  base::FileEnumerator enumerator(directory, false /* recursive */,
+                                  base::FileEnumerator::FILES);
   for (base::FilePath file_path = enumerator.Next(); !file_path.empty();
        file_path = enumerator.Next()) {
     DVLOG(1) << "Removing " << file_path.value();
     if (!file_util::Delete(file_path, false /* recursive */))
       LOG(WARNING) << "Failed to delete " << file_path.value();
   }
 }
 
 // Moves the file.
 bool MoveFile(const base::FilePath& source_path,
@@ skipping 22 matching lines @@
 // Deletes all files that match |path_to_delete_pattern| except for
 // |path_to_keep| on blocking pool.
 // If |path_to_keep| is empty, all files in |path_to_delete_pattern| are
 // deleted.
 void DeleteFilesSelectively(const base::FilePath& path_to_delete_pattern,
                             const base::FilePath& path_to_keep) {
   // Enumerate all files in directory of |path_to_delete_pattern| that match
   // base name of |path_to_delete_pattern|.
   // If a file is not |path_to_keep|, delete it.
   bool success = true;
-  file_util::FileEnumerator enumerator(
+  base::FileEnumerator enumerator(
       path_to_delete_pattern.DirName(),
       false,  // not recursive
-      file_util::FileEnumerator::FILES,
+      base::FileEnumerator::FILES,
       path_to_delete_pattern.BaseName().value());
   for (base::FilePath current = enumerator.Next(); !current.empty();
        current = enumerator.Next()) {
     // If |path_to_keep| is not empty and same as current, don't delete it.
     if (!path_to_keep.empty() && current == path_to_keep)
       continue;
 
     success = file_util::Delete(current, false);
     if (!success)
       DVLOG(1) << "Error deleting " << current.value();
@@ skipping 982 matching lines @@
 }
 
 // static
 FileCache::CacheSubDirectoryType FileCache::GetSubDirectoryType(
     const FileCacheEntry& cache_entry) {
   return cache_entry.is_persistent() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
 }
 
 }  // namespace internal
 }  // namespace drive