gdata: Remove IsCache/SetCache/ClearCache* functions from GDataCache

chrome/browser/chromeos/gdata/gdata_cache_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 "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
@@ skipping 72 matching lines @@
 struct PathToVerify {
   PathToVerify(const FilePath& in_path_to_scan,
                const FilePath& in_expected_existing_path) :
       path_to_scan(in_path_to_scan),
       expected_existing_path(in_expected_existing_path) {
   }
 
   FilePath path_to_scan;
   FilePath expected_existing_path;
 };
-}  // anonymous namespace
+
+// Converts |cache_state| to a GDataCache::CacheEntry.
+GDataCache::CacheEntry ToCacheEntry(int cache_state) {
+  return GDataCache::CacheEntry("dummy_md5", cache_state);
+}
+
+}  // namespace
 
 class MockFreeDiskSpaceGetter : public FreeDiskSpaceGetterInterface {
  public:
   virtual ~MockFreeDiskSpaceGetter() {}
   MOCK_CONST_METHOD0(AmountOfFreeDiskSpace, int64());
 };
 
 class MockGDataUploader : public GDataUploaderInterface {
  public:
   virtual ~MockGDataUploader() {}
@@ skipping 158 matching lines @@
     // GDataFileSystem::InitializeCacheOnBlockingPool would scan through them
     // and populate cache map accordingly.
 
     // Copy files from data dir to cache dir to act as cached files.
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(initial_cache_resources); ++i) {
       const struct InitialCacheResource& resource = initial_cache_resources[i];
       // Determine gdata cache file absolute path according to cache state.
       FilePath dest_path = cache_->GetCacheFilePath(
           resource.resource_id,
           resource.md5,
-          GDataCache::IsCachePinned(resource.cache_state) ||
-              GDataCache::IsCacheDirty(resource.cache_state) ?
+          ToCacheEntry(resource.cache_state).IsPinned() ||
+          ToCacheEntry(resource.cache_state).IsDirty() ?
                   GDataCache::CACHE_TYPE_PERSISTENT :
                   GDataCache::CACHE_TYPE_TMP,
-          GDataCache::IsCacheDirty(resource.cache_state) ?
+          ToCacheEntry(resource.cache_state).IsDirty() ?
               GDataCache::CACHED_FILE_LOCALLY_MODIFIED :
               GDataCache::CACHED_FILE_FROM_SERVER);
 
       // Copy file from data dir to cache subdir, naming it per cache files
       // convention.
-      if (GDataCache::IsCachePresent(resource.cache_state)) {
+      if (ToCacheEntry(resource.cache_state).IsPresent()) {
         FilePath source_path = GetTestFilePath(resource.source_file);
         ASSERT_TRUE(file_util::CopyFile(source_path, dest_path));
       } else {
         dest_path = FilePath(FILE_PATH_LITERAL(kSymLinkToDevNull));
       }
 
       // Create symbolic link in pinned dir, naming it per cache files
       // convention.
-      if (GDataCache::IsCachePinned(resource.cache_state)) {
+      if (ToCacheEntry(resource.cache_state).IsPinned()) {
         FilePath link_path = cache_->GetCacheFilePath(
             resource.resource_id,
             "",
             GDataCache::CACHE_TYPE_PINNED,
             GDataCache::CACHED_FILE_FROM_SERVER);
         ASSERT_TRUE(file_util::CreateSymbolicLink(dest_path, link_path));
       }
 
       // Create symbolic link in outgoing dir, naming it per cache files
       // convention.
-      if (GDataCache::IsCacheDirty(resource.cache_state)) {
+      if (ToCacheEntry(resource.cache_state).IsDirty()) {
         FilePath link_path = cache_->GetCacheFilePath(
             resource.resource_id,
             "",
             GDataCache::CACHE_TYPE_OUTGOING,
             GDataCache::CACHED_FILE_FROM_SERVER);
         ASSERT_TRUE(file_util::CreateSymbolicLink(dest_path, link_path));
       }
     }
     DVLOG(1) << "PrepareForInitCacheTest finished";
     cache_->RequestInitializeOnUIThread();  // Force a re-scan.
     test_util::RunBlockingPoolTask();
   }
 
   void TestInitializeCache() {
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(initial_cache_resources); ++i) {
       const struct InitialCacheResource& resource = initial_cache_resources[i];
       // Check cache file.
       num_callback_invocations_ = 0;
       TestGetFileFromCacheByResourceIdAndMd5(
           resource.resource_id,
           resource.md5,
-          GDataCache::IsCachePresent(resource.cache_state) ?
+          ToCacheEntry(resource.cache_state).IsPresent() ?
           base::PLATFORM_FILE_OK :
           base::PLATFORM_FILE_ERROR_NOT_FOUND,
           resource.expected_file_extension);
       EXPECT_EQ(1, num_callback_invocations_);
 
       // Verify cache state.
       std::string md5;
-      if (GDataCache::IsCachePresent(resource.cache_state))
+      if (ToCacheEntry(resource.cache_state).IsPresent())
          md5 = resource.md5;
       scoped_ptr<GDataCache::CacheEntry> cache_entry =
           GetCacheEntryFromOriginThread(resource.resource_id, md5);
       ASSERT_TRUE(cache_entry.get());
       EXPECT_EQ(resource.cache_state, cache_entry->cache_state);
       EXPECT_EQ(resource.expected_sub_dir_type,
                 cache_entry->GetSubDirectoryType());
     }
   }
 
@@ skipping 338 matching lines @@
   void VerifyCacheFileState(base::PlatformFileError error,
                             const std::string& resource_id,
                             const std::string& md5) {
     ++num_callback_invocations_;
 
     EXPECT_EQ(expected_error_, error);
 
     // Verify cache map.
     scoped_ptr<GDataCache::CacheEntry> cache_entry =
         GetCacheEntryFromOriginThread(resource_id, md5);
-    if (GDataCache::IsCachePresent(expected_cache_state_) ||
-        GDataCache::IsCachePinned(expected_cache_state_)) {
+    if (ToCacheEntry(expected_cache_state_).IsPresent() ||
+        ToCacheEntry(expected_cache_state_).IsPinned()) {
       ASSERT_TRUE(cache_entry.get());
       EXPECT_EQ(expected_cache_state_, cache_entry->cache_state);
       EXPECT_EQ(expected_sub_dir_type_, cache_entry->GetSubDirectoryType());
     } else {
       EXPECT_FALSE(cache_entry.get());
     }
 
     // Verify actual cache file.
     FilePath dest_path = cache_->GetCacheFilePath(
         resource_id,
         md5,
-        GDataCache::IsCachePinned(expected_cache_state_) ||
-            GDataCache::IsCacheDirty(expected_cache_state_) ?
+        ToCacheEntry(expected_cache_state_).IsPinned() ||
+        ToCacheEntry(expected_cache_state_).IsDirty() ?
                 GDataCache::CACHE_TYPE_PERSISTENT :
                 GDataCache::CACHE_TYPE_TMP,
-        GDataCache::IsCacheDirty(expected_cache_state_) ?
+        ToCacheEntry(expected_cache_state_).IsDirty() ?
             GDataCache::CACHED_FILE_LOCALLY_MODIFIED :
             GDataCache::CACHED_FILE_FROM_SERVER);
     bool exists = file_util::PathExists(dest_path);
-    if (GDataCache::IsCachePresent(expected_cache_state_))
+    if (ToCacheEntry(expected_cache_state_).IsPresent())
       EXPECT_TRUE(exists);
     else
       EXPECT_FALSE(exists);
 
     // Verify symlink in pinned dir.
     FilePath symlink_path = cache_->GetCacheFilePath(
         resource_id,
         std::string(),
         GDataCache::CACHE_TYPE_PINNED,
         GDataCache::CACHED_FILE_FROM_SERVER);
     // Check that pin symlink exists, without deferencing to target path.
     exists = file_util::IsLink(symlink_path);
-    if (GDataCache::IsCachePinned(expected_cache_state_)) {
+    if (ToCacheEntry(expected_cache_state_).IsPinned()) {
       EXPECT_TRUE(exists);
       FilePath target_path;
       EXPECT_TRUE(file_util::ReadSymbolicLink(symlink_path, &target_path));
-      if (GDataCache::IsCachePresent(expected_cache_state_))
+      if (ToCacheEntry(expected_cache_state_).IsPresent())
         EXPECT_EQ(dest_path, target_path);
       else
         EXPECT_EQ(kSymLinkToDevNull, target_path.value());
     } else {
       EXPECT_FALSE(exists);
     }
 
     // Verify symlink in outgoing dir.
     symlink_path = cache_->GetCacheFilePath(
         resource_id,
         std::string(),
         GDataCache::CACHE_TYPE_OUTGOING,
         GDataCache::CACHED_FILE_FROM_SERVER);
     // Check that outgoing symlink exists, without deferencing to target path.
     exists = file_util::IsLink(symlink_path);
     if (expect_outgoing_symlink_ &&
-        GDataCache::IsCacheDirty(expected_cache_state_)) {
+        ToCacheEntry(expected_cache_state_).IsDirty()) {
       EXPECT_TRUE(exists);
       FilePath target_path;
       EXPECT_TRUE(file_util::ReadSymbolicLink(symlink_path, &target_path));
       EXPECT_TRUE(target_path.value() != kSymLinkToDevNull);
-      if (GDataCache::IsCachePresent(expected_cache_state_))
+      if (ToCacheEntry(expected_cache_state_).IsPresent())
         EXPECT_EQ(dest_path, target_path);
     } else {
       EXPECT_FALSE(exists);
     }
   }
 
   FilePath GetCacheFilePath(const std::string& resource_id,
                             const std::string& md5,
                             GDataCache::CacheSubDirectoryType sub_dir_type,
                             GDataCache::CachedFileOrigin file_origin) {
@@ skipping 103 matching lines @@
   bool expect_outgoing_symlink_;
   std::string expected_file_extension_;
   int root_feed_changestamp_;
 };
 
 TEST_F(GDataCacheTest, InitializeCache) {
   PrepareForInitCacheTest();
   TestInitializeCache();
 }
 
-TEST_F(GDataCacheTest, CacheStateBitmasks) {
-  GDataCache::CacheEntry cache_entry("md5_cache_state_bitmasks",
-                                     GDataCache::CACHE_STATE_NONE);
+TEST_F(GDataCacheTest, CacheEntry_Is) {
+  GDataCache::CacheEntry cache_entry("dummy_md5", GDataCache::CACHE_STATE_NONE);
   EXPECT_FALSE(cache_entry.IsPresent());
   EXPECT_FALSE(cache_entry.IsPinned());
   EXPECT_FALSE(cache_entry.IsDirty());
+  EXPECT_FALSE(cache_entry.IsMounted());
+  EXPECT_FALSE(cache_entry.IsPersistent());
 
   cache_entry.cache_state = GDataCache::CACHE_STATE_PRESENT;
   EXPECT_TRUE(cache_entry.IsPresent());
   EXPECT_FALSE(cache_entry.IsPinned());
   EXPECT_FALSE(cache_entry.IsDirty());
+  EXPECT_FALSE(cache_entry.IsMounted());
+  EXPECT_FALSE(cache_entry.IsPersistent());
 
-  cache_entry.cache_state = GDataCache::CACHE_STATE_PINNED;
-  EXPECT_FALSE(cache_entry.IsPresent());
-  EXPECT_TRUE(cache_entry.IsPinned());
-  EXPECT_FALSE(cache_entry.IsDirty());
-
-  cache_entry.cache_state = GDataCache::CACHE_STATE_PRESENT |
-                            GDataCache::CACHE_STATE_PINNED;
+  cache_entry.cache_state |= GDataCache::CACHE_STATE_PINNED;
   EXPECT_TRUE(cache_entry.IsPresent());
   EXPECT_TRUE(cache_entry.IsPinned());
   EXPECT_FALSE(cache_entry.IsDirty());
+  EXPECT_FALSE(cache_entry.IsMounted());
+  EXPECT_FALSE(cache_entry.IsPersistent());
 
-  cache_entry.cache_state = GDataCache::CACHE_STATE_PRESENT |
-                            GDataCache::CACHE_STATE_DIRTY;
-  EXPECT_TRUE(cache_entry.IsPresent());
-  EXPECT_FALSE(cache_entry.IsPinned());
-  EXPECT_TRUE(cache_entry.IsDirty());
-
-  cache_entry.cache_state = GDataCache::CACHE_STATE_PRESENT |
-                            GDataCache::CACHE_STATE_PINNED |
-                            GDataCache::CACHE_STATE_DIRTY;
+  cache_entry.cache_state |= GDataCache::CACHE_STATE_DIRTY;
   EXPECT_TRUE(cache_entry.IsPresent());
   EXPECT_TRUE(cache_entry.IsPinned());
   EXPECT_TRUE(cache_entry.IsDirty());
+  EXPECT_FALSE(cache_entry.IsMounted());
+  EXPECT_FALSE(cache_entry.IsPersistent());
 
-  int cache_state = GDataCache::CACHE_STATE_NONE;
-  EXPECT_EQ(GDataCache::CACHE_STATE_PRESENT,
-            GDataCache::SetCachePresent(cache_state));
-  EXPECT_EQ(GDataCache::CACHE_STATE_PINNED,
-            GDataCache::SetCachePinned(cache_state));
+  cache_entry.cache_state |= GDataCache::CACHE_STATE_MOUNTED;
+  EXPECT_TRUE(cache_entry.IsPresent());
+  EXPECT_TRUE(cache_entry.IsPinned());
+  EXPECT_TRUE(cache_entry.IsDirty());
+  EXPECT_TRUE(cache_entry.IsMounted());
+  EXPECT_FALSE(cache_entry.IsPersistent());
 
-  cache_state = GDataCache::CACHE_STATE_PRESENT;
-  EXPECT_EQ(GDataCache::CACHE_STATE_PRESENT | GDataCache::CACHE_STATE_PINNED,
-            GDataCache::SetCachePinned(cache_state));
-  EXPECT_EQ(GDataCache::CACHE_STATE_PRESENT | GDataCache::CACHE_STATE_DIRTY,
-            GDataCache::SetCacheDirty(cache_state));
-  cache_state |= GDataCache::CACHE_STATE_PINNED;
-  EXPECT_EQ(GDataCache::CACHE_STATE_PRESENT | GDataCache::CACHE_STATE_PINNED |
+  cache_entry.cache_state |= GDataCache::CACHE_STATE_PERSISTENT;
+  EXPECT_TRUE(cache_entry.IsPresent());
+  EXPECT_TRUE(cache_entry.IsPinned());
+  EXPECT_TRUE(cache_entry.IsDirty());
+  EXPECT_TRUE(cache_entry.IsMounted());
+  EXPECT_TRUE(cache_entry.IsPersistent());
+}
+
+TEST_F(GDataCacheTest, CacheEntry_Set) {
+  GDataCache::CacheEntry cache_entry("dummy_md5", GDataCache::CACHE_STATE_NONE);
+
+  cache_entry.SetPresent(true);
+  EXPECT_EQ(GDataCache::CACHE_STATE_PRESENT, cache_entry.cache_state);
+
+  cache_entry.SetPinned(true);
+  EXPECT_EQ(GDataCache::CACHE_STATE_PRESENT |
+            GDataCache::CACHE_STATE_PINNED,
+            cache_entry.cache_state);
+
+  cache_entry.SetDirty(true);
+  EXPECT_EQ(GDataCache::CACHE_STATE_PRESENT |
+            GDataCache::CACHE_STATE_PINNED |
             GDataCache::CACHE_STATE_DIRTY,
-            GDataCache::SetCacheDirty(cache_state));
+            cache_entry.cache_state);
 
-  cache_state = GDataCache::CACHE_STATE_PINNED;
-  EXPECT_EQ(GDataCache::CACHE_STATE_PRESENT | GDataCache::CACHE_STATE_PINNED,
-            GDataCache::SetCachePresent(cache_state));
+  cache_entry.SetMounted(true);
+  EXPECT_EQ(GDataCache::CACHE_STATE_PRESENT |
+            GDataCache::CACHE_STATE_PINNED |
+            GDataCache::CACHE_STATE_DIRTY |
+            GDataCache::CACHE_STATE_MOUNTED,
+            cache_entry.cache_state);
 
-  cache_state = GDataCache::CACHE_STATE_PRESENT |
-                GDataCache::CACHE_STATE_PINNED |
-                GDataCache::CACHE_STATE_DIRTY;
-  EXPECT_EQ(cache_state & ~GDataCache::CACHE_STATE_PRESENT,
-            GDataCache::ClearCachePresent(cache_state));
-  EXPECT_EQ(cache_state & ~GDataCache::CACHE_STATE_PINNED,
-            GDataCache::ClearCachePinned(cache_state));
-  EXPECT_EQ(cache_state & ~GDataCache::CACHE_STATE_DIRTY,
-            GDataCache::ClearCacheDirty(cache_state));
+  cache_entry.SetPersistent(true);
+  EXPECT_EQ(GDataCache::CACHE_STATE_PRESENT |
+            GDataCache::CACHE_STATE_PINNED |
+            GDataCache::CACHE_STATE_DIRTY |
+            GDataCache::CACHE_STATE_MOUNTED |
+            GDataCache::CACHE_STATE_PERSISTENT,
+            cache_entry.cache_state);
+
+  cache_entry.SetPresent(false);
+  EXPECT_EQ(GDataCache::CACHE_STATE_PINNED |
+            GDataCache::CACHE_STATE_DIRTY |
+            GDataCache::CACHE_STATE_MOUNTED |
+            GDataCache::CACHE_STATE_PERSISTENT,
+            cache_entry.cache_state);
+
+  cache_entry.SetPinned(false);
+  EXPECT_EQ(GDataCache::CACHE_STATE_DIRTY |
+            GDataCache::CACHE_STATE_MOUNTED |
+            GDataCache::CACHE_STATE_PERSISTENT,
+            cache_entry.cache_state);
+
+  cache_entry.SetDirty(false);
+  EXPECT_EQ(GDataCache::CACHE_STATE_MOUNTED |
+            GDataCache::CACHE_STATE_PERSISTENT, cache_entry.cache_state);
+
+  cache_entry.SetMounted(false);
+  EXPECT_EQ(GDataCache::CACHE_STATE_PERSISTENT, cache_entry.cache_state);
+
+  cache_entry.SetPersistent(false);
+  EXPECT_EQ(GDataCache::CACHE_STATE_NONE, cache_entry.cache_state);
 }
 
 TEST_F(GDataCacheTest, GetCacheFilePath) {
   // Use alphanumeric characters for resource id.
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   TestGetCacheFilePath(resource_id, md5,
                        resource_id + FilePath::kExtensionSeparator + md5);
   EXPECT_EQ(0, num_callback_invocations_);
 
@@ skipping 32 matching lines @@
   // |md5|.
   md5 = "new_md5";
   num_callback_invocations_ = 0;
   TestStoreToCache(resource_id, md5, GetTestFilePath("subdir_feed.json"),
                    base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Verify that there's only one file with name <resource_id>, i.e. previously
   // cached file with the different md5 should be deleted.
-  FilePath path = GetCacheFilePath(resource_id, "*",
-      (GDataCache::IsCachePinned(expected_cache_state_)) ?
-          GDataCache::CACHE_TYPE_PERSISTENT :
-          GDataCache::CACHE_TYPE_TMP,
+  FilePath path = GetCacheFilePath(
+      resource_id, "*",
+      (ToCacheEntry(expected_cache_state_).IsPinned() ?
+       GDataCache::CACHE_TYPE_PERSISTENT :
+       GDataCache::CACHE_TYPE_TMP),
       GDataCache::CACHED_FILE_FROM_SERVER);
   file_util::FileEnumerator enumerator(path.DirName(), false,
                                        file_util::FileEnumerator::FILES,
                                        path.BaseName().value());
   size_t num_files_found = 0;
   for (FilePath current = enumerator.Next(); !current.empty();
        current = enumerator.Next()) {
     ++num_files_found;
     EXPECT_EQ(util::EscapeCacheFileName(resource_id) +
               FilePath::kExtensionSeparator +
@@ skipping 633 matching lines @@
   EXPECT_EQ(1, num_callback_invocations_);
   EXPECT_TRUE(CacheEntryExists(resource_id, md5));
 
   // Try to remove the file.
   num_callback_invocations_ = 0;
   TestRemoveFromCache(resource_id, base::PLATFORM_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 }   // namespace gdata