gdata: Move GDataCache::CacheEntry out of 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 21 matching lines @@
   const char* source_file;              // Source file to be used for cache.
   const char* resource_id;              // Resource id of cache file.
   const char* md5;                      // MD5 of cache file.
   int cache_state;                      // Cache state of cache file.
   const char* expected_file_extension;  // Expected extension of cached file.
   // Expected CacheSubDirectoryType of cached file.
   GDataCache::CacheSubDirectoryType expected_sub_dir_type;
 } const initial_cache_resources[] = {
   // Cache resource in tmp dir, i.e. not pinned or dirty.
   { "root_feed.json", "tmp:resource_id", "md5_tmp_alphanumeric",
-    GDataCache::CACHE_STATE_PRESENT,
+    CACHE_STATE_PRESENT,
     "md5_tmp_alphanumeric", GDataCache::CACHE_TYPE_TMP },
   // Cache resource in tmp dir, i.e. not pinned or dirty, with resource_id
   // containing non-alphanumeric characters, to test resource_id is escaped and
   // unescaped correctly.
   { "subdir_feed.json", "tmp:`~!@#$%^&*()-_=+[{|]}\\;',<.>/?",
     "md5_tmp_non_alphanumeric",
-    GDataCache::CACHE_STATE_PRESENT,
+    CACHE_STATE_PRESENT,
     "md5_tmp_non_alphanumeric", GDataCache::CACHE_TYPE_TMP },
   // Cache resource that is pinned, to test a pinned file is in persistent dir
   // with a symlink in pinned dir referencing it.
   { "directory_entry_atom.json", "pinned:existing", "md5_pinned_existing",
-    GDataCache::CACHE_STATE_PRESENT |
-    GDataCache::CACHE_STATE_PINNED |
-    GDataCache::CACHE_STATE_PERSISTENT,
+    CACHE_STATE_PRESENT |
+    CACHE_STATE_PINNED |
+    CACHE_STATE_PERSISTENT,
     "md5_pinned_existing", GDataCache::CACHE_TYPE_PERSISTENT },
   // Cache resource with a non-existent source file that is pinned, to test that
   // a pinned file can reference a non-existent file.
   { "", "pinned:non-existent", "md5_pinned_non_existent",
-    GDataCache::CACHE_STATE_PINNED,
+    CACHE_STATE_PINNED,
     "md5_pinned_non_existent", GDataCache::CACHE_TYPE_TMP },
   // Cache resource that is dirty, to test a dirty file is in persistent dir
   // with a symlink in outgoing dir referencing it.
   { "account_metadata.json", "dirty:existing", "md5_dirty_existing",
-    GDataCache::CACHE_STATE_PRESENT |
-    GDataCache::CACHE_STATE_DIRTY |
-    GDataCache::CACHE_STATE_PERSISTENT,
+    CACHE_STATE_PRESENT |
+    CACHE_STATE_DIRTY |
+    CACHE_STATE_PERSISTENT,
      "local", GDataCache::CACHE_TYPE_PERSISTENT },
   // Cache resource that is pinned and dirty, to test a dirty pinned file is in
   // persistent dir with symlink in pinned and outgoing dirs referencing it.
   { "basic_feed.json", "dirty_and_pinned:existing",
     "md5_dirty_and_pinned_existing",
-    GDataCache::CACHE_STATE_PRESENT |
-    GDataCache::CACHE_STATE_PINNED |
-    GDataCache::CACHE_STATE_DIRTY |
-    GDataCache::CACHE_STATE_PERSISTENT,
+    CACHE_STATE_PRESENT |
+    CACHE_STATE_PINNED |
+    CACHE_STATE_DIRTY |
+    CACHE_STATE_PERSISTENT,
      "local", GDataCache::CACHE_TYPE_PERSISTENT },
 };
 
 const int64 kLotsOfSpace = kMinFreeSpace * 10;
 
 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;
 };
 
-// Converts |cache_state| to a GDataCache::CacheEntry.
-GDataCache::CacheEntry ToCacheEntry(int cache_state) {
-  return GDataCache::CacheEntry("dummy_md5", cache_state);
+// Converts |cache_state| to a GDataCacheEntry.
+GDataCacheEntry ToCacheEntry(int cache_state) {
+  return GDataCacheEntry("dummy_md5", cache_state);
 }
 
 }  // namespace
 
 class MockFreeDiskSpaceGetter : public FreeDiskSpaceGetterInterface {
  public:
   virtual ~MockFreeDiskSpaceGetter() {}
   MOCK_CONST_METHOD0(AmountOfFreeDiskSpace, int64());
 };
 
@@ skipping 223 matching lines @@
           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 (ToCacheEntry(resource.cache_state).IsPresent())
          md5 = resource.md5;
-      scoped_ptr<GDataCache::CacheEntry> cache_entry =
+      scoped_ptr<GDataCacheEntry> 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());
+                GDataCache::GetSubDirectoryType(*cache_entry));
     }
   }
 
   void TestGetFileFromCacheByResourceIdAndMd5(
       const std::string& resource_id,
       const std::string& md5,
       base::PlatformFileError expected_error,
       const std::string& expected_file_extension) {
     expected_error_ = expected_error;
     expected_file_extension_ = expected_file_extension;
@@ skipping 61 matching lines @@
   }
 
   void VerifyRemoveFromCache(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 =
+    scoped_ptr<GDataCacheEntry> cache_entry =
         GetCacheEntryFromOriginThread(resource_id, md5);
     if (cache_entry.get())
       EXPECT_TRUE(cache_entry->IsDirty());
 
     // If entry doesn't exist, verify that:
     // - no files with "<resource_id>.* exists in persistent and tmp dirs
     // - no "<resource_id>" symlink exists in pinned and outgoing dirs.
     std::vector<PathToVerify> paths_to_verify;
     paths_to_verify.push_back(  // Index 0: CACHE_TYPE_TMP.
         PathToVerify(cache_->GetCacheFilePath(resource_id, "*",
@@ skipping 119 matching lines @@
     expected_cache_state_ = expected_cache_state;
 
     cache_->GetCacheEntryOnUIThread(resource_id, md5,
         base::Bind(&GDataCacheTest::VerifyGetCacheState,
                    base::Unretained(this)));
 
     test_util::RunBlockingPoolTask();
   }
 
   void VerifyGetCacheState(bool success,
-                           const GDataCache::CacheEntry& cache_entry) {
+                           const GDataCacheEntry& cache_entry) {
     ++num_callback_invocations_;
 
     EXPECT_EQ(expected_success_, success);
 
     if (success) {
       EXPECT_EQ(expected_cache_state_, cache_entry.cache_state());
     }
   }
 
   void TestMarkDirty(
@@ skipping 107 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 =
+    scoped_ptr<GDataCacheEntry> 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_sub_dir_type_, cache_entry->GetSubDirectoryType());
+      EXPECT_EQ(expected_sub_dir_type_,
+                GDataCache::GetSubDirectoryType(*cache_entry));
     } else {
       EXPECT_FALSE(cache_entry.get());
     }
 
     // Verify actual cache file.
     FilePath dest_path = cache_->GetCacheFilePath(
         resource_id,
         md5,
         ToCacheEntry(expected_cache_state_).IsPinned() ||
         ToCacheEntry(expected_cache_state_).IsDirty() ?
@@ skipping 51 matching lines @@
 
   FilePath GetCacheFilePath(const std::string& resource_id,
                             const std::string& md5,
                             GDataCache::CacheSubDirectoryType sub_dir_type,
                             GDataCache::CachedFileOrigin file_origin) {
     return cache_->GetCacheFilePath(resource_id, md5, sub_dir_type,
                                     file_origin);
   }
 
   // Helper function to call GetCacheEntry from origin thread.
-  scoped_ptr<GDataCache::CacheEntry> GetCacheEntryFromOriginThread(
+  scoped_ptr<GDataCacheEntry> GetCacheEntryFromOriginThread(
       const std::string& resource_id,
       const std::string& md5) {
-    scoped_ptr<GDataCache::CacheEntry> cache_entry;
+    scoped_ptr<GDataCacheEntry> cache_entry;
     content::BrowserThread::GetBlockingPool()
         ->GetSequencedTaskRunner(sequence_token_)->PostTask(
             FROM_HERE,
             base::Bind(
                 &GDataCacheTest::GetCacheEntryFromOriginThreadInternal,
                 base::Unretained(this),
                 resource_id,
                 md5,
                 &cache_entry));
     test_util::RunBlockingPoolTask();
     return cache_entry.Pass();
   }
 
   // Used to implement GetCacheEntry.
   void GetCacheEntryFromOriginThreadInternal(
       const std::string& resource_id,
       const std::string& md5,
-      scoped_ptr<GDataCache::CacheEntry>* cache_entry) {
+      scoped_ptr<GDataCacheEntry>* cache_entry) {
     cache_entry->reset(cache_->GetCacheEntry(resource_id, md5).release());
   }
 
   // Returns true if the cache entry exists for the given resource ID and MD5.
   bool CacheEntryExists(const std::string& resource_id,
                         const std::string& md5) {
     return GetCacheEntryFromOriginThread(resource_id, md5).get();
   }
 
   void TestGetCacheFilePath(const std::string& resource_id,
@@ skipping 66 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_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.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.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.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.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.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());
-
-  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.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_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_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_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_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_);
 
   // Use non-alphanumeric characters for resource id, including '.' which is an
   // extension separator, to test that the characters are escaped and unescaped
   // correctly, and '.' doesn't mess up the filename format and operations.
   resource_id = "pdf:`~!@#$%^&*()-_=+[{|]}\\;',<.>/?";
   std::string escaped_resource_id = util::EscapeCacheFileName(resource_id);
   std::string escaped_md5 = util::EscapeCacheFileName(md5);
   num_callback_invocations_ = 0;
   TestGetCacheFilePath(resource_id, md5,
                        escaped_resource_id + FilePath::kExtensionSeparator +
                        escaped_md5);
   EXPECT_EQ(0, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, StoreToCacheSimple) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // Store an existing file.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Store a non-existent file to the same |resource_id| and |md5|.
   num_callback_invocations_ = 0;
   TestStoreToCache(resource_id, md5, FilePath("./non_existent.json"),
                    base::PLATFORM_FILE_ERROR_NOT_FOUND,
-                   GDataCache::CACHE_STATE_PRESENT,
+                   CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Store a different existing file to the same |resource_id| but different
   // |md5|.
   md5 = "new_md5";
   num_callback_invocations_ = 0;
   TestStoreToCache(resource_id, md5, GetTestFilePath("subdir_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, 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, "*",
       (ToCacheEntry(expected_cache_state_).IsPinned() ?
        GDataCache::CACHE_TYPE_PERSISTENT :
        GDataCache::CACHE_TYPE_TMP),
@@ skipping 11 matching lines @@
               current.BaseName().value());
   }
   EXPECT_EQ(1U, num_files_found);
 }
 
 TEST_F(GDataCacheTest, GetFromCacheSimple) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   // First store a file to cache.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Then try to get the existing file from cache.
   num_callback_invocations_ = 0;
   TestGetFileFromCacheByResourceIdAndMd5(
       resource_id, md5, base::PLATFORM_FILE_OK, md5);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Get file from cache with same resource id as existing file but different
   // md5.
@@ skipping 10 matching lines @@
       resource_id, md5, base::PLATFORM_FILE_ERROR_NOT_FOUND, md5);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, RemoveFromCacheSimple) {
   // Use alphanumeric characters for resource id.
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   // First store a file to cache.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Then try to remove existing file from cache.
   num_callback_invocations_ = 0;
   TestRemoveFromCache(resource_id, base::PLATFORM_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Repeat using non-alphanumeric characters for resource id, including '.'
   // which is an extension separator.
   resource_id = "pdf:`~!@#$%^&*()-_=+[{|]}\\;',<.>/?";
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   num_callback_invocations_ = 0;
   TestRemoveFromCache(resource_id, base::PLATFORM_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, PinAndUnpin) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_sync_client_, OnCachePinned(resource_id, md5)).Times(2);
   EXPECT_CALL(*mock_sync_client_, OnCacheUnpinned(resource_id, md5)).Times(1);
 
   // First store a file to cache.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Pin the existing file in cache.
   num_callback_invocations_ = 0;
   TestPin(resource_id, md5, base::PLATFORM_FILE_OK,
-          GDataCache::CACHE_STATE_PRESENT | GDataCache::CACHE_STATE_PINNED |
-          GDataCache::CACHE_STATE_PERSISTENT,
+          CACHE_STATE_PRESENT | CACHE_STATE_PINNED |
+          CACHE_STATE_PERSISTENT,
           GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Unpin the existing file in cache.
   num_callback_invocations_ = 0;
   TestUnpin(resource_id, md5, base::PLATFORM_FILE_OK,
-            GDataCache::CACHE_STATE_PRESENT,
+            CACHE_STATE_PRESENT,
             GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Pin back the same existing file in cache.
   num_callback_invocations_ = 0;
   TestPin(resource_id, md5, base::PLATFORM_FILE_OK,
-          GDataCache::CACHE_STATE_PRESENT | GDataCache::CACHE_STATE_PINNED |
-          GDataCache::CACHE_STATE_PERSISTENT,
+          CACHE_STATE_PRESENT | CACHE_STATE_PINNED |
+          CACHE_STATE_PERSISTENT,
           GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Pin a non-existent file in cache.
   resource_id = "document:1a2b";
   EXPECT_CALL(*mock_sync_client_, OnCachePinned(resource_id, md5)).Times(1);
   EXPECT_CALL(*mock_sync_client_, OnCacheUnpinned(resource_id, md5)).Times(1);
 
   num_callback_invocations_ = 0;
   TestPin(resource_id, md5, base::PLATFORM_FILE_OK,
-          GDataCache::CACHE_STATE_PINNED,
+          CACHE_STATE_PINNED,
           GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Unpin the previously pinned non-existent file in cache.
   num_callback_invocations_ = 0;
   TestUnpin(resource_id, md5, base::PLATFORM_FILE_OK,
-            GDataCache::CACHE_STATE_NONE,
+            CACHE_STATE_NONE,
             GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Unpin a file that doesn't exist in cache and is not pinned, i.e. cache
   // has zero knowledge of the file.
   resource_id = "not-in-cache:1a2b";
   // Because unpinning will fail, OnCacheUnpinned() won't be run.
   EXPECT_CALL(*mock_sync_client_, OnCacheUnpinned(resource_id, md5)).Times(0);
 
   num_callback_invocations_ = 0;
   TestUnpin(resource_id, md5, base::PLATFORM_FILE_ERROR_NOT_FOUND,
-            GDataCache::CACHE_STATE_NONE,
+            CACHE_STATE_NONE,
             GDataCache::CACHE_TYPE_TMP /* non-applicable */);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, StoreToCachePinned) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_sync_client_, OnCachePinned(resource_id, md5)).Times(1);
 
   // Pin a non-existent file.
   TestPin(resource_id, md5, base::PLATFORM_FILE_OK,
-          GDataCache::CACHE_STATE_PINNED,
+          CACHE_STATE_PINNED,
           GDataCache::CACHE_TYPE_TMP);
 
   // Store an existing file to a previously pinned file.
   num_callback_invocations_ = 0;
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
                    base::PLATFORM_FILE_OK,
-                   GDataCache::CACHE_STATE_PRESENT |
-                   GDataCache::CACHE_STATE_PINNED |
-                   GDataCache::CACHE_STATE_PERSISTENT,
+                   CACHE_STATE_PRESENT |
+                   CACHE_STATE_PINNED |
+                   CACHE_STATE_PERSISTENT,
                    GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Store a non-existent file to a previously pinned and stored file.
   num_callback_invocations_ = 0;
   TestStoreToCache(resource_id, md5, FilePath("./non_existent.json"),
                    base::PLATFORM_FILE_ERROR_NOT_FOUND,
-                   GDataCache::CACHE_STATE_PRESENT |
-                   GDataCache::CACHE_STATE_PINNED |
-                   GDataCache::CACHE_STATE_PERSISTENT,
+                   CACHE_STATE_PRESENT |
+                   CACHE_STATE_PINNED |
+                   CACHE_STATE_PERSISTENT,
                    GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, GetFromCachePinned) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_sync_client_, OnCachePinned(resource_id, md5)).Times(1);
 
   // Pin a non-existent file.
   TestPin(resource_id, md5, base::PLATFORM_FILE_OK,
-          GDataCache::CACHE_STATE_PINNED,
+          CACHE_STATE_PINNED,
           GDataCache::CACHE_TYPE_TMP);
 
   // Get the non-existent pinned file from cache.
   num_callback_invocations_ = 0;
   TestGetFileFromCacheByResourceIdAndMd5(
       resource_id, md5, base::PLATFORM_FILE_ERROR_NOT_FOUND, md5);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Store an existing file to the previously pinned non-existent file.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
                    base::PLATFORM_FILE_OK,
-                   GDataCache::CACHE_STATE_PRESENT |
-                   GDataCache::CACHE_STATE_PINNED |
-                   GDataCache::CACHE_STATE_PERSISTENT,
+                   CACHE_STATE_PRESENT |
+                   CACHE_STATE_PINNED |
+                   CACHE_STATE_PERSISTENT,
                    GDataCache::CACHE_TYPE_PERSISTENT);
 
   // Get the previously pinned and stored file from cache.
   num_callback_invocations_ = 0;
   TestGetFileFromCacheByResourceIdAndMd5(
       resource_id, md5, base::PLATFORM_FILE_OK, md5);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, RemoveFromCachePinned) {
   // Use alphanumeric characters for resource_id.
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_sync_client_, OnCachePinned(resource_id, md5)).Times(1);
 
   // Store a file to cache, and pin it.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   TestPin(resource_id, md5, base::PLATFORM_FILE_OK,
-          GDataCache::CACHE_STATE_PRESENT | GDataCache::CACHE_STATE_PINNED |
-          GDataCache::CACHE_STATE_PERSISTENT,
+          CACHE_STATE_PRESENT | CACHE_STATE_PINNED |
+          CACHE_STATE_PERSISTENT,
           GDataCache::CACHE_TYPE_PERSISTENT);
 
   // Remove |resource_id| from cache.
   num_callback_invocations_ = 0;
   TestRemoveFromCache(resource_id, base::PLATFORM_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Repeat using non-alphanumeric characters for resource id, including '.'
   // which is an extension separator.
   resource_id = "pdf:`~!@#$%^&*()-_=+[{|]}\\;',<.>/?";
   EXPECT_CALL(*mock_sync_client_, OnCachePinned(resource_id, md5)).Times(1);
 
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   TestPin(resource_id, md5, base::PLATFORM_FILE_OK,
-          GDataCache::CACHE_STATE_PRESENT | GDataCache::CACHE_STATE_PINNED |
-          GDataCache::CACHE_STATE_PERSISTENT,
+          CACHE_STATE_PRESENT | CACHE_STATE_PINNED |
+          CACHE_STATE_PERSISTENT,
           GDataCache::CACHE_TYPE_PERSISTENT);
 
   num_callback_invocations_ = 0;
   TestRemoveFromCache(resource_id, base::PLATFORM_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, DirtyCacheSimple) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_sync_client_, OnCacheCommitted(resource_id)).Times(1);
 
   // First store a file to cache.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Mark the file dirty.
   num_callback_invocations_ = 0;
   TestMarkDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                GDataCache::CACHE_STATE_PRESENT |
-                GDataCache::CACHE_STATE_DIRTY |
-                GDataCache::CACHE_STATE_PERSISTENT,
+                CACHE_STATE_PRESENT |
+                CACHE_STATE_DIRTY |
+                CACHE_STATE_PERSISTENT,
                 GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Commit the file dirty.
   num_callback_invocations_ = 0;
   TestCommitDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                  GDataCache::CACHE_STATE_PRESENT |
-                  GDataCache::CACHE_STATE_DIRTY |
-                  GDataCache::CACHE_STATE_PERSISTENT,
+                  CACHE_STATE_PRESENT |
+                  CACHE_STATE_DIRTY |
+                  CACHE_STATE_PERSISTENT,
                   GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Clear dirty state of the file.
   num_callback_invocations_ = 0;
   TestClearDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                 GDataCache::CACHE_STATE_PRESENT,
+                 CACHE_STATE_PRESENT,
                  GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, DirtyCachePinned) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_sync_client_, OnCachePinned(resource_id, md5)).Times(1);
   EXPECT_CALL(*mock_sync_client_, OnCacheCommitted(resource_id)).Times(1);
 
   // First store a file to cache and pin it.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   TestPin(resource_id, md5, base::PLATFORM_FILE_OK,
-          GDataCache::CACHE_STATE_PRESENT | GDataCache::CACHE_STATE_PINNED |
-          GDataCache::CACHE_STATE_PERSISTENT,
+          CACHE_STATE_PRESENT | CACHE_STATE_PINNED |
+          CACHE_STATE_PERSISTENT,
           GDataCache::CACHE_TYPE_PERSISTENT);
 
   // Mark the file dirty.
   num_callback_invocations_ = 0;
   TestMarkDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                GDataCache::CACHE_STATE_PRESENT |
-                GDataCache::CACHE_STATE_DIRTY |
-                GDataCache::CACHE_STATE_PINNED |
-                GDataCache::CACHE_STATE_PERSISTENT,
+                CACHE_STATE_PRESENT |
+                CACHE_STATE_DIRTY |
+                CACHE_STATE_PINNED |
+                CACHE_STATE_PERSISTENT,
                 GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Commit the file dirty.
   num_callback_invocations_ = 0;
   TestCommitDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                  GDataCache::CACHE_STATE_PRESENT |
-                  GDataCache::CACHE_STATE_DIRTY |
-                  GDataCache::CACHE_STATE_PINNED |
-                  GDataCache::CACHE_STATE_PERSISTENT,
+                  CACHE_STATE_PRESENT |
+                  CACHE_STATE_DIRTY |
+                  CACHE_STATE_PINNED |
+                  CACHE_STATE_PERSISTENT,
                   GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Clear dirty state of the file.
   num_callback_invocations_ = 0;
   TestClearDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                 GDataCache::CACHE_STATE_PRESENT |
-                 GDataCache::CACHE_STATE_PINNED |
-                 GDataCache::CACHE_STATE_PERSISTENT,
+                 CACHE_STATE_PRESENT |
+                 CACHE_STATE_PINNED |
+                 CACHE_STATE_PERSISTENT,
                  GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 // Test is disabled because it is flaky (http://crbug.com/134146)
 TEST_F(GDataCacheTest, PinAndUnpinDirtyCache) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_sync_client_, OnCachePinned(resource_id, md5)).Times(1);
   EXPECT_CALL(*mock_sync_client_, OnCacheUnpinned(resource_id, md5)).Times(1);
 
   // First store a file to cache and mark it as dirty.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   TestMarkDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                GDataCache::CACHE_STATE_PRESENT |
-                GDataCache::CACHE_STATE_DIRTY |
-                GDataCache::CACHE_STATE_PERSISTENT,
+                CACHE_STATE_PRESENT |
+                CACHE_STATE_DIRTY |
+                CACHE_STATE_PERSISTENT,
                 GDataCache::CACHE_TYPE_PERSISTENT);
 
   // Verifies dirty file exists.
   FilePath dirty_path = GetCacheFilePath(
       resource_id,
       md5,
       GDataCache::CACHE_TYPE_PERSISTENT,
       GDataCache::CACHED_FILE_LOCALLY_MODIFIED);
   EXPECT_TRUE(file_util::PathExists(dirty_path));
 
   // Pin the dirty file.
   TestPin(resource_id, md5, base::PLATFORM_FILE_OK,
-          GDataCache::CACHE_STATE_PRESENT | GDataCache::CACHE_STATE_DIRTY |
-          GDataCache::CACHE_STATE_PINNED | GDataCache::CACHE_STATE_PERSISTENT,
+          CACHE_STATE_PRESENT | CACHE_STATE_DIRTY |
+          CACHE_STATE_PINNED | CACHE_STATE_PERSISTENT,
           GDataCache::CACHE_TYPE_PERSISTENT);
 
   // Verify dirty file still exist at the same pathname.
   EXPECT_TRUE(file_util::PathExists(dirty_path));
 
   // Unpin the dirty file.
   TestUnpin(resource_id, md5, base::PLATFORM_FILE_OK,
-            GDataCache::CACHE_STATE_PRESENT | GDataCache::CACHE_STATE_DIRTY |
-            GDataCache::CACHE_STATE_PERSISTENT,
+            CACHE_STATE_PRESENT | CACHE_STATE_DIRTY |
+            CACHE_STATE_PERSISTENT,
             GDataCache::CACHE_TYPE_PERSISTENT);
 
   // Verify dirty file still exist at the same pathname.
   EXPECT_TRUE(file_util::PathExists(dirty_path));
 }
 
 TEST_F(GDataCacheTest, DirtyCacheRepetitive) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_sync_client_, OnCacheCommitted(resource_id)).Times(3);
 
   // First store a file to cache.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Mark the file dirty.
   num_callback_invocations_ = 0;
   TestMarkDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                GDataCache::CACHE_STATE_PRESENT |
-                GDataCache::CACHE_STATE_DIRTY |
-                GDataCache::CACHE_STATE_PERSISTENT,
+                CACHE_STATE_PRESENT |
+                CACHE_STATE_DIRTY |
+                CACHE_STATE_PERSISTENT,
                 GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Again, mark the file dirty.  Nothing should change.
   num_callback_invocations_ = 0;
   TestMarkDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                GDataCache::CACHE_STATE_PRESENT |
-                GDataCache::CACHE_STATE_DIRTY |
-                GDataCache::CACHE_STATE_PERSISTENT,
+                CACHE_STATE_PRESENT |
+                CACHE_STATE_DIRTY |
+                CACHE_STATE_PERSISTENT,
                 GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Commit the file dirty.  Outgoing symlink should be created.
   num_callback_invocations_ = 0;
   TestCommitDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                  GDataCache::CACHE_STATE_PRESENT |
-                  GDataCache::CACHE_STATE_DIRTY |
-                  GDataCache::CACHE_STATE_PERSISTENT,
+                  CACHE_STATE_PRESENT |
+                  CACHE_STATE_DIRTY |
+                  CACHE_STATE_PERSISTENT,
                   GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Again, commit the file dirty.  Nothing should change.
   num_callback_invocations_ = 0;
   TestCommitDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                  GDataCache::CACHE_STATE_PRESENT |
-                  GDataCache::CACHE_STATE_DIRTY |
-                  GDataCache::CACHE_STATE_PERSISTENT,
+                  CACHE_STATE_PRESENT |
+                  CACHE_STATE_DIRTY |
+                  CACHE_STATE_PERSISTENT,
                   GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Mark the file dirty agian after it's being committed.  Outgoing symlink
   // should be deleted.
   num_callback_invocations_ = 0;
   TestMarkDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                GDataCache::CACHE_STATE_PRESENT |
-                GDataCache::CACHE_STATE_DIRTY |
-                GDataCache::CACHE_STATE_PERSISTENT,
+                CACHE_STATE_PRESENT |
+                CACHE_STATE_DIRTY |
+                CACHE_STATE_PERSISTENT,
                 GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Commit the file dirty.  Outgoing symlink should be created again.
   num_callback_invocations_ = 0;
   TestCommitDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                  GDataCache::CACHE_STATE_PRESENT |
-                  GDataCache::CACHE_STATE_DIRTY |
-                  GDataCache::CACHE_STATE_PERSISTENT,
+                  CACHE_STATE_PRESENT |
+                  CACHE_STATE_DIRTY |
+                  CACHE_STATE_PERSISTENT,
                   GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Clear dirty state of the file.
   num_callback_invocations_ = 0;
   TestClearDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                 GDataCache::CACHE_STATE_PRESENT,
+                 CACHE_STATE_PRESENT,
                  GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Again, clear dirty state of the file, which is no longer dirty.
   num_callback_invocations_ = 0;
   TestClearDirty(resource_id, md5, base::PLATFORM_FILE_ERROR_INVALID_OPERATION,
-                 GDataCache::CACHE_STATE_PRESENT,
+                 CACHE_STATE_PRESENT,
                  GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, DirtyCacheInvalid) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // Mark a non-existent file dirty.
   num_callback_invocations_ = 0;
   TestMarkDirty(resource_id, md5, base::PLATFORM_FILE_ERROR_NOT_FOUND,
-                GDataCache::CACHE_STATE_NONE,
+                CACHE_STATE_NONE,
                 GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Commit a non-existent file dirty.
   num_callback_invocations_ = 0;
   TestCommitDirty(resource_id, md5, base::PLATFORM_FILE_ERROR_NOT_FOUND,
-                  GDataCache::CACHE_STATE_NONE,
+                  CACHE_STATE_NONE,
                   GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Clear dirty state of a non-existent file.
   num_callback_invocations_ = 0;
   TestClearDirty(resource_id, md5, base::PLATFORM_FILE_ERROR_NOT_FOUND,
-                 GDataCache::CACHE_STATE_NONE,
+                 CACHE_STATE_NONE,
                  GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Store a file to cache.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Commit a non-dirty existing file dirty.
   num_callback_invocations_ = 0;
   TestCommitDirty(resource_id, md5, base::PLATFORM_FILE_ERROR_INVALID_OPERATION,
-                 GDataCache::CACHE_STATE_PRESENT,
+                 CACHE_STATE_PRESENT,
                  GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Clear dirty state of a non-dirty existing file.
   num_callback_invocations_ = 0;
   TestClearDirty(resource_id, md5, base::PLATFORM_FILE_ERROR_INVALID_OPERATION,
-                 GDataCache::CACHE_STATE_PRESENT,
+                 CACHE_STATE_PRESENT,
                  GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Mark an existing file dirty, then store a new file to the same resource id
   // but different md5, which should fail.
   TestMarkDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                GDataCache::CACHE_STATE_PRESENT |
-                GDataCache::CACHE_STATE_DIRTY |
-                GDataCache::CACHE_STATE_PERSISTENT,
+                CACHE_STATE_PRESENT |
+                CACHE_STATE_DIRTY |
+                CACHE_STATE_PERSISTENT,
                 GDataCache::CACHE_TYPE_PERSISTENT);
   num_callback_invocations_ = 0;
   md5 = "new_md5";
   TestStoreToCache(resource_id, md5, GetTestFilePath("subdir_feed.json"),
                    base::PLATFORM_FILE_ERROR_IN_USE,
-                   GDataCache::CACHE_STATE_PRESENT |
-                   GDataCache::CACHE_STATE_DIRTY |
-                   GDataCache::CACHE_STATE_PERSISTENT,
+                   CACHE_STATE_PRESENT |
+                   CACHE_STATE_DIRTY |
+                   CACHE_STATE_PERSISTENT,
                    GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, RemoveFromDirtyCache) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_sync_client_, OnCachePinned(resource_id, md5)).Times(1);
   EXPECT_CALL(*mock_sync_client_, OnCacheCommitted(resource_id)).Times(1);
 
   // Store a file to cache, pin it, mark it dirty and commit it.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   TestPin(resource_id, md5, base::PLATFORM_FILE_OK,
-          GDataCache::CACHE_STATE_PRESENT | GDataCache::CACHE_STATE_PINNED |
-          GDataCache::CACHE_STATE_PERSISTENT,
+          CACHE_STATE_PRESENT | CACHE_STATE_PINNED |
+          CACHE_STATE_PERSISTENT,
           GDataCache::CACHE_TYPE_PERSISTENT);
   TestMarkDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                GDataCache::CACHE_STATE_PRESENT |
-                GDataCache::CACHE_STATE_PINNED |
-                GDataCache::CACHE_STATE_DIRTY |
-                GDataCache::CACHE_STATE_PERSISTENT,
+                CACHE_STATE_PRESENT |
+                CACHE_STATE_PINNED |
+                CACHE_STATE_DIRTY |
+                CACHE_STATE_PERSISTENT,
                 GDataCache::CACHE_TYPE_PERSISTENT);
   TestCommitDirty(resource_id, md5, base::PLATFORM_FILE_OK,
-                  GDataCache::CACHE_STATE_PRESENT |
-                  GDataCache::CACHE_STATE_PINNED |
-                  GDataCache::CACHE_STATE_DIRTY |
-                  GDataCache::CACHE_STATE_PERSISTENT,
+                  CACHE_STATE_PRESENT |
+                  CACHE_STATE_PINNED |
+                  CACHE_STATE_DIRTY |
+                  CACHE_STATE_PERSISTENT,
                   GDataCache::CACHE_TYPE_PERSISTENT);
 
   // Try to remove the file.  Since file is dirty, it and the corresponding
   // pinned and outgoing symlinks should not be removed.
   num_callback_invocations_ = 0;
   TestRemoveFromCache(resource_id, base::PLATFORM_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, GetCacheState) {
   // Populate gdata file system.
   LoadRootFeedDocument("root_feed.json");
 
   {  // Test cache state of an existing normal file.
     // Retrieve resource id and md5 of a file from file system.
     FilePath file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
     GDataEntry* entry = FindEntry(file_path);
     ASSERT_TRUE(entry != NULL);
     GDataFile* file = entry->AsGDataFile();
     ASSERT_TRUE(file != NULL);
     std::string resource_id = file->resource_id();
     std::string md5 = file->file_md5();
 
     // Store a file corresponding to |resource_id| and |md5| to cache.
     TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                     base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                     base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                      GDataCache::CACHE_TYPE_TMP);
 
     // Get its cache state.
     num_callback_invocations_ = 0;
     TestGetCacheState(resource_id, md5, true,
-                      GDataCache::CACHE_STATE_PRESENT, file);
+                      CACHE_STATE_PRESENT, file);
     EXPECT_EQ(1, num_callback_invocations_);
   }
 
   {  // Test cache state of an existing pinned file.
     // Retrieve resource id and md5 of a file from file system.
     FilePath file_path(
         FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
     GDataEntry* entry = FindEntry(file_path);
     ASSERT_TRUE(entry != NULL);
     GDataFile* file = entry->AsGDataFile();
     ASSERT_TRUE(file != NULL);
     std::string resource_id = file->resource_id();
     std::string md5 = file->file_md5();
 
     EXPECT_CALL(*mock_sync_client_, OnCachePinned(resource_id, md5)).Times(1);
 
     // Store a file corresponding to |resource_id| and |md5| to cache, and pin
     // it.
-    int expected_cache_state = (GDataCache::CACHE_STATE_PRESENT |
-                                GDataCache::CACHE_STATE_PINNED |
-                                GDataCache::CACHE_STATE_PERSISTENT);
+    int expected_cache_state = (CACHE_STATE_PRESENT |
+                                CACHE_STATE_PINNED |
+                                CACHE_STATE_PERSISTENT);
     TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                     base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                     base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                      GDataCache::CACHE_TYPE_TMP);
     TestPin(resource_id, md5, base::PLATFORM_FILE_OK, expected_cache_state,
             GDataCache::CACHE_TYPE_PERSISTENT);
 
     // Get its cache state.
     num_callback_invocations_ = 0;
     TestGetCacheState(resource_id, md5, true,
                       expected_cache_state, file);
     EXPECT_EQ(1, num_callback_invocations_);
   }
 
   {  // Test cache state of a non-existent file.
     num_callback_invocations_ = 0;
     TestGetCacheState("pdf:12345", "abcd", false,
                       0, NULL);
     EXPECT_EQ(1, num_callback_invocations_);
   }
 }
 
 TEST_F(GDataCacheTest, MountUnmount) {
   FilePath file_path;
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // First store a file to cache in the tmp subdir.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
-                   base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
+                   base::PLATFORM_FILE_OK, CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Mark the file mounted.
   num_callback_invocations_ = 0;
   file_path = cache_->GetCacheFilePath(resource_id, md5,
                                        GDataCache::CACHE_TYPE_TMP,
                                        GDataCache::CACHED_FILE_FROM_SERVER);
   TestSetMountedState(resource_id, md5, file_path, true,
                       base::PLATFORM_FILE_OK,
-                      GDataCache::CACHE_STATE_PRESENT |
-                      GDataCache::CACHE_STATE_MOUNTED |
-                      GDataCache::CACHE_STATE_PERSISTENT,
+                      CACHE_STATE_PRESENT |
+                      CACHE_STATE_MOUNTED |
+                      CACHE_STATE_PERSISTENT,
                       GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
   EXPECT_TRUE(CacheEntryExists(resource_id, md5));
 
   // Clear mounted state of the file.
   num_callback_invocations_ = 0;
   file_path = cache_->GetCacheFilePath(resource_id,
                                        md5,
                                        GDataCache::CACHE_TYPE_PERSISTENT,
                                        GDataCache::CACHED_FILE_MOUNTED);
   TestSetMountedState(resource_id, md5, file_path, false,
                       base::PLATFORM_FILE_OK,
-                      GDataCache::CACHE_STATE_PRESENT,
+                      CACHE_STATE_PRESENT,
                       GDataCache::CACHE_TYPE_TMP);
   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