drive: Remove FakeCacheMetadata

chrome/browser/chromeos/drive/file_cache_metadata_unittest.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_metadata.h"
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/file_cache.h"
@@ skipping 18 matching lines @@
     persistent_directory_ = cache_paths_[FileCache::CACHE_TYPE_PERSISTENT];
     tmp_directory_ = cache_paths_[FileCache::CACHE_TYPE_TMP];
   }
 
   virtual void TearDown() OVERRIDE {
     metadata_.reset();
   }
 
   // Sets up the FileCacheMetadata object.
   void SetUpCacheMetadata() {
-    metadata_ = FileCacheMetadata::CreateCacheMetadata(NULL);
+    metadata_.reset(new FileCacheMetadata(NULL));
     ASSERT_TRUE(metadata_->Initialize(cache_paths_));
   }
 
   // Sets up the cache directories with various files.
   // Should be called before SetUpCacheMetadata().
   void SetUpCacheWithVariousFiles() {
     // Create some files in persistent directory.
     //
     CreateFile(persistent_directory_.AppendASCII("id_foo.md5foo"));
     CreateFile(persistent_directory_.AppendASCII("id_bar.local"));
 
     // Create some files in tmp directory.
     //
     CreateFile(tmp_directory_.AppendASCII("id_qux.md5qux"));
     // "id_quux" is invalid as we shouldn't have a dirty file in "tmp".
     CreateFile(tmp_directory_.AppendASCII("id_quux.local"));
   }
 
   // Create a file at |file_path|.
   void CreateFile(const base::FilePath& file_path) {
     const std::string kFoo = "foo";
     ASSERT_TRUE(google_apis::test_util::WriteStringToFile(file_path, kFoo))
         << ": " << file_path.value();
   }
 
  protected:
-  // Helper function to insert an item with key |resource_id| into |cache_map|.
-  // |md5| and |cache_state| are used to create the value FileCacheEntry.
-  void InsertIntoMap(FileCacheMetadata::CacheMap* cache_map,
-                     const std::string& resource_id,
-                     const FileCacheEntry& cache_entry) {
-    cache_map->insert(std::make_pair(
-        resource_id, cache_entry));
-  }
-
-  // Adds all entries in |cache_map| to the metadata storage.
-  void AddAllMapEntries(const FileCacheMetadata::CacheMap& cache_map) {
-    for (FileCacheMetadata::CacheMap::const_iterator iter = cache_map.begin();
-         iter != cache_map.end(); ++iter) {
-      metadata_->AddOrUpdateCacheEntry(iter->first, iter->second);
-    }
-  }
-
   base::ScopedTempDir temp_dir_;
   scoped_ptr<FileCacheMetadata> metadata_;
   std::vector<base::FilePath> cache_paths_;
   base::FilePath persistent_directory_;
   base::FilePath tmp_directory_;
 };
 
 // Test all the methods of FileCacheMetadata except for
 // RemoveTemporaryFiles.
 TEST_F(FileCacheMetadataTest, CacheTest) {
@@ skipping 153 matching lines @@
   EXPECT_TRUE(PathExists(tmp_directory_.AppendASCII("id_qux.md5qux")));
 
   // "id_quux" should be removed during cache initialization.
   EXPECT_FALSE(metadata_->GetCacheEntry("id_quux", "md5qux", &cache_entry));
 }
 
 // Test FileCacheMetadata::RemoveTemporaryFiles.
 TEST_F(FileCacheMetadataTest, RemoveTemporaryFiles) {
   SetUpCacheMetadata();
 
-  FileCacheMetadata::CacheMap cache_map;
   {
     FileCacheEntry cache_entry;
     cache_entry.set_md5("<md5>");
     cache_entry.set_is_present(true);
-    InsertIntoMap(&cache_map, "<resource_id_1>", cache_entry);
+    metadata_->AddOrUpdateCacheEntry("<resource_id_1>", cache_entry);
   }
   {
     FileCacheEntry cache_entry;
     cache_entry.set_md5("<md5>");
     cache_entry.set_is_present(true);
     cache_entry.set_is_persistent(true);
-    InsertIntoMap(&cache_map, "<resource_id_2>", cache_entry);
+    metadata_->AddOrUpdateCacheEntry("<resource_id_2>", cache_entry);
   }
   {
     FileCacheEntry cache_entry;
     cache_entry.set_md5("<md5>");
     cache_entry.set_is_present(true);
     cache_entry.set_is_persistent(true);
-    InsertIntoMap(&cache_map, "<resource_id_3>", cache_entry);
+    metadata_->AddOrUpdateCacheEntry("<resource_id_3>", cache_entry);
   }
   {
     FileCacheEntry cache_entry;
     cache_entry.set_md5("<md5>");
     cache_entry.set_is_present(true);
-    InsertIntoMap(&cache_map, "<resource_id_4>", cache_entry);
+    metadata_->AddOrUpdateCacheEntry("<resource_id_4>", cache_entry);
   }
 
-  AddAllMapEntries(cache_map);
   metadata_->RemoveTemporaryFiles();
   // resource 1 and 4 should be gone, as these are temporary.
   FileCacheEntry cache_entry;
   EXPECT_FALSE(metadata_->GetCacheEntry("<resource_id_1>", "", &cache_entry));
   EXPECT_TRUE(metadata_->GetCacheEntry("<resource_id_2>", "", &cache_entry));
   EXPECT_TRUE(metadata_->GetCacheEntry("<resource_id_3>", "", &cache_entry));
   EXPECT_FALSE(metadata_->GetCacheEntry("<resource_id_4>", "", &cache_entry));
 }
 
 // Don't use TEST_F, as we don't want SetUp() and TearDown() for this test.
 TEST(FileCacheMetadataExtraTest, CannotOpenDB) {
   // Create nonexistent cache paths, so the initialization fails due to the
   // failure of opening the DB.
   std::vector<base::FilePath> cache_paths =
       FileCache::GetCachePaths(
           base::FilePath::FromUTF8Unsafe("/somewhere/nonexistent"));
 
-  scoped_ptr<FileCacheMetadata> metadata =
-      FileCacheMetadata::CreateCacheMetadata(NULL);
+  scoped_ptr<FileCacheMetadata> metadata(new FileCacheMetadata(NULL));
   EXPECT_FALSE(metadata->Initialize(cache_paths));
 }
 
 }  // namespace internal
 }  // namespace drive