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

chrome/browser/chromeos/gdata/gdata_cache.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.h"
 
 #include <vector>
 
 #include "base/chromeos/chromeos_version.h"
 #include "base/file_util.h"
@@ skipping 794 matching lines @@
 void GDataCache::Store(const std::string& resource_id,
                        const std::string& md5,
                        const FilePath& source_path,
                        FileOperationType file_operation_type,
                        base::PlatformFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   FilePath dest_path;
   FilePath symlink_path;
-  int cache_state = CACHE_STATE_PRESENT;
+  CacheEntry new_cache_entry(md5, CACHE_STATE_NONE);
   CacheSubDirectoryType sub_dir_type = CACHE_TYPE_TMP;
 
   scoped_ptr<CacheEntry> cache_entry = GetCacheEntry(resource_id, md5);
 
   // If file was previously pinned, store it in persistent dir and create
   // symlink in pinned dir.
   if (cache_entry.get()) {  // File exists in cache.
     // If file is dirty or mounted, return error.
     if (cache_entry->IsDirty() || cache_entry->IsMounted()) {
       LOG(WARNING) << "Can't store a file to replace a "
                    << (cache_entry->IsDirty() ? "dirty" : "mounted")
                    << " file: res_id=" << resource_id
                    << ", md5=" << md5;
       *error = base::PLATFORM_FILE_ERROR_IN_USE;
       return;
     }
 
-    cache_state |= cache_entry->cache_state;
+    new_cache_entry.cache_state = cache_entry->cache_state;
 
     // If file is pinned, determines destination path.
     if (cache_entry->IsPinned()) {
       sub_dir_type = CACHE_TYPE_PERSISTENT;
       dest_path = GetCacheFilePath(resource_id, md5, sub_dir_type,
                                    CACHED_FILE_FROM_SERVER);
       symlink_path = GetCacheFilePath(
           resource_id, std::string(), CACHE_TYPE_PINNED,
           CACHED_FILE_FROM_SERVER);
     }
@@ skipping 29 matching lines @@
     // Note that ReplaceExtension automatically prefixes the extension with the
     // extension separator '.'.
     stale_filenames_pattern = dest_path.ReplaceExtension(util::kWildCard);
   }
 
   // Delete files that match |stale_filenames_pattern| except for |dest_path|.
   DeleteFilesSelectively(stale_filenames_pattern, dest_path);
 
   if (*error == base::PLATFORM_FILE_OK) {
     // Now that file operations have completed, update cache map.
+    new_cache_entry.SetPresent(true);
     UpdateCacheWithSubDirectoryType(resource_id,
                                     sub_dir_type,
-                                    CacheEntry(md5, cache_state));
+                                    new_cache_entry);
   }
 }
 
 void GDataCache::Pin(const std::string& resource_id,
                      const std::string& md5,
                      FileOperationType file_operation_type,
                      base::PlatformFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   FilePath source_path;
   FilePath dest_path;
   FilePath symlink_path;
   bool create_symlink = true;
-  int cache_state = CACHE_STATE_PINNED;
+  CacheEntry new_cache_entry(md5, CACHE_STATE_NONE);
   CacheSubDirectoryType sub_dir_type = CACHE_TYPE_PERSISTENT;
 
   scoped_ptr<CacheEntry> cache_entry = GetCacheEntry(resource_id, md5);
 
   if (!cache_entry.get()) {  // Entry does not exist in cache.
     // Set both |dest_path| and |source_path| to /dev/null, so that:
     // 1) ModifyCacheState won't move files when |source_path| and |dest_path|
     //    are the same.
     // 2) symlinks to /dev/null will be picked up by GDataSyncClient to download
     //    pinned files that don't exist in cache.
     dest_path = FilePath::FromUTF8Unsafe(util::kSymLinkToDevNull);
     source_path = dest_path;
 
     // Set sub_dir_type to TMP. The file will be first downloaded in 'tmp',
     // then moved to 'persistent'.
     sub_dir_type = CACHE_TYPE_TMP;
   } else {  // File exists in cache, determines destination path.
-    cache_state |= cache_entry->cache_state;
+    new_cache_entry.cache_state = cache_entry->cache_state;
 
     // Determine source and destination paths.
 
     // If file is dirty or mounted, don't move it, so determine |dest_path| and
     // set |source_path| the same, because ModifyCacheState only moves files if
     // source and destination are different.
     if (cache_entry->IsDirty() || cache_entry->IsMounted()) {
       DCHECK(cache_entry->IsPersistent());
       dest_path = GetCacheFilePath(resource_id,
                                    md5,
@@ skipping 33 matching lines @@
   }
 
   *error = ModifyCacheState(source_path,
                             dest_path,
                             file_operation_type,
                             symlink_path,
                             create_symlink);
 
   if (*error == base::PLATFORM_FILE_OK) {
     // Now that file operations have completed, update cache map.
+    new_cache_entry.SetPinned(true);
     UpdateCacheWithSubDirectoryType(resource_id,
                                     sub_dir_type,
-                                    CacheEntry(md5, cache_state));
+                                    new_cache_entry);
   }
 }
 
 void GDataCache::Unpin(const std::string& resource_id,
                        const std::string& md5,
                        FileOperationType file_operation_type,
                        base::PlatformFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
@@ skipping 57 matching lines @@
 
   *error = ModifyCacheState(
       source_path,
       dest_path,
       file_operation_type,
       symlink_path,  // This will be deleted if it exists.
       false /* don't create symlink*/);
 
   if (*error == base::PLATFORM_FILE_OK) {
     // Now that file operations have completed, update cache map.
-    int cache_state = ClearCachePinned(cache_entry->cache_state);
+    CacheEntry new_cache_entry(md5, cache_entry->cache_state);
+    new_cache_entry.SetPinned(false);
     UpdateCacheWithSubDirectoryType(resource_id,
                                     sub_dir_type,
-                                    CacheEntry(md5, cache_state));
+                                    new_cache_entry);
   }
 }
 
 void GDataCache::SetMountedState(const FilePath& file_path,
                                  bool to_mount,
                                  base::PlatformFileError *error,
                                  FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
   DCHECK(cache_file_path);
@@ skipping 25 matching lines @@
       resource_id, md5, unmounted_subdir, CACHED_FILE_FROM_SERVER);
 
   // Get the subdir type and path for the mounted state.
   CacheSubDirectoryType mounted_subdir = CACHE_TYPE_PERSISTENT;
   FilePath mounted_path = GetCacheFilePath(
       resource_id, md5, mounted_subdir, CACHED_FILE_MOUNTED);
 
   // Determine the source and destination paths for moving the cache blob.
   FilePath source_path;
   CacheSubDirectoryType dest_subdir;
-  int cache_state = cache_entry->cache_state;
+  CacheEntry new_cache_entry(md5, cache_entry->cache_state);
   if (to_mount) {
     source_path = unmounted_path;
     *cache_file_path = mounted_path;
     dest_subdir = mounted_subdir;
-    cache_state = SetCacheMounted(cache_state);
+    new_cache_entry.SetMounted(true);
   } else {
     source_path = mounted_path;
     *cache_file_path = unmounted_path;
     dest_subdir = unmounted_subdir;
-    cache_state = ClearCacheMounted(cache_state);
+    new_cache_entry.SetMounted(false);
   }
 
   // Move cache blob from source path to destination path.
   *error = ModifyCacheState(source_path, *cache_file_path,
                             FILE_OPERATION_MOVE, FilePath(), false);
   if (*error == base::PLATFORM_FILE_OK) {
     // Now that cache operation is complete, update cache map
     UpdateCacheWithSubDirectoryType(resource_id,
                                     dest_subdir,
-                                    CacheEntry(md5, cache_state));
+                                    new_cache_entry);
   }
 }
 
 void GDataCache::MarkDirty(const std::string& resource_id,
                            const std::string& md5,
                            FileOperationType file_operation_type,
                            base::PlatformFileError* error,
                            FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
@@ skipping 81 matching lines @@
 
   *error = ModifyCacheState(
       source_path,
       *cache_file_path,
       file_operation_type,
       symlink_path,
       !symlink_path.empty() /* create symlink */);
 
   if (*error == base::PLATFORM_FILE_OK) {
     // Now that file operations have completed, update cache map.
-    int cache_state = SetCacheDirty(cache_entry->cache_state);
+    CacheEntry new_cache_entry(md5, cache_entry->cache_state);
+    new_cache_entry.SetDirty(true);
     UpdateCacheWithSubDirectoryType(resource_id,
                                     sub_dir_type,
-                                    CacheEntry(md5, cache_state));
+                                    new_cache_entry);
   }
 }
 
 void GDataCache::CommitDirty(const std::string& resource_id,
                              const std::string& md5,
                              FileOperationType file_operation_type,
                              base::PlatformFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
@@ skipping 124 matching lines @@
     // if source and destination are different.
     *error = ModifyCacheState(dest_path,  // source path
                               dest_path,  // destination path
                               file_operation_type,
                               symlink_path,
                               true /* create symlink */);
   }
 
   if (*error == base::PLATFORM_FILE_OK) {
     // Now that file operations have completed, update cache map.
-    int cache_state = ClearCacheDirty(cache_entry->cache_state);
-   UpdateCacheWithSubDirectoryType(resource_id,
+    CacheEntry new_cache_entry(md5, cache_entry->cache_state);
+    new_cache_entry.SetDirty(false);
+    UpdateCacheWithSubDirectoryType(resource_id,
                                     sub_dir_type,
-                                    CacheEntry(md5, cache_state));
+                                    new_cache_entry);
   }
 }
 
 void GDataCache::Remove(const std::string& resource_id,
                         base::PlatformFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   // MD5 is not passed into RemoveFromCache and hence
   // RemoveFromCacheOnBlockingPool, because we would delete all cache files
@@ skipping 122 matching lines @@
 }
 
 void GDataCache::UpdateCacheWithSubDirectoryType(
     const std::string& resource_id,
     CacheSubDirectoryType sub_dir_type,
     const CacheEntry& in_cache_entry) {
   DCHECK(sub_dir_type == CACHE_TYPE_PERSISTENT ||
          sub_dir_type == CACHE_TYPE_TMP);
 
   CacheEntry cache_entry = in_cache_entry;
-  if (sub_dir_type == CACHE_TYPE_PERSISTENT)
-    cache_entry.cache_state = SetCachePersistent(cache_entry.cache_state);
-  else
-    cache_entry.cache_state = ClearCachePersistent(cache_entry.cache_state);
+  cache_entry.SetPersistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
 
   metadata_->UpdateCache(resource_id, cache_entry);
 }
 
 // static
 FilePath GDataCache::GetCacheRootPath(Profile* profile) {
   FilePath cache_base_path;
   chrome::GetUserCacheDirectory(profile->GetPath(), &cache_base_path);
   FilePath cache_root_path =
       cache_base_path.Append(chrome::kGDataCacheDirname);
@@ skipping 34 matching lines @@
   }
   return success;
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata