Rename GDataCache* to DriveCache*

chrome/browser/chromeos/gdata/drive_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/gdata/gdata_cache_metadata.h"
+#include "chrome/browser/chromeos/gdata/drive_cache_metadata.h"
 
 #include "base/file_util.h"
 #include "base/scoped_temp_dir.h"
 #include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_test_util.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gdata {
 
-class GDataCacheMetadataTest : public testing::Test {
+class DriveCacheMetadataTest : public testing::Test {
  public:
-  GDataCacheMetadataTest() {}
+  DriveCacheMetadataTest() {}
 
   virtual void SetUp() OVERRIDE {
     // Create cache directories.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-    cache_paths_ = GDataCache::GetCachePaths(temp_dir_.path());
-    ASSERT_TRUE(GDataCache::CreateCacheDirectories(cache_paths_));
+    cache_paths_ = DriveCache::GetCachePaths(temp_dir_.path());
+    ASSERT_TRUE(DriveCache::CreateCacheDirectories(cache_paths_));
 
-    persistent_directory_ = cache_paths_[GDataCache::CACHE_TYPE_PERSISTENT];
-    tmp_directory_ = cache_paths_[GDataCache::CACHE_TYPE_TMP];
-    pinned_directory_ = cache_paths_[GDataCache::CACHE_TYPE_PINNED];
-    outgoing_directory_ = cache_paths_[GDataCache::CACHE_TYPE_OUTGOING];
+    persistent_directory_ = cache_paths_[DriveCache::CACHE_TYPE_PERSISTENT];
+    tmp_directory_ = cache_paths_[DriveCache::CACHE_TYPE_TMP];
+    pinned_directory_ = cache_paths_[DriveCache::CACHE_TYPE_PINNED];
+    outgoing_directory_ = cache_paths_[DriveCache::CACHE_TYPE_OUTGOING];
   }
 
   virtual void TearDown() OVERRIDE {
     metadata_.reset();
   }
 
-  // Sets up the GDataCacheMetadata object.
+  // Sets up the DriveCacheMetadata object.
   void SetUpCacheMetadata() {
-    metadata_ = GDataCacheMetadata::CreateGDataCacheMetadata(NULL).Pass();
+    metadata_ = DriveCacheMetadata::CreateDriveCacheMetadata(NULL).Pass();
     metadata_->Initialize(cache_paths_);
   }
 
   // Sets up the cache directories with various files, including stale
   // symbolic links etc. 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"));
@@ skipping 57 matching lines @@
 
   // Create an symlink to |target| at |symlink|.
   void CreateSymbolicLink(const FilePath& target, const FilePath& symlink) {
     ASSERT_TRUE(file_util::CreateSymbolicLink(target, symlink))
         << ": " << target.value() << ": " << symlink.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 CacheEntry.
-  void InsertIntoMap(GDataCacheMetadata::CacheMap* cache_map,
+  void InsertIntoMap(DriveCacheMetadata::CacheMap* cache_map,
                      const std::string& resource_id,
                      const DriveCacheEntry& 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 GDataCacheMetadata::CacheMap& cache_map) {
-    for (GDataCacheMetadata::CacheMap::const_iterator iter = cache_map.begin();
+  void AddAllMapEntries(const DriveCacheMetadata::CacheMap& cache_map) {
+    for (DriveCacheMetadata::CacheMap::const_iterator iter = cache_map.begin();
          iter != cache_map.end(); ++iter) {
       metadata_->AddOrUpdateCacheEntry(iter->first, iter->second);
     }
   }
 
   ScopedTempDir temp_dir_;
-  scoped_ptr<GDataCacheMetadata> metadata_;
+  scoped_ptr<DriveCacheMetadata> metadata_;
   std::vector<FilePath> cache_paths_;
   FilePath persistent_directory_;
   FilePath tmp_directory_;
   FilePath pinned_directory_;
   FilePath outgoing_directory_;
 };
 
-// Test all the methods of GDataCacheMetadata except for
+// Test all the methods of DriveCacheMetadata except for
 // RemoveTemporaryFiles.
-TEST_F(GDataCacheMetadataTest, CacheTest) {
+TEST_F(DriveCacheMetadataTest, CacheTest) {
   SetUpCacheMetadata();
 
   // Save an initial entry.
   std::string test_resource_id("test_resource_id");
   std::string test_file_md5("test_file_md5");
   {
     DriveCacheEntry new_cache_entry;
     new_cache_entry.set_md5(test_file_md5);
     new_cache_entry.set_is_present(true);
     new_cache_entry.set_is_persistent(true);
@@ skipping 81 matching lines @@
     metadata_->AddOrUpdateCacheEntry(test_resource_id, new_cache_entry);
   }
 
   // Make sure the values took.
   ASSERT_TRUE(metadata_->GetCacheEntry(
       test_resource_id, test_file_md5, &cache_entry));
   EXPECT_EQ(test_file_md5, cache_entry.md5());
   EXPECT_TRUE(cache_entry.is_present());
 }
 
-TEST_F(GDataCacheMetadataTest, Initialization) {
+TEST_F(DriveCacheMetadataTest, Initialization) {
   using file_util::PathExists;
   using file_util::IsLink;
   SetUpCacheWithVariousFiles();
 
   // Some files are removed during cache initialization. Make sure these
   // exist beforehand.
   EXPECT_TRUE(PathExists(persistent_directory_.AppendASCII("id_baz.local")));
   EXPECT_TRUE(PathExists(persistent_directory_.AppendASCII("id_bad.md5bad")));
   EXPECT_TRUE(PathExists(tmp_directory_.AppendASCII("id_quux.local")));
   EXPECT_TRUE(PathExists(pinned_directory_.AppendASCII("id_not_symlink")));
   EXPECT_TRUE(IsLink(pinned_directory_.AppendASCII("id_dangling")));
   EXPECT_TRUE(IsLink(pinned_directory_.AppendASCII("id_outside")));
   EXPECT_TRUE(IsLink(outgoing_directory_.AppendASCII("id_foo")));
   EXPECT_TRUE(IsLink(persistent_directory_.AppendASCII("id_symlink")));
   EXPECT_TRUE(IsLink(tmp_directory_.AppendASCII("id_symlink_tmp")));
 
   SetUpCacheMetadata();
 
   // Check contents in "persistent" directory.
   //
   // "id_foo" is present and pinned.
   DriveCacheEntry cache_entry;
   ASSERT_TRUE(metadata_->GetCacheEntry("id_foo", "md5foo", &cache_entry));
   EXPECT_EQ("md5foo", cache_entry.md5());
-  EXPECT_EQ(GDataCache::CACHE_TYPE_PERSISTENT,
-            GDataCache::GetSubDirectoryType(cache_entry));
+  EXPECT_EQ(DriveCache::CACHE_TYPE_PERSISTENT,
+            DriveCache::GetSubDirectoryType(cache_entry));
   EXPECT_TRUE(test_util::CacheStatesEqual(
       test_util::ToCacheEntry(test_util::TEST_CACHE_STATE_PRESENT |
                               test_util::TEST_CACHE_STATE_PINNED |
                               test_util::TEST_CACHE_STATE_PERSISTENT),
       cache_entry));
   EXPECT_TRUE(PathExists(persistent_directory_.AppendASCII("id_foo.md5foo")));
   EXPECT_TRUE(PathExists(pinned_directory_.AppendASCII("id_foo")));
   // The invalid symlink in "outgoing" should be removed.
   EXPECT_FALSE(PathExists(outgoing_directory_.AppendASCII("id_foo")));
 
   // "id_bar" is present and dirty.
   ASSERT_TRUE(metadata_->GetCacheEntry("id_bar", "", &cache_entry));
   EXPECT_EQ("local", cache_entry.md5());
-  EXPECT_EQ(GDataCache::CACHE_TYPE_PERSISTENT,
-            GDataCache::GetSubDirectoryType(cache_entry));
+  EXPECT_EQ(DriveCache::CACHE_TYPE_PERSISTENT,
+            DriveCache::GetSubDirectoryType(cache_entry));
   EXPECT_TRUE(test_util::CacheStatesEqual(
       test_util::ToCacheEntry(test_util::TEST_CACHE_STATE_PRESENT |
                               test_util::TEST_CACHE_STATE_DIRTY |
                               test_util::TEST_CACHE_STATE_PERSISTENT),
       cache_entry));
   EXPECT_TRUE(PathExists(persistent_directory_.AppendASCII("id_bar.local")));
   EXPECT_TRUE(PathExists(outgoing_directory_.AppendASCII("id_bar")));
 
   // "id_baz" should be removed during cache initialization.
   EXPECT_FALSE(metadata_->GetCacheEntry("id_baz", "", &cache_entry));
   EXPECT_FALSE(PathExists(persistent_directory_.AppendASCII("id_baz.local")));
 
   // "id_bad" should be removed during cache initialization.
   EXPECT_FALSE(metadata_->GetCacheEntry("id_bad", "md5bad", &cache_entry));
   EXPECT_FALSE(PathExists(persistent_directory_.AppendASCII("id_bad.md5bad")));
 
   // "id_symlink" should be removed during cache initialization.
   EXPECT_FALSE(metadata_->GetCacheEntry("id_symlink", "", &cache_entry));
   EXPECT_FALSE(PathExists(persistent_directory_.AppendASCII("id_symlink")));
 
   // Check contents in "tmp" directory.
   //
   // "id_qux" is just present in tmp directory.
   ASSERT_TRUE(metadata_->GetCacheEntry("id_qux", "md5qux", &cache_entry));
   EXPECT_EQ("md5qux", cache_entry.md5());
-  EXPECT_EQ(GDataCache::CACHE_TYPE_TMP,
-            GDataCache::GetSubDirectoryType(cache_entry));
+  EXPECT_EQ(DriveCache::CACHE_TYPE_TMP,
+            DriveCache::GetSubDirectoryType(cache_entry));
   EXPECT_TRUE(test_util::CacheStatesEqual(
       test_util::ToCacheEntry(test_util::TEST_CACHE_STATE_PRESENT),
       cache_entry));
   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));
   EXPECT_FALSE(PathExists(pinned_directory_.AppendASCII("id_quux.local")));
 
   // "id_symlink_tmp" should be removed during cache initialization.
@@ skipping 16 matching lines @@
 
   // "id_outside" should be removed during cache initialization.
   EXPECT_FALSE(metadata_->GetCacheEntry("id_outside", "", &cache_entry));
   EXPECT_FALSE(IsLink(pinned_directory_.AppendASCII("id_outside")));
 
   // "id_not_symlink" should be removed during cache initialization.
   EXPECT_FALSE(metadata_->GetCacheEntry("id_not_symlink", "", &cache_entry));
   EXPECT_FALSE(IsLink(pinned_directory_.AppendASCII("id_not_symlink")));
 }
 
-// Test GDataCacheMetadata::RemoveTemporaryFiles.
-TEST_F(GDataCacheMetadataTest, RemoveTemporaryFilesTest) {
+// Test DriveCacheMetadata::RemoveTemporaryFiles.
+TEST_F(DriveCacheMetadataTest, RemoveTemporaryFilesTest) {
   SetUpCacheMetadata();
 
-  GDataCacheMetadata::CacheMap cache_map;
+  DriveCacheMetadata::CacheMap cache_map;
   {
     DriveCacheEntry cache_entry;
     cache_entry.set_md5("<md5>");
     cache_entry.set_is_present(true);
     InsertIntoMap(&cache_map, "<resource_id_1>", cache_entry);
   }
   {
     DriveCacheEntry cache_entry;
     cache_entry.set_md5("<md5>");
     cache_entry.set_is_present(true);
@@ skipping 18 matching lines @@
   metadata_->RemoveTemporaryFiles();
   // resource 1 and 4 should be gone, as these are temporary.
   DriveCacheEntry 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));
 }
 
 }  // namespace gdata