gdata: Remove a werid behavior from GDataCacheMetadata::UpdateCache()

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 864 matching lines @@
     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);
     new_cache_entry.SetPersistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
-    metadata_->UpdateCache(resource_id, new_cache_entry);
+    metadata_->AddOrUpdateCacheEntry(resource_id, 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);
 
@@ skipping 68 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);
     new_cache_entry.SetPersistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
-    metadata_->UpdateCache(resource_id, new_cache_entry);
+    metadata_->AddOrUpdateCacheEntry(resource_id, 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.
-    GDataCacheEntry new_cache_entry(md5, cache_entry->cache_state());
-    new_cache_entry.SetPinned(false);
-    new_cache_entry.SetPersistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
-    metadata_->UpdateCache(resource_id, new_cache_entry);
+    if (cache_entry->IsPresent()) {
+      GDataCacheEntry new_cache_entry(md5, cache_entry->cache_state());
+      new_cache_entry.SetPinned(false);
+      new_cache_entry.SetPersistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
+      metadata_->AddOrUpdateCacheEntry(resource_id, new_cache_entry);
+    } else {
+      // Remove the existing entry if we are unpinning a non-present file.
+      metadata_->RemoveCacheEntry(resource_id);
+    }
   }
 }
 
 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;
     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
     new_cache_entry.SetPersistent(dest_subdir == CACHE_TYPE_PERSISTENT);
-    metadata_->UpdateCache(resource_id, new_cache_entry);
+    metadata_->AddOrUpdateCacheEntry(resource_id, 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 84 matching lines @@
       *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.
     GDataCacheEntry new_cache_entry(md5, cache_entry->cache_state());
     new_cache_entry.SetDirty(true);
     new_cache_entry.SetPersistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
-    metadata_->UpdateCache(resource_id, new_cache_entry);
+    metadata_->AddOrUpdateCacheEntry(resource_id, 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 127 matching lines @@
                               file_operation_type,
                               symlink_path,
                               true /* create symlink */);
   }
 
   if (*error == base::PLATFORM_FILE_OK) {
     // Now that file operations have completed, update cache map.
     GDataCacheEntry new_cache_entry(md5, cache_entry->cache_state());
     new_cache_entry.SetDirty(false);
     new_cache_entry.SetPersistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
-    metadata_->UpdateCache(resource_id, new_cache_entry);
+    metadata_->AddOrUpdateCacheEntry(resource_id, 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
-  // corresponding to <resource_id> regardless of the md5.
+  // MD5 is not passed into RemoveCacheEntry because we would delete all
+  // cache files corresponding to <resource_id> regardless of the md5.
   // So, search for entry in cache without taking md5 into account.
   scoped_ptr<GDataCacheEntry> cache_entry =
       GetCacheEntry(resource_id, std::string());
 
   // If entry doesn't exist or is dirty or mounted in cache, nothing to do.
   if (!cache_entry.get() ||
       cache_entry->IsDirty() ||
       cache_entry->IsMounted()) {
     DVLOG(1) << "Entry is "
              << (cache_entry.get() ?
@@ skipping 32 matching lines @@
   FilePath path_to_keep = GetCacheFilePath(resource_id,
                                            std::string(),
                                            CACHE_TYPE_PERSISTENT,
                                            CACHED_FILE_LOCALLY_MODIFIED);
 
   for (size_t i = 0; i < paths_to_delete.size(); ++i) {
     DeleteFilesSelectively(paths_to_delete[i], path_to_keep);
   }
 
   // Now that all file operations have completed, remove from cache map.
-  metadata_->RemoveFromCache(resource_id);
+  metadata_->RemoveCacheEntry(resource_id);
 
   *error = base::PLATFORM_FILE_OK;
 }
 
 void GDataCache::OnPinned(base::PlatformFileError* error,
                           const std::string& resource_id,
                           const std::string& md5,
                           const CacheOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
@@ skipping 106 matching lines @@
     const GDataCacheEntry& cache_entry) {
   return cache_entry.IsPersistent() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata