gdata: Take GDataCache::CacheEntry as parameters

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 863 matching lines @@
     // 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.
     UpdateCacheWithSubDirectoryType(resource_id,
-                                    md5,
                                     sub_dir_type,
-                                    cache_state);
+                                    CacheEntry(md5, cache_state));
   }
 }
 
 void GDataCache::Pin(const std::string& resource_id,
                      const std::string& md5,
                      FileOperationType file_operation_type,
                      base::PlatformFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
@@ skipping 67 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.
     UpdateCacheWithSubDirectoryType(resource_id,
-                                    md5,
                                     sub_dir_type,
-                                    cache_state);
+                                    CacheEntry(md5, cache_state));
   }
 }
 
 void GDataCache::Unpin(const std::string& resource_id,
                        const std::string& md5,
                        FileOperationType file_operation_type,
                        base::PlatformFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
@@ skipping 59 matching lines @@
       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);
     UpdateCacheWithSubDirectoryType(resource_id,
-                                    md5,
                                     sub_dir_type,
-                                    cache_state);
+                                    CacheEntry(md5, cache_state));
   }
 }
 
 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 44 matching lines @@
     dest_subdir = unmounted_subdir;
     cache_state = ClearCacheMounted(cache_state);
   }
 
   // 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,
-                                    md5,
                                     dest_subdir,
-                                    cache_state);
+                                    CacheEntry(md5, cache_state));
   }
 }
 
 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 83 matching lines @@
       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);
     UpdateCacheWithSubDirectoryType(resource_id,
-                                    md5,
                                     sub_dir_type,
-                                    cache_state);
+                                    CacheEntry(md5, cache_state));
   }
 }
 
 void GDataCache::CommitDirty(const std::string& resource_id,
                              const std::string& md5,
                              FileOperationType file_operation_type,
                              base::PlatformFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
@@ skipping 125 matching lines @@
     *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,
-                                    md5,
+   UpdateCacheWithSubDirectoryType(resource_id,
                                     sub_dir_type,
-                                    cache_state);
+                                    CacheEntry(md5, cache_state));
   }
 }
 
 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 116 matching lines @@
   DCHECK(cache_entry);
 
   scoped_ptr<GDataCache::CacheEntry> value(GetCacheEntry(resource_id, md5));
   *success = value.get();
   if (*success)
     *cache_entry = *value;
 }
 
 void GDataCache::UpdateCacheWithSubDirectoryType(
     const std::string& resource_id,
-    const std::string& md5,
     CacheSubDirectoryType sub_dir_type,
-    int cache_state) {
+    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_state = SetCachePersistent(cache_state);
+    cache_entry.cache_state = SetCachePersistent(cache_entry.cache_state);
   else
-    cache_state = ClearCachePersistent(cache_state);
+    cache_entry.cache_state = ClearCachePersistent(cache_entry.cache_state);
 
-  metadata_->UpdateCache(resource_id, md5, cache_state);
+  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);
   return cache_root_path.Append(kGDataCacheVersionDir);
 }
@@ skipping 32 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