gdata: Remove sub_dir_type from CacheEntry for simplicity

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 19 matching lines @@
 const FilePath::CharType kGDataCacheOutgoingDir[] =
     FILE_PATH_LITERAL("outgoing");
 const FilePath::CharType kGDataCachePersistentDir[] =
     FILE_PATH_LITERAL("persistent");
 const FilePath::CharType kGDataCacheTmpDir[] = FILE_PATH_LITERAL("tmp");
 const FilePath::CharType kGDataCacheTmpDownloadsDir[] =
     FILE_PATH_LITERAL("tmp/downloads");
 const FilePath::CharType kGDataCacheTmpDocumentsDir[] =
     FILE_PATH_LITERAL("tmp/documents");
 
-std::string CacheSubDirectoryTypeToString(
-    GDataCache::CacheSubDirectoryType subdir) {
-  switch (subdir) {
-    case GDataCache::CACHE_TYPE_META:
-      return "meta";
-    case GDataCache::CACHE_TYPE_PINNED:
-      return "pinned";
-    case GDataCache::CACHE_TYPE_OUTGOING:
-      return "outgoing";
-    case GDataCache::CACHE_TYPE_PERSISTENT:
-      return "persistent";
-    case GDataCache::CACHE_TYPE_TMP:
-      return "tmp";
-    case GDataCache::CACHE_TYPE_TMP_DOWNLOADS:
-      return "tmp_downloads";
-    case GDataCache::CACHE_TYPE_TMP_DOCUMENTS:
-      return "tmp_documents";
-    case GDataCache::NUM_CACHE_TYPES:
-      NOTREACHED();
-  }
-  NOTREACHED();
-  return "unknown subdir";
-}
-
 // Returns the home directory path, or an empty string if the home directory
 // is not found.
 // Copied from webkit/chromeos/cros_mount_point_provider.h.
 // TODO(satorux): Share the code.
 std::string GetHomeDirectory() {
   if (base::chromeos::IsRunningOnChromeOS())
     return "/home/chronos/user";
 
   const char* home = getenv("HOME");
   if (home)
@@ skipping 286 matching lines @@
 }  // namespace
 
 std::string GDataCache::CacheEntry::ToString() const {
   std::vector<std::string> cache_states;
   if (GDataCache::IsCachePresent(cache_state))
     cache_states.push_back("present");
   if (GDataCache::IsCachePinned(cache_state))
     cache_states.push_back("pinned");
   if (GDataCache::IsCacheDirty(cache_state))
     cache_states.push_back("dirty");
+  if (GDataCache::IsCachePersistent(cache_state))
+    cache_states.push_back("persistent");
 
-  return base::StringPrintf("md5=%s, subdir=%s, cache_state=%s",
+  return base::StringPrintf("md5=%s, cache_state=%s",
                             md5.c_str(),
-                            CacheSubDirectoryTypeToString(sub_dir_type).c_str(),
                             JoinString(cache_states, ',').c_str());
 }
 
 GDataCache::GDataCache(
     const FilePath& cache_root_path,
     base::SequencedWorkerPool* pool,
     const base::SequencedWorkerPool::SequenceToken& sequence_token)
     : cache_root_path_(cache_root_path),
       cache_paths_(GetCachePaths(cache_root_path_)),
       pool_(pool),
@@ skipping 426 matching lines @@
     if (cache_entry->IsMounted()) {
       file_origin = CACHED_FILE_MOUNTED;
     } else if (cache_entry->IsDirty()) {
       file_origin = CACHED_FILE_LOCALLY_MODIFIED;
     } else {
       file_origin = CACHED_FILE_FROM_SERVER;
     }
     *cache_file_path = GetCacheFilePath(
         resource_id,
         md5,
-        cache_entry->sub_dir_type,
+        cache_entry->GetSubDirectoryType(),
         file_origin);
     *error = base::PLATFORM_FILE_OK;
   } else {
     *error = base::PLATFORM_FILE_ERROR_NOT_FOUND;
   }
 }
 
 void GDataCache::Store(const std::string& resource_id,
                        const std::string& md5,
                        const FilePath& source_path,
@@ skipping 65 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.
-    metadata_->UpdateCache(resource_id, md5, sub_dir_type, cache_state);
+    UpdateCacheWithSubDirectoryType(resource_id,
+                                    md5,
+                                    sub_dir_type,
+                                    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 20 matching lines @@
     sub_dir_type = CACHE_TYPE_TMP;
   } else {  // File exists in cache, determines destination path.
     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_EQ(CACHE_TYPE_PERSISTENT, cache_entry->sub_dir_type);
+      DCHECK(cache_entry->IsPersistent());
       dest_path = GetCacheFilePath(resource_id,
                                    md5,
-                                   cache_entry->sub_dir_type,
+                                   cache_entry->GetSubDirectoryType(),
                                    CACHED_FILE_LOCALLY_MODIFIED);
       source_path = dest_path;
     } else {
       // Gets the current path of the file in cache.
       source_path = GetCacheFilePath(resource_id,
                                      md5,
-                                     cache_entry->sub_dir_type,
+                                     cache_entry->GetSubDirectoryType(),
                                      CACHED_FILE_FROM_SERVER);
 
       // If file was pinned before but actual file blob doesn't exist in cache:
       // - don't need to move the file, so set |dest_path| to |source_path|,
       //   because ModifyCacheState only moves files if source and destination
       //   are different
       // - don't create symlink since it already exists.
       if (!cache_entry->IsPresent()) {
         dest_path = source_path;
         create_symlink = false;
@@ skipping 15 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.
-    metadata_->UpdateCache(resource_id, md5, sub_dir_type, cache_state);
+    UpdateCacheWithSubDirectoryType(resource_id,
+                                    md5,
+                                    sub_dir_type,
+                                    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 12 matching lines @@
 
   FilePath source_path;
   FilePath dest_path;
   CacheSubDirectoryType sub_dir_type = CACHE_TYPE_TMP;
 
   // If file is dirty or mounted, don't move it, so determine |dest_path| and
   // set |source_path| the same, because ModifyCacheState moves files if source
   // and destination are different.
   if (cache_entry->IsDirty() || cache_entry->IsMounted()) {
     sub_dir_type = CACHE_TYPE_PERSISTENT;
-    DCHECK_EQ(sub_dir_type, cache_entry->sub_dir_type);
+    DCHECK(cache_entry->IsPersistent());
     dest_path = GetCacheFilePath(resource_id,
                                  md5,
-                                 cache_entry->sub_dir_type,
+                                 cache_entry->GetSubDirectoryType(),
                                  CACHED_FILE_LOCALLY_MODIFIED);
     source_path = dest_path;
   } else {
     // Gets the current path of the file in cache.
     source_path = GetCacheFilePath(resource_id,
                                    md5,
-                                   cache_entry->sub_dir_type,
+                                   cache_entry->GetSubDirectoryType(),
                                    CACHED_FILE_FROM_SERVER);
 
     // If file was pinned but actual file blob still doesn't exist in cache,
     // don't need to move the file, so set |dest_path| to |source_path|, because
     // ModifyCacheState only moves files if source and destination are
     // different.
     if (!cache_entry->IsPresent()) {
       dest_path = source_path;
     } else {  // File exists, move it to tmp dir.
       dest_path = GetCacheFilePath(resource_id, md5,
@@ skipping 15 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);
-    metadata_->UpdateCache(resource_id, md5, sub_dir_type, cache_state);
+    UpdateCacheWithSubDirectoryType(resource_id,
+                                    md5,
+                                    sub_dir_type,
+                                    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 43 matching lines @@
     *cache_file_path = unmounted_path;
     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
-    metadata_->UpdateCache(resource_id, md5, dest_subdir, cache_state);
+    UpdateCacheWithSubDirectoryType(resource_id,
+                                    md5,
+                                    dest_subdir,
+                                    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 17 matching lines @@
   }
 
   // If a file is already dirty (i.e. MarkDirtyInCache was called before),
   // delete outgoing symlink if it exists.
   // TODO(benchan): We should only delete outgoing symlink if file is currently
   // not being uploaded.  However, for now, cache doesn't know if uploading of a
   // file is in progress.  Per zel, the upload process should be canceled before
   // MarkDirtyInCache is called again.
   if (cache_entry->IsDirty()) {
     // The file must be in persistent dir.
-    DCHECK_EQ(CACHE_TYPE_PERSISTENT, cache_entry->sub_dir_type);
+    DCHECK(cache_entry->IsPersistent());
 
     // Determine symlink path in outgoing dir, so as to remove it.
     FilePath symlink_path = GetCacheFilePath(
         resource_id,
         std::string(),
         CACHE_TYPE_OUTGOING,
         CACHED_FILE_FROM_SERVER);
 
     // We're not moving files here, so simply use empty FilePath for both
     // |source_path| and |dest_path| because ModifyCacheState only move files
@@ skipping 15 matching lines @@
     }
     return;
   }
 
   // Move file to persistent dir with new .local extension.
 
   // Get the current path of the file in cache.
   FilePath source_path = GetCacheFilePath(
       resource_id,
       md5,
-      cache_entry->sub_dir_type,
+      cache_entry->GetSubDirectoryType(),
       CACHED_FILE_FROM_SERVER);
 
   // Determine destination path.
   CacheSubDirectoryType sub_dir_type = CACHE_TYPE_PERSISTENT;
   *cache_file_path = GetCacheFilePath(resource_id,
                                       md5,
                                       sub_dir_type,
                                       CACHED_FILE_LOCALLY_MODIFIED);
 
   // If file is pinned, update symlink in pinned dir.
   FilePath symlink_path;
   if (cache_entry->IsPinned()) {
     symlink_path = GetCacheFilePath(resource_id,
                                     std::string(),
                                     CACHE_TYPE_PINNED,
                                     CACHED_FILE_FROM_SERVER);
   }
 
   *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);
-    metadata_->UpdateCache(resource_id, md5, sub_dir_type, cache_state);
+    UpdateCacheWithSubDirectoryType(resource_id,
+                                    md5,
+                                    sub_dir_type,
+                                    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 18 matching lines @@
   // MarkDirtyInCache), committing it dirty is an invalid operation.
   if (!cache_entry->IsDirty()) {
     LOG(WARNING) << "Can't commit a non-dirty file: res_id="
                  << resource_id
                  << ", md5=" << md5;
     *error = base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
     return;
   }
 
   // Dirty files must be in persistent dir.
-  DCHECK_EQ(CACHE_TYPE_PERSISTENT, cache_entry->sub_dir_type);
+  DCHECK(cache_entry->IsPersistent());
 
   // Create symlink in outgoing dir.
   FilePath symlink_path = GetCacheFilePath(resource_id,
                                            std::string(),
                                            CACHE_TYPE_OUTGOING,
                                            CACHED_FILE_FROM_SERVER);
 
   // Get target path of symlink i.e. current path of the file in cache.
   FilePath target_path = GetCacheFilePath(resource_id,
                                           md5,
-                                          cache_entry->sub_dir_type,
+                                          cache_entry->GetSubDirectoryType(),
                                           CACHED_FILE_LOCALLY_MODIFIED);
 
   // Since there's no need to move files, use |target_path| for both
   // |source_path| and |dest_path|, because ModifyCacheState only moves files
   // if source and destination are different.
   *error = ModifyCacheState(target_path,  // source
                             target_path,  // destination
                             file_operation_type,
                             symlink_path,
                             true /* create symlink */);
@@ skipping 25 matching lines @@
   // MarkDirtyInCache), clearing its dirty state is an invalid operation.
   if (!cache_entry->IsDirty()) {
     LOG(WARNING) << "Can't clear dirty state of a non-dirty file: res_id="
                  << resource_id
                  << ", md5=" << md5;
     *error = base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
     return;
   }
 
   // File must be dirty and hence in persistent dir.
-  DCHECK_EQ(CACHE_TYPE_PERSISTENT, cache_entry->sub_dir_type);
+  DCHECK(cache_entry->IsPersistent());
 
   // Get the current path of the file in cache.
   FilePath source_path = GetCacheFilePath(resource_id,
                                           md5,
-                                          cache_entry->sub_dir_type,
+                                          cache_entry->GetSubDirectoryType(),
                                           CACHED_FILE_LOCALLY_MODIFIED);
 
   // Determine destination path.
   // If file is pinned, move it to persistent dir with .md5 extension;
   // otherwise, move it to tmp dir with .md5 extension.
   CacheSubDirectoryType sub_dir_type =
       cache_entry->IsPinned() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
   FilePath dest_path = GetCacheFilePath(resource_id,
                                         md5,
                                         sub_dir_type,
@@ skipping 24 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);
-    metadata_->UpdateCache(resource_id, md5, sub_dir_type, cache_state);
+    UpdateCacheWithSubDirectoryType(resource_id,
+                                    md5,
+                                    sub_dir_type,
+                                    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 114 matching lines @@
   AssertOnSequencedWorkerPool();
   DCHECK(success);
   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) {
+  DCHECK(sub_dir_type == CACHE_TYPE_PERSISTENT ||
+         sub_dir_type == CACHE_TYPE_TMP);
+
+  if (sub_dir_type == CACHE_TYPE_PERSISTENT)
+    cache_state = SetCachePersistent(cache_state);
+  else
+    cache_state = ClearCachePersistent(cache_state);
+
+  metadata_->UpdateCache(resource_id, md5, cache_state);
+}
+
 // 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);
 }
 
 // static
@@ skipping 30 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