drive: Remove FakeCacheMetadata

chrome/browser/chromeos/drive/file_cache_metadata.cc

Index: chrome/browser/chromeos/drive/file_cache_metadata.cc
diff --git a/chrome/browser/chromeos/drive/file_cache_metadata.cc b/chrome/browser/chromeos/drive/file_cache_metadata.cc
index 46ac4fa87758001b4c455477840fd7bb85bc882d..6f89d3b103788d6615b452398e31d868c5140313 100644
--- a/chrome/browser/chromeos/drive/file_cache_metadata.cc
+++ b/chrome/browser/chromeos/drive/file_cache_metadata.cc
@@ -18,6 +18,8 @@ namespace internal {
 
 namespace {
 
+typedef std::map<std::string, FileCacheEntry> CacheMap;
+
 enum DBOpenStatus {
   DB_OPEN_SUCCESS,
   DB_OPEN_FAILURE_CORRUPTION,
@@ -33,11 +35,10 @@ typedef std::map<std::string, base::FilePath> ResourceIdToFilePathMap;
 //
 // The resource IDs and file paths of discovered files are collected as a
 // ResourceIdToFilePathMap, if these are processed properly.
-void ScanCacheDirectory(
-    const std::vector<base::FilePath>& cache_paths,
-    FileCache::CacheSubDirectoryType sub_dir_type,
-    FileCacheMetadata::CacheMap* cache_map,
-    ResourceIdToFilePathMap* processed_file_map) {
+void ScanCacheDirectory(const std::vector<base::FilePath>& cache_paths,
+                        FileCache::CacheSubDirectoryType sub_dir_type,
+                        CacheMap* cache_map,
+                        ResourceIdToFilePathMap* processed_file_map) {
   DCHECK(cache_map);
   DCHECK(processed_file_map);
 
@@ -90,7 +91,7 @@ void ScanCacheDirectory(
 }
 
 void ScanCachePaths(const std::vector<base::FilePath>& cache_paths,
-                    FileCacheMetadata::CacheMap* cache_map) {
+                    CacheMap* cache_map) {
   DVLOG(1) << "Scanning directories";
 
   // Scan cache persistent and tmp directories to enumerate all files and create
@@ -114,8 +115,7 @@ void ScanCachePaths(const std::vector<base::FilePath>& cache_paths,
     const std::string& resource_id = iter->first;
     const base::FilePath& file_path = iter->second;
 
-    FileCacheMetadata::CacheMap::iterator cache_map_iter =
-        cache_map->find(resource_id);
+    CacheMap::iterator cache_map_iter = cache_map->find(resource_id);
     if (cache_map_iter != cache_map->end()) {
       FileCacheEntry* cache_entry = &cache_map_iter->second;
       const bool is_dirty = cache_entry->is_dirty();
@@ -136,9 +136,8 @@ void ScanCachePaths(const std::vector<base::FilePath>& cache_paths,
 
 // Returns true if |md5| matches the one in |cache_entry| with some
 // exceptions. See the function definition for details.
-bool CheckIfMd5Matches(
-    const std::string& md5,
-    const FileCacheEntry& cache_entry) {
+bool CheckIfMd5Matches(const std::string& md5,
+                       const FileCacheEntry& cache_entry) {
   if (cache_entry.is_dirty()) {
     // If the entry is dirty, its MD5 may have been replaced by "local"
     // during cache initialization, so we don't compare MD5.
@@ -159,171 +158,28 @@ bool CheckIfMd5Matches(
   return false;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// FileCacheMetadata implementation with std::map.
-// Used for testing.
-
-class FakeCacheMetadata : public FileCacheMetadata {
- public:
-  explicit FakeCacheMetadata(
-      base::SequencedTaskRunner* blocking_task_runner);
-
- private:
-  virtual ~FakeCacheMetadata();
-
-  // FileCacheMetadata overrides:
-  virtual bool Initialize(
-      const std::vector<base::FilePath>& cache_paths) OVERRIDE;
-  virtual void AddOrUpdateCacheEntry(
-      const std::string& resource_id,
-      const FileCacheEntry& cache_entry) OVERRIDE;
-  virtual void RemoveCacheEntry(const std::string& resource_id) OVERRIDE;
-  virtual bool GetCacheEntry(const std::string& resource_id,
-                             const std::string& md5,
-                             FileCacheEntry* cache_entry) OVERRIDE;
-  virtual void RemoveTemporaryFiles() OVERRIDE;
-  virtual void Iterate(const CacheIterateCallback& callback) OVERRIDE;
-
-  CacheMap cache_map_;
-
-  DISALLOW_COPY_AND_ASSIGN(FakeCacheMetadata);
-};
-
-FakeCacheMetadata::FakeCacheMetadata(
-    base::SequencedTaskRunner* blocking_task_runner)
-    : FileCacheMetadata(blocking_task_runner) {
-  AssertOnSequencedWorkerPool();
-}
-
-FakeCacheMetadata::~FakeCacheMetadata() {
-  AssertOnSequencedWorkerPool();
-}
-
-bool FakeCacheMetadata::Initialize(
-    const std::vector<base::FilePath>& cache_paths) {
-  AssertOnSequencedWorkerPool();
-
-  ScanCachePaths(cache_paths, &cache_map_);
-  return true;
-}
-
-void FakeCacheMetadata::AddOrUpdateCacheEntry(
-    const std::string& resource_id,
-    const FileCacheEntry& cache_entry) {
-  AssertOnSequencedWorkerPool();
-
-  CacheMap::iterator iter = cache_map_.find(resource_id);
-  if (iter == cache_map_.end()) {  // New resource, create new entry.
-    cache_map_.insert(std::make_pair(resource_id, cache_entry));
-  } else {  // Resource exists.
-    cache_map_[resource_id] = cache_entry;
-  }
-}
-
-void FakeCacheMetadata::RemoveCacheEntry(const std::string& resource_id) {
-  AssertOnSequencedWorkerPool();
-
-  CacheMap::iterator iter = cache_map_.find(resource_id);
-  if (iter != cache_map_.end()) {
-    // Delete the FileCacheEntry and remove it from the map.
-    cache_map_.erase(iter);
-  }
-}
-
-bool FakeCacheMetadata::GetCacheEntry(const std::string& resource_id,
-                                      const std::string& md5,
-                                      FileCacheEntry* entry) {
-  DCHECK(entry);
-  AssertOnSequencedWorkerPool();
-
-  CacheMap::iterator iter = cache_map_.find(resource_id);
-  if (iter == cache_map_.end()) {
-    DVLOG(1) << "Can't find " << resource_id << " in cache map";
-    return false;
-  }
-
-  const FileCacheEntry& cache_entry = iter->second;
-
-  if (!CheckIfMd5Matches(md5, cache_entry)) {
-    return false;
-  }
-
-  *entry = cache_entry;
-  return true;
-}
-
-void FakeCacheMetadata::RemoveTemporaryFiles() {
-  AssertOnSequencedWorkerPool();
-
-  CacheMap::iterator iter = cache_map_.begin();
-  while (iter != cache_map_.end()) {
-    if (!iter->second.is_persistent()) {
-      // Post-increment the iterator to avoid iterator invalidation.
-      cache_map_.erase(iter++);
-    } else {
-      ++iter;
-    }
-  }
-}
-
-void FakeCacheMetadata::Iterate(const CacheIterateCallback& callback) {
-  AssertOnSequencedWorkerPool();
-
-  for (CacheMap::const_iterator iter = cache_map_.begin();
-       iter != cache_map_.end(); ++iter) {
-    callback.Run(iter->first, iter->second);
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// FileCacheMetadata implementation with level::db.
-
-class FileCacheMetadataDB : public FileCacheMetadata {
- public:
-  explicit FileCacheMetadataDB(
-      base::SequencedTaskRunner* blocking_task_runner);
-
- private:
-  virtual ~FileCacheMetadataDB();
-
-  // FileCacheMetadata overrides:
-  virtual bool Initialize(
-      const std::vector<base::FilePath>& cache_paths) OVERRIDE;
-  virtual void AddOrUpdateCacheEntry(
-      const std::string& resource_id,
-      const FileCacheEntry& cache_entry) OVERRIDE;
-  virtual void RemoveCacheEntry(const std::string& resource_id) OVERRIDE;
-  virtual bool GetCacheEntry(const std::string& resource_id,
-                             const std::string& md5,
-                             FileCacheEntry* cache_entry) OVERRIDE;
-  virtual void RemoveTemporaryFiles() OVERRIDE;
-  virtual void Iterate(const CacheIterateCallback& callback) OVERRIDE;
-
-  // Helper function to insert |cache_map| entries into the database.
-  void InsertMapIntoDB(const CacheMap& cache_map);
-
-  scoped_ptr<leveldb::DB> level_db_;
+}  // namespace
 
-  DISALLOW_COPY_AND_ASSIGN(FileCacheMetadataDB);
-};
+// static
+const base::FilePath::CharType* FileCacheMetadata::kCacheMetadataDBPath =
+    FILE_PATH_LITERAL("cache_metadata.db");
 
-FileCacheMetadataDB::FileCacheMetadataDB(
+FileCacheMetadata::FileCacheMetadata(
     base::SequencedTaskRunner* blocking_task_runner)
-    : FileCacheMetadata(blocking_task_runner) {
+    : blocking_task_runner_(blocking_task_runner) {
   AssertOnSequencedWorkerPool();
 }
 
-FileCacheMetadataDB::~FileCacheMetadataDB() {
+FileCacheMetadata::~FileCacheMetadata() {
   AssertOnSequencedWorkerPool();
 }
 
-bool FileCacheMetadataDB::Initialize(
+bool FileCacheMetadata::Initialize(
     const std::vector<base::FilePath>& cache_paths) {
   AssertOnSequencedWorkerPool();
 
   const base::FilePath db_path =
-      cache_paths[FileCache::CACHE_TYPE_META].Append(
-          kCacheMetadataDBPath);
+      cache_paths[FileCache::CACHE_TYPE_META].Append(kCacheMetadataDBPath);
   DVLOG(1) << "db path=" << db_path.value();
 
   bool scan_cache = !file_util::PathExists(db_path);
@@ -365,21 +221,16 @@ bool FileCacheMetadataDB::Initialize(
   if (scan_cache) {
     CacheMap cache_map;
     ScanCachePaths(cache_paths, &cache_map);
-    InsertMapIntoDB(cache_map);
+    for (CacheMap::const_iterator it = cache_map.begin();
+         it != cache_map.end(); ++it) {
+      AddOrUpdateCacheEntry(it->first, it->second);
+    }
   }
 
   return true;
 }
 
-void FileCacheMetadataDB::InsertMapIntoDB(const CacheMap& cache_map) {
-  DVLOG(1) << "InsertMapIntoDB";
-  for (CacheMap::const_iterator it = cache_map.begin();
-       it != cache_map.end(); ++it) {
-    AddOrUpdateCacheEntry(it->first, it->second);
-  }
-}
-
-void FileCacheMetadataDB::AddOrUpdateCacheEntry(
+void FileCacheMetadata::AddOrUpdateCacheEntry(
     const std::string& resource_id,
     const FileCacheEntry& cache_entry) {
   AssertOnSequencedWorkerPool();
@@ -393,16 +244,16 @@ void FileCacheMetadataDB::AddOrUpdateCacheEntry(
                    leveldb::Slice(serialized));
 }
 
-void FileCacheMetadataDB::RemoveCacheEntry(const std::string& resource_id) {
+void FileCacheMetadata::RemoveCacheEntry(const std::string& resource_id) {
   AssertOnSequencedWorkerPool();
 
   DVLOG(1) << "RemoveCacheEntry, resource_id=" << resource_id;
   level_db_->Delete(leveldb::WriteOptions(), leveldb::Slice(resource_id));
 }
 
-bool FileCacheMetadataDB::GetCacheEntry(const std::string& resource_id,
-                                        const std::string& md5,
-                                        FileCacheEntry* entry) {
+bool FileCacheMetadata::GetCacheEntry(const std::string& resource_id,
+                                      const std::string& md5,
+                                      FileCacheEntry* entry) {
   DCHECK(entry);
   AssertOnSequencedWorkerPool();
 
@@ -430,7 +281,7 @@ bool FileCacheMetadataDB::GetCacheEntry(const std::string& resource_id,
   return true;
 }
 
-void FileCacheMetadataDB::RemoveTemporaryFiles() {
+void FileCacheMetadata::RemoveTemporaryFiles() {
   AssertOnSequencedWorkerPool();
 
   scoped_ptr<leveldb::Iterator> iter(level_db_->NewIterator(
@@ -444,7 +295,7 @@ void FileCacheMetadataDB::RemoveTemporaryFiles() {
   }
 }
 
-void FileCacheMetadataDB::Iterate(const CacheIterateCallback& callback) {
+void FileCacheMetadata::Iterate(const CacheIterateCallback& callback) {
   AssertOnSequencedWorkerPool();
 
   scoped_ptr<leveldb::Iterator> iter(level_db_->NewIterator(
@@ -458,38 +309,6 @@ void FileCacheMetadataDB::Iterate(const CacheIterateCallback& callback) {
   }
 }
 
-}  // namespace
-
-// static
-const base::FilePath::CharType* FileCacheMetadata::kCacheMetadataDBPath =
-    FILE_PATH_LITERAL("cache_metadata.db");
-
-
-FileCacheMetadata::FileCacheMetadata(
-    base::SequencedTaskRunner* blocking_task_runner)
-    : blocking_task_runner_(blocking_task_runner) {
-  AssertOnSequencedWorkerPool();
-}
-
-FileCacheMetadata::~FileCacheMetadata() {
-  AssertOnSequencedWorkerPool();
-}
-
-// static
-scoped_ptr<FileCacheMetadata> FileCacheMetadata::CreateCacheMetadata(
-    base::SequencedTaskRunner* blocking_task_runner) {
-  return scoped_ptr<FileCacheMetadata>(
-      new FileCacheMetadataDB(blocking_task_runner));
-}
-
-// static
-scoped_ptr<FileCacheMetadata>
-FileCacheMetadata::CreateCacheMetadataForTesting(
-    base::SequencedTaskRunner* blocking_task_runner) {
-  return scoped_ptr<FileCacheMetadata>(
-      new FakeCacheMetadata(blocking_task_runner));
-}
-
 void FileCacheMetadata::AssertOnSequencedWorkerPool() {
   DCHECK(!blocking_task_runner_ ||
          blocking_task_runner_->RunsTasksOnCurrentThread());