Move chromeos::GDataFileSystem::GetCacheDirectoryPath and GetCacheFilePath implementation to GDataC…

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/logging.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
+#include "chrome/browser/chromeos/gdata/gdata_util.h"
 
 namespace gdata {
 namespace {
 
+const char kLocallyModifiedFileExtension[] = "local";
+
+const FilePath::CharType kGDataCacheMetaDir[] = FILE_PATH_LITERAL("meta");
+const FilePath::CharType kGDataCachePinnedDir[] = FILE_PATH_LITERAL("pinned");
+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";
 }
 
 }  // namespace
 
+const char GDataCache::kMountedArchiveFileExtension[] = "mounted";
+
 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");
 
   return base::StringPrintf("md5=%s, subdir=%s, cache_state=%s",
                             md5.c_str(),
                             CacheSubDirectoryTypeToString(sub_dir_type).c_str(),
                             JoinString(cache_states, ',').c_str());
 }
 
-GDataCache::GDataCache() {
+GDataCache::GDataCache(const FilePath& cache_root_path) {
+  // Insert into |cache_paths_| in order defined in enum CacheSubDirectoryType.
+  cache_paths_.push_back(cache_root_path.Append(kGDataCacheMetaDir));
+  cache_paths_.push_back(cache_root_path.Append(kGDataCachePinnedDir));
+  cache_paths_.push_back(cache_root_path.Append(kGDataCacheOutgoingDir));
+  cache_paths_.push_back(cache_root_path.Append(kGDataCachePersistentDir));
+  cache_paths_.push_back(cache_root_path.Append(kGDataCacheTmpDir));
+  cache_paths_.push_back(cache_root_path.Append(kGDataCacheTmpDownloadsDir));
+  cache_paths_.push_back(cache_root_path.Append(kGDataCacheTmpDocumentsDir));
 }
 
 GDataCache::~GDataCache() {
 }
 
+FilePath GDataCache::GetCacheDirectoryPath(
+    CacheSubDirectoryType sub_dir_type) const {
+  DCHECK_LE(0, sub_dir_type);
+  DCHECK_GT(NUM_CACHE_TYPES, sub_dir_type);
+  return cache_paths_[sub_dir_type];
+}
+
+FilePath GDataCache::GetCacheFilePath(const std::string& resource_id,
+                                      const std::string& md5,
+                                      CacheSubDirectoryType sub_dir_type,
+                                      CachedFileOrigin file_origin) const {
+  DCHECK(sub_dir_type != CACHE_TYPE_META);
+
+  // Runs on any thread.
+  // Filename is formatted as resource_id.md5, i.e. resource_id is the base
+  // name and md5 is the extension.
+  std::string base_name = util::EscapeCacheFileName(resource_id);
+  if (file_origin == CACHED_FILE_LOCALLY_MODIFIED) {
+    DCHECK(sub_dir_type == CACHE_TYPE_PERSISTENT);
+    base_name += FilePath::kExtensionSeparator;
+    base_name += kLocallyModifiedFileExtension;
+  } else if (!md5.empty()) {
+    base_name += FilePath::kExtensionSeparator;
+    base_name += util::EscapeCacheFileName(md5);
+  }
+  // For mounted archives the filename is formatted as resource_id.md5.mounted,
+  // i.e. resource_id.md5 is the base name and ".mounted" is the extension
+  if (file_origin == CACHED_FILE_MOUNTED) {
+     DCHECK(sub_dir_type == CACHE_TYPE_PERSISTENT);
+     base_name += FilePath::kExtensionSeparator;
+     base_name += kMountedArchiveFileExtension;
+  }
+  return GetCacheDirectoryPath(sub_dir_type).Append(base_name);
+}
+
 class GDataCacheMap : public GDataCache {
  public:
-  GDataCacheMap();
+  explicit GDataCacheMap(const FilePath& cache_root_path);
 
  protected:
   virtual ~GDataCacheMap();
 
  private:
   // GDataCache implementation.
   virtual void SetCacheMap(const CacheMap& new_cache_map) OVERRIDE;
   virtual void UpdateCache(const std::string& resource_id,
                               const std::string& md5,
                               CacheSubDirectoryType subdir,
                               int cache_state) OVERRIDE;
   virtual void RemoveFromCache(const std::string& resource_id) OVERRIDE;
   virtual scoped_ptr<CacheEntry> GetCacheEntry(const std::string& resource_id,
                                                const std::string& md5) OVERRIDE;
   virtual void RemoveTemporaryFiles() OVERRIDE;
 
   CacheMap cache_map_;
 };
 
-GDataCacheMap::GDataCacheMap() {
+GDataCacheMap::GDataCacheMap(const FilePath& cache_root_path)
+    : GDataCache(cache_root_path) {
 }
 
 GDataCacheMap::~GDataCacheMap() {
   base::ThreadRestrictions::AssertIOAllowed();
   cache_map_.clear();
 }
 
 void GDataCacheMap::SetCacheMap(const CacheMap& new_cache_map)  {
   base::ThreadRestrictions::AssertIOAllowed();
   cache_map_ = new_cache_map;
@@ skipping 79 matching lines @@
     if (iter->second.sub_dir_type == CACHE_TYPE_TMP) {
       // Post-increment the iterator to avoid iterator invalidation.
       cache_map_.erase(iter++);
     } else {
       ++iter;
     }
   }
 }
 
 // static
-scoped_ptr<GDataCache> GDataCache::CreateGDataCache() {
-  return scoped_ptr<GDataCache>(new GDataCacheMap());
+scoped_ptr<GDataCache> GDataCache::CreateGDataCache(
+    const FilePath& cache_root_path) {
+  return scoped_ptr<GDataCache>(new GDataCacheMap(cache_root_path));
 }
 
 }  // namespace gdata