drive: Stop using FileCacheEntry related methods in FileCache

chrome/browser/chromeos/drive/resource_metadata_storage_unittest.cc

 // Copyright 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/browser/chromeos/drive/resource_metadata_storage.h"
 
 #include <algorithm>
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 138 matching lines @@
   keys.push_back("entry2");
   keys.push_back("entry3");
   keys.push_back("entry4");
 
   for (size_t i = 0; i < keys.size(); ++i) {
     ResourceEntry entry;
     entry.set_local_id(keys[i]);
     EXPECT_EQ(FILE_ERROR_OK, storage_->PutEntry(entry));
   }
 
-  // Insert some cache entries.
-  std::map<std::string, FileCacheEntry> cache_entries;
-  cache_entries[keys[0]].set_md5("aaaaaa");
-  cache_entries[keys[1]].set_md5("bbbbbb");
-  for (std::map<std::string, FileCacheEntry>::iterator it =
-           cache_entries.begin(); it != cache_entries.end(); ++it)
-    EXPECT_EQ(FILE_ERROR_OK, storage_->PutCacheEntry(it->first, it->second));
-
   // Iterate and check the result.
   std::map<std::string, ResourceEntry> found_entries;
   scoped_ptr<ResourceMetadataStorage::Iterator> it = storage_->GetIterator();
   ASSERT_TRUE(it);
   for (; !it->IsAtEnd(); it->Advance()) {
     const ResourceEntry& entry = it->GetValue();
     found_entries[it->GetID()] = entry;
   }
   EXPECT_FALSE(it->HasError());
 
   EXPECT_EQ(keys.size(), found_entries.size());
   for (size_t i = 0; i < keys.size(); ++i)
     EXPECT_EQ(1U, found_entries.count(keys[i]));
 }
 
-TEST_F(ResourceMetadataStorageTest, PutCacheEntry) {
-  FileCacheEntry entry;
-  const std::string key1 = "abcdefg";
-  const std::string key2 = "abcd";
-  const std::string md5_1 = "foo";
-  const std::string md5_2 = "bar";
-
-  // Put cache entries.
-  entry.set_md5(md5_1);
-  EXPECT_EQ(FILE_ERROR_OK, storage_->PutCacheEntry(key1, entry));
-  entry.set_md5(md5_2);
-  EXPECT_EQ(FILE_ERROR_OK, storage_->PutCacheEntry(key2, entry));
-
-  // Get cache entires.
-  EXPECT_EQ(FILE_ERROR_OK, storage_->GetCacheEntry(key1, &entry));
-  EXPECT_EQ(md5_1, entry.md5());
-  EXPECT_EQ(FILE_ERROR_OK, storage_->GetCacheEntry(key2, &entry));
-  EXPECT_EQ(md5_2, entry.md5());
-
-  // Remove cache entries.
-  EXPECT_EQ(FILE_ERROR_OK, storage_->RemoveCacheEntry(key1));
-  EXPECT_EQ(FILE_ERROR_NOT_FOUND, storage_->GetCacheEntry(key1, &entry));
-
-  EXPECT_EQ(FILE_ERROR_OK, storage_->RemoveCacheEntry(key2));
-  EXPECT_EQ(FILE_ERROR_NOT_FOUND, storage_->GetCacheEntry(key2, &entry));
-}
-
-TEST_F(ResourceMetadataStorageTest, CacheEntryIterator) {
-  // Prepare data.
-  std::map<std::string, FileCacheEntry> entries;
-  FileCacheEntry cache_entry;
-
-  cache_entry.set_md5("aA");
-  entries["entry1"] = cache_entry;
-  cache_entry.set_md5("bB");
-  entries["entry2"] = cache_entry;
-  cache_entry.set_md5("cC");
-  entries["entry3"] = cache_entry;
-  cache_entry.set_md5("dD");
-  entries["entry4"] = cache_entry;
-
-  for (std::map<std::string, FileCacheEntry>::iterator it = entries.begin();
-       it != entries.end(); ++it)
-    EXPECT_EQ(FILE_ERROR_OK, storage_->PutCacheEntry(it->first, it->second));
-
-  // Insert some dummy entries.
-  ResourceEntry entry;
-  entry.set_local_id("entry1");
-  EXPECT_EQ(FILE_ERROR_OK, storage_->PutEntry(entry));
-  entry.set_local_id("entry2");
-  EXPECT_EQ(FILE_ERROR_OK, storage_->PutEntry(entry));
-
-  // Iterate and check the result.
-  scoped_ptr<ResourceMetadataStorage::CacheEntryIterator> it =
-      storage_->GetCacheEntryIterator();
-  ASSERT_TRUE(it);
-  size_t num_entries = 0;
-  for (; !it->IsAtEnd(); it->Advance()) {
-    EXPECT_EQ(1U, entries.count(it->GetID()));
-    EXPECT_EQ(entries[it->GetID()].md5(), it->GetValue().md5());
-    ++num_entries;
-  }
-  EXPECT_FALSE(it->HasError());
-  EXPECT_EQ(entries.size(), num_entries);
-}
-
 TEST_F(ResourceMetadataStorageTest, GetIdByResourceId) {
   const std::string local_id = "local_id";
   const std::string resource_id = "resource_id";
 
   // Resource ID to local ID mapping is not stored yet.
   std::string id;
   EXPECT_EQ(FILE_ERROR_NOT_FOUND,
             storage_->GetIdByResourceId(resource_id, &id));
 
   // Put an entry with the resource ID.
@@ skipping 43 matching lines @@
   for (size_t i = 0; i < children_name_id.size(); ++i) {
     for (size_t j = 0; j < children_name_id[i].size(); ++j) {
       ResourceEntry entry;
       entry.set_local_id(children_name_id[i][j].second);
       entry.set_parent_local_id(parents_id[i]);
       entry.set_base_name(children_name_id[i][j].first);
       EXPECT_EQ(FILE_ERROR_OK, storage_->PutEntry(entry));
     }
   }
 
-  // Put some dummy cache entries.
-  for (size_t i = 0; i < arraysize(parents_id); ++i) {
-    FileCacheEntry cache_entry;
-    EXPECT_EQ(FILE_ERROR_OK,
-              storage_->PutCacheEntry(parents_id[i], cache_entry));
-  }
-
   // Try to get children.
   for (size_t i = 0; i < children_name_id.size(); ++i) {
     std::vector<std::string> children;
     storage_->GetChildren(parents_id[i], &children);
     EXPECT_EQ(children_name_id[i].size(), children.size());
     for (size_t j = 0; j < children_name_id[i].size(); ++j) {
       EXPECT_EQ(1, std::count(children.begin(),
                               children.end(),
                               children_name_id[i][j].second));
     }
@@ skipping 130 matching lines @@
 TEST_F(ResourceMetadataStorageTest, IncompatibleDB_Unknown) {
   const int64 kLargestChangestamp = 1234567890;
   const std::string key1 = "abcd";
 
   // Put some data.
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->SetLargestChangestamp(kLargestChangestamp));
   ResourceEntry entry;
   entry.set_local_id(key1);
   EXPECT_EQ(FILE_ERROR_OK, storage_->PutEntry(entry));
-  FileCacheEntry cache_entry;
-  EXPECT_EQ(FILE_ERROR_OK, storage_->PutCacheEntry(key1, cache_entry));
 
   // Set newer version, upgrade and reopen DB.
   SetDBVersion(ResourceMetadataStorage::kDBVersion + 1);
   storage_.reset();
   EXPECT_FALSE(ResourceMetadataStorage::UpgradeOldDB(
       temp_dir_.path(), base::Bind(&util::CanonicalizeResourceId)));
   storage_.reset(new ResourceMetadataStorage(
       temp_dir_.path(), base::MessageLoopProxy::current().get()));
   ASSERT_TRUE(storage_->Initialize());
 
   // Data is erased because of the incompatible version.
   int64 largest_changestamp = 0;
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->GetLargestChangestamp(&largest_changestamp));
   EXPECT_EQ(0, largest_changestamp);
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, storage_->GetEntry(key1, &entry));
-  EXPECT_EQ(FILE_ERROR_NOT_FOUND, storage_->GetCacheEntry(key1, &cache_entry));
 }
 
 TEST_F(ResourceMetadataStorageTest, WrongPath) {
   // Create a file.
   base::FilePath path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &path));
 
   storage_.reset(new ResourceMetadataStorage(
       path, base::MessageLoopProxy::current().get()));
   // Cannot initialize DB beacause the path does not point a directory.
   ASSERT_FALSE(storage_->Initialize());
 }
 
 TEST_F(ResourceMetadataStorageTest, RecoverCacheEntriesFromTrashedResourceMap) {
-  // Put some cache entries.
-  FileCacheEntry cache_entry;
-  cache_entry.set_md5("md5_foo");
-  EXPECT_EQ(FILE_ERROR_OK, storage_->PutCacheEntry("id_foo", cache_entry));
-  cache_entry.set_md5("md5_bar");
-  cache_entry.set_is_dirty(true);
-  EXPECT_EQ(FILE_ERROR_OK, storage_->PutCacheEntry("id_bar", cache_entry));
-
   // Put entry with id_foo.
   ResourceEntry entry;
   entry.set_local_id("id_foo");
   entry.set_base_name("foo");
   entry.set_title("foo");
+  entry.mutable_file_specific_info()->mutable_cache_state()->set_md5("md5_foo");
   EXPECT_EQ(FILE_ERROR_OK, storage_->PutEntry(entry));
 
   // Put entry with id_bar as a id_foo's child.
   entry.set_local_id("id_bar");
   entry.set_parent_local_id("id_foo");
   entry.set_base_name("bar");
   entry.set_title("bar");
+  entry.mutable_file_specific_info()->mutable_cache_state()->set_md5("md5_bar");
+  entry.mutable_file_specific_info()->mutable_cache_state()->set_is_dirty(true);
   EXPECT_EQ(FILE_ERROR_OK, storage_->PutEntry(entry));
 
   // Remove parent-child relationship to make the DB invalid.
   RemoveChild("id_foo", "bar");
   EXPECT_FALSE(CheckValidity());
 
   // Reopen. This should result in trashing the DB.
   storage_.reset(new ResourceMetadataStorage(
       temp_dir_.path(), base::MessageLoopProxy::current().get()));
   ASSERT_TRUE(storage_->Initialize());
@@ skipping 58 matching lines @@
   EXPECT_FALSE(CheckValidity());
   PutChild(key2, name2, key3);
   EXPECT_FALSE(CheckValidity());
 
   // Fix up the relationship between key2 and key3.
   RemoveChild(key2, name2);
   EXPECT_FALSE(CheckValidity());
   PutChild(key2, name3, key3);
   EXPECT_TRUE(CheckValidity());
 
-  // Add some cache entries.
-  FileCacheEntry cache_entry;
-  EXPECT_EQ(FILE_ERROR_OK, storage_->PutCacheEntry(key1, cache_entry));
-  EXPECT_EQ(FILE_ERROR_OK, storage_->PutCacheEntry(key2, cache_entry));
-
   // Remove key2.
   RemoveChild(key1, name2);
   EXPECT_FALSE(CheckValidity());
   EXPECT_EQ(FILE_ERROR_OK, storage_->RemoveEntry(key2));
   EXPECT_FALSE(CheckValidity());
 
   // Remove key3.
   RemoveChild(key2, name3);
   EXPECT_FALSE(CheckValidity());
   EXPECT_EQ(FILE_ERROR_OK, storage_->RemoveEntry(key3));
   EXPECT_TRUE(CheckValidity());
 
   // Remove key1.
   EXPECT_EQ(FILE_ERROR_OK, storage_->RemoveEntry(key1));
   EXPECT_TRUE(CheckValidity());
 }
 
 }  // namespace internal
 }  // namespace drive