Move FileEnumerator to its own file, do some refactoring.

net/disk_cache/simple/simple_index_file.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 "net/disk_cache/simple/simple_index_file.h"
 
 #include "base/file_util.h"
+#include "base/files/file_enumerator.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_index.h"
 #include "net/disk_cache/simple/simple_synchronous_entry.h"
@@ skipping 290 matching lines @@
                             initialize_method, INITIALIZE_METHOD_MAX);
   response_thread->PostTask(FROM_HERE,
                             base::Bind(completion_callback,
                                        base::Passed(&index_file_entries),
                                        force_index_flush));
 }
 
 // static
 scoped_ptr<SimpleIndex::EntrySet> SimpleIndexFile::RestoreFromDisk(
     const base::FilePath& index_file_path) {
-  using file_util::FileEnumerator;
   LOG(INFO) << "Simple Cache Index is being restored from disk.";
 
   file_util::Delete(index_file_path, /* recursive = */ false);
   scoped_ptr<SimpleIndex::EntrySet> index_file_entries(
       new SimpleIndex::EntrySet());
 
   // TODO(felipeg,gavinp): Fix this once we have a one-file per entry format.
   COMPILE_ASSERT(kSimpleEntryFileCount == 3,
                  file_pattern_must_match_file_count);
 
   const int kFileSuffixLength = sizeof("_0") - 1;
   const base::FilePath::StringType file_pattern = FILE_PATH_LITERAL("*_[0-2]");
-  FileEnumerator enumerator(index_file_path.DirName(),
-                            false /* recursive */,
-                            FileEnumerator::FILES,
-                            file_pattern);
+  base::FileEnumerator enumerator(index_file_path.DirName(),
+                                  false /* recursive */,
+                                  base::FileEnumerator::FILES,
+                                  file_pattern);
   for (base::FilePath file_path = enumerator.Next(); !file_path.empty();
        file_path = enumerator.Next()) {
     const base::FilePath::StringType base_name = file_path.BaseName().value();
     // Converting to std::string is OK since we never use UTF8 wide chars in our
     // file names.
     const std::string hash_key_string(base_name.begin(),
                                       base_name.end() - kFileSuffixLength);
     uint64 hash_key = 0;
     if (!simple_util::GetEntryHashKeyFromHexString(
             hash_key_string, &hash_key)) {
       LOG(WARNING) << "Invalid Entry Hash Key filename while restoring "
                    << "Simple Index from disk: " << base_name;
       // TODO(felipeg): Should we delete the invalid file here ?
       continue;
     }
 
-    FileEnumerator::FindInfo find_info = {};
-    enumerator.GetFindInfo(&find_info);
+    base::FileEnumerator::FileInfo info = enumerator.GetInfo();
     base::Time last_used_time;
 #if defined(OS_POSIX)
     // For POSIX systems, a last access time is available. However, it's not
     // guaranteed to be more accurate than mtime. It is no worse though.
-    last_used_time = base::Time::FromTimeT(find_info.stat.st_atime);
+    last_used_time = base::Time::FromTimeT(info.stat().st_atime);
 #endif
     if (last_used_time.is_null())
-      last_used_time = FileEnumerator::GetLastModifiedTime(find_info);
+      last_used_time = info.GetLastModifiedTime();
 
-    int64 file_size = FileEnumerator::GetFilesize(find_info);
+    int64 file_size = info.GetSize();
     SimpleIndex::EntrySet::iterator it = index_file_entries->find(hash_key);
     if (it == index_file_entries->end()) {
       SimpleIndex::InsertInEntrySet(
           hash_key,
           EntryMetadata(last_used_time, file_size),
           index_file_entries.get());
     } else {
       // Summing up the total size of the entry through all the *_[0-2] files
       it->second.SetEntrySize(it->second.GetEntrySize() + file_size);
     }
   }
   return index_file_entries.Pass();
 }
 
 }  // namespace disk_cache