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

chrome/browser/chromeos/gdata/gdata_file_system_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 <errno.h>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 104 matching lines @@
   upload_file_info->gdata_path = gdata_path;
   upload_file_info->file_path = local_file_path;
   upload_file_info->entry.reset(document_entry);
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
       base::Bind(arg5, error, base::Passed(&upload_file_info)));
 
   const int kUploadId = 123;
   return kUploadId;
 }
 
+// Converts |cache_state| to a GDataCAche::CacheEntry.

[hashimoto, 2012/07/11 11:08:04]

nit: s/CAche/Cache/

[satorux1, 2012/07/11 19:54:42]

Done.

+GDataCache::CacheEntry ToCacheEntry(int cache_state) {
+  return GDataCache::CacheEntry("dummy_md5", cache_state);
+}
+
 }  // anonymous namespace

[hashimoto, 2012/07/11 11:08:04]

Could you fix this while you are at this file?
s/anonymous namespace/namespace/

[satorux1, 2012/07/11 19:54:42]

Done.

 
 class MockFreeDiskSpaceGetter : public FreeDiskSpaceGetterInterface {
  public:
   virtual ~MockFreeDiskSpaceGetter() {}
   MOCK_CONST_METHOD0(AmountOfFreeDiskSpace, int64());
 };
 
 class MockGDataUploader : public GDataUploaderInterface {
  public:
   virtual ~MockGDataUploader() {}
@@ skipping 556 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);
     }
   }
 
   void SetExpectationsForGetDocumentEntry(scoped_ptr<base::Value>* document,
                                           const std::string& resource_id) {
     EXPECT_CALL(*mock_doc_service_, GetDocumentEntry(resource_id, _))
         .WillOnce(MockGetDocumentEntryCallback(gdata::HTTP_SUCCESS, document));
@@ skipping 1853 matching lines @@
 
   // Try to close the same file twice.
   file_system_->CloseFile(kFileInRoot, close_file_callback);
   message_loop_.Run();
 
   // It must fail.
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 }
 
 }   // namespace gdata