Move FileEnumerator to its own file, do some refactoring.

chrome/common/extensions/extension_file_util.cc

 // Copyright (c) 2013 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/common/extensions/extension_file_util.h"
 
 #include <map>
 #include <vector>
 
 #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/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_constants.h"
@@ skipping 174 matching lines @@
     return NULL;
   }
 
   return static_cast<DictionaryValue*>(root.release());
 }
 
 std::vector<base::FilePath> FindPrivateKeyFiles(
     const base::FilePath& extension_dir) {
   std::vector<base::FilePath> result;
   // Pattern matching only works at the root level, so filter manually.
-  file_util::FileEnumerator traversal(extension_dir, /*recursive=*/true,
-                                      file_util::FileEnumerator::FILES);
+  base::FileEnumerator traversal(extension_dir, /*recursive=*/true,
+                                 base::FileEnumerator::FILES);
   for (base::FilePath current = traversal.Next(); !current.empty();
        current = traversal.Next()) {
     if (!current.MatchesExtension(chrome::kExtensionKeyFileExtension))
       continue;
 
     std::string key_contents;
     if (!file_util::ReadFileToString(current, &key_contents)) {
       // If we can't read the file, assume it's not a private key.
       continue;
     }
@@ skipping 107 matching lines @@
 }
 
 void GarbageCollectExtensions(
     const base::FilePath& install_directory,
     const std::multimap<std::string, base::FilePath>& extension_paths) {
   // Nothing to clean up if it doesn't exist.
   if (!file_util::DirectoryExists(install_directory))
     return;
 
   DVLOG(1) << "Garbage collecting extensions...";
-  file_util::FileEnumerator enumerator(install_directory,
-                                       false,  // Not recursive.
-                                       file_util::FileEnumerator::DIRECTORIES);
+  base::FileEnumerator enumerator(install_directory,
+                                  false,  // Not recursive.
+                                  base::FileEnumerator::DIRECTORIES);
   base::FilePath extension_path;
   for (extension_path = enumerator.Next(); !extension_path.value().empty();
        extension_path = enumerator.Next()) {
     std::string extension_id;
 
     base::FilePath basename = extension_path.BaseName();
     // Clean up temporary files left if Chrome crashed or quit in the middle
     // of an extension install.
     if (basename.value() == kTempDirectoryName) {
       file_util::Delete(extension_path, true);  // Recursive
@@ skipping 24 matching lines @@
     // move on. This can legitimately happen when an uninstall does not
     // complete, for example, when a plugin is in use at uninstall time.
     if (iter_pair.first == iter_pair.second) {
       DVLOG(1) << "Deleting unreferenced install for directory "
                << extension_path.LossyDisplayName() << ".";
       file_util::Delete(extension_path, true);  // Recursive.
       continue;
     }
 
     // Clean up old version directories.
-    file_util::FileEnumerator versions_enumerator(
+    base::FileEnumerator versions_enumerator(
         extension_path,
         false,  // Not recursive.
-        file_util::FileEnumerator::DIRECTORIES);
+        base::FileEnumerator::DIRECTORIES);
     for (base::FilePath version_dir = versions_enumerator.Next();
          !version_dir.value().empty();
          version_dir = versions_enumerator.Next()) {
       bool knownVersion = false;
       for (Iter it = iter_pair.first; it != iter_pair.second; ++it)
         if (version_dir.BaseName() == it->second.BaseName()) {
           knownVersion = true;
           break;
         }
       if (!knownVersion) {
@@ skipping 69 matching lines @@
     FILE_PATH_LITERAL("__MACOSX"),
   };
   CR_DEFINE_STATIC_LOCAL(
       std::set<base::FilePath::StringType>, reserved_underscore_names,
       (reserved_names, reserved_names + arraysize(reserved_names)));
 
   // Enumerate all files and directories in the extension root.
   // There is a problem when using pattern "_*" with FileEnumerator, so we have
   // to cheat with find_first_of and match all.
   const int kFilesAndDirectories =
-      file_util::FileEnumerator::DIRECTORIES | file_util::FileEnumerator::FILES;
-  file_util::FileEnumerator all_files(
-      extension_path, false, kFilesAndDirectories);
+      base::FileEnumerator::DIRECTORIES | base::FileEnumerator::FILES;
+  base::FileEnumerator all_files(extension_path, false, kFilesAndDirectories);
 
   base::FilePath file;
   while (!(file = all_files.Next()).empty()) {
     base::FilePath::StringType filename = file.BaseName().value();
     // Skip all that don't start with "_".
     if (filename.find_first_of(FILE_PATH_LITERAL("_")) != 0) continue;
     if (reserved_underscore_names.find(filename) ==
         reserved_underscore_names.end()) {
       *error = base::StringPrintf(
           "Cannot load extension with file or directory name %s. "
@@ skipping 87 matching lines @@
     return base::FilePath();
   }
   return temp_path;
 }
 
 void DeleteFile(const base::FilePath& path, bool recursive) {
   file_util::Delete(path, recursive);
 }
 
 }  // namespace extension_file_util