Move FileEnumerator to its own file, do some refactoring.

net/disk_cache/simple/simple_index.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.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
+#include "base/files/file_enumerator.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/task_runner.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
 #include "base/time.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
@@ skipping 418 matching lines @@
 
   io_thread->PostTask(FROM_HERE,
                       base::Bind(completion_callback,
                                  base::Passed(&index_file_entries),
                                  force_index_flush));
 }
 
 // static
 scoped_ptr<SimpleIndex::EntrySet> SimpleIndex::RestoreFromDisk(
     const base::FilePath& index_filename) {
-  using file_util::FileEnumerator;
   LOG(INFO) << "Simple Cache Index is being restored from disk.";
 
   file_util::Delete(index_filename, /* recursive = */ false);
   scoped_ptr<EntrySet> index_file_entries(new 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 kFileSuffixLenght = std::string("_0").size();
   const base::FilePath::StringType file_pattern = FILE_PATH_LITERAL("*_[0-2]");
-  FileEnumerator enumerator(index_filename.DirName(),
-                            false /* recursive */,
-                            FileEnumerator::FILES,
-                            file_pattern);
+  base::FileEnumerator enumerator(index_filename.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_name(base_name.begin(), base_name.end());
     const std::string hash_key_string =
         hash_name.substr(0, hash_name.size() - kFileSuffixLenght);
     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: " << hash_name;
       // TODO(felipeg): Should we delete the invalid file here ?
       continue;
     }
 
-    FileEnumerator::FindInfo find_info = {};
-    enumerator.GetFindInfo(&find_info);
+    base::FileEnumerator::FileInfo find_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(find_info.stat().st_atime);
 #endif
     if (last_used_time.is_null())
-      last_used_time = FileEnumerator::GetLastModifiedTime(find_info);
+      last_used_time = find_info.GetLastModifiedTime();
 
-    int64 file_size = FileEnumerator::GetFilesize(find_info);
+    int64 file_size = find_info.GetSize();
     EntrySet::iterator it = index_file_entries->find(hash_key);
     if (it == index_file_entries->end()) {
       InsertInEntrySet(EntryMetadata(hash_key, 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();
@@ skipping 85 matching lines @@
   scoped_ptr<Pickle> pickle = SimpleIndexFile::Serialize(index_metadata,
                                                          entries_set_);
   cache_thread_->PostTask(FROM_HERE, base::Bind(
       &SimpleIndex::WriteToDiskInternal,
       index_filename_,
       base::Passed(&pickle),
       start));
 }
 
 }  // namespace disk_cache