gdata: Make GDataCache::CacheEntry a struct

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 322 matching lines @@
           resource.expected_file_extension);
       EXPECT_EQ(1, num_callback_invocations_);
 
       // Verify cache state.
       std::string md5;
       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.cache_state, cache_entry->cache_state());
       EXPECT_EQ(resource.expected_sub_dir_type,
                 cache_entry->GetSubDirectoryType());
     }
   }
 
   void TestGetFileFromCacheByResourceIdAndMd5(
       const std::string& resource_id,
       const std::string& md5,
       base::PlatformFileError expected_error,
       const std::string& expected_file_extension) {
@@ skipping 209 matching lines @@
     test_util::RunBlockingPoolTask();
   }
 
   void VerifyGetCacheState(bool success,
                            const GDataCache::CacheEntry& cache_entry) {
     ++num_callback_invocations_;
 
     EXPECT_EQ(expected_success_, success);
 
     if (success) {
-      EXPECT_EQ(expected_cache_state_, cache_entry.cache_state);
+      EXPECT_EQ(expected_cache_state_, cache_entry.cache_state());
     }
   }
 
   void TestMarkDirty(
       const std::string& resource_id,
       const std::string& md5,
       base::PlatformFileError expected_error,
       int expected_cache_state,
       GDataCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
@@ skipping 106 matching lines @@
     ++num_callback_invocations_;
 
     EXPECT_EQ(expected_error_, error);
 
     // Verify cache map.
     scoped_ptr<GDataCache::CacheEntry> cache_entry =
         GetCacheEntryFromOriginThread(resource_id, md5);
     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_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,
         ToCacheEntry(expected_cache_state_).IsPinned() ||
@@ skipping 160 matching lines @@
   bool expect_outgoing_symlink_;
   std::string expected_file_extension_;
   int root_feed_changestamp_;
 };
 
 TEST_F(GDataCacheTest, InitializeCache) {
   PrepareForInitCacheTest();
   TestInitializeCache();
 }
 
-TEST_F(GDataCacheTest, CacheEntry_Is) {
+TEST_F(GDataCacheTest, CacheEntry_CacheStateChanges) {
   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;
+  cache_entry.SetPresent(true);
   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;
+  cache_entry.SetPinned(true);
   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_DIRTY;
+  cache_entry.SetDirty(true);
   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());
 
-  cache_entry.cache_state |= GDataCache::CACHE_STATE_MOUNTED;
+  cache_entry.SetMounted(true);
   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_entry.cache_state |= GDataCache::CACHE_STATE_PERSISTENT;
+  cache_entry.SetPersistent(true);
   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,
-            cache_entry.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_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);
+  EXPECT_FALSE(cache_entry.IsPresent());
+  EXPECT_TRUE(cache_entry.IsPinned());
+  EXPECT_TRUE(cache_entry.IsDirty());
+  EXPECT_TRUE(cache_entry.IsMounted());
+  EXPECT_TRUE(cache_entry.IsPersistent());
+
+  cache_entry.SetPresent(false);
+  EXPECT_FALSE(cache_entry.IsPresent());
+  EXPECT_TRUE(cache_entry.IsPinned());
+  EXPECT_TRUE(cache_entry.IsDirty());
+  EXPECT_TRUE(cache_entry.IsMounted());
+  EXPECT_TRUE(cache_entry.IsPersistent());
 
   cache_entry.SetPinned(false);
-  EXPECT_EQ(GDataCache::CACHE_STATE_DIRTY |
-            GDataCache::CACHE_STATE_MOUNTED |
-            GDataCache::CACHE_STATE_PERSISTENT,
-            cache_entry.cache_state);
+  EXPECT_FALSE(cache_entry.IsPresent());
+  EXPECT_FALSE(cache_entry.IsPinned());
+  EXPECT_TRUE(cache_entry.IsDirty());
+  EXPECT_TRUE(cache_entry.IsMounted());
+  EXPECT_TRUE(cache_entry.IsPersistent());
 
   cache_entry.SetDirty(false);
-  EXPECT_EQ(GDataCache::CACHE_STATE_MOUNTED |
-            GDataCache::CACHE_STATE_PERSISTENT, cache_entry.cache_state);
+  EXPECT_FALSE(cache_entry.IsPresent());
+  EXPECT_FALSE(cache_entry.IsPinned());
+  EXPECT_FALSE(cache_entry.IsDirty());
+  EXPECT_TRUE(cache_entry.IsMounted());
+  EXPECT_TRUE(cache_entry.IsPersistent());
 
   cache_entry.SetMounted(false);
-  EXPECT_EQ(GDataCache::CACHE_STATE_PERSISTENT, cache_entry.cache_state);
+  EXPECT_FALSE(cache_entry.IsPresent());
+  EXPECT_FALSE(cache_entry.IsPinned());
+  EXPECT_FALSE(cache_entry.IsDirty());
+  EXPECT_FALSE(cache_entry.IsMounted());
+  EXPECT_TRUE(cache_entry.IsPersistent());
 
   cache_entry.SetPersistent(false);
-  EXPECT_EQ(GDataCache::CACHE_STATE_NONE, cache_entry.cache_state);
+  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());
 }
 
 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 690 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