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

chrome/browser/chromeos/gdata/gdata_file_system.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_file_system.h"
 
 #include <errno.h>
 #include <sys/stat.h>
 
 #include <set>
@@ skipping 35 matching lines @@
 
 using content::BrowserThread;
 
 namespace gdata {
 namespace {
 
 const char kMimeTypeJson[] = "application/json";
 const char kMimeTypeOctetStream[] = "application/octet-stream";
 
 const char kWildCard[] = "*";
-const char kLocallyModifiedFileExtension[] = "local";
-const char kMountedArchiveFileExtension[] = "mounted";
 
 const FilePath::CharType kGDataCacheVersionDir[] = FILE_PATH_LITERAL("v1");
-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");
 const FilePath::CharType kAccountMetadataFile[] =
     FILE_PATH_LITERAL("account_metadata.json");
 const FilePath::CharType kFilesystemProtoFile[] =
     FILE_PATH_LITERAL("file_system.pb");
 const FilePath::CharType kSymLinkToDevNull[] = FILE_PATH_LITERAL("/dev/null");
 
 // GData update check interval (in seconds).
 #ifndef NDEBUG
 const int kGDataUpdateCheckIntervalInSec = 5;
 #else
@@ skipping 864 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void GDataFileSystem::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FilePath cache_base_path;
   chrome::GetUserCacheDirectory(profile_->GetPath(), &cache_base_path);
   gdata_cache_path_ = cache_base_path.Append(chrome::kGDataCacheDirname);
   gdata_cache_path_ = gdata_cache_path_.Append(kGDataCacheVersionDir);
-  SetCachePaths(gdata_cache_path_);
 
   documents_service_->Initialize(profile_);
 
   root_.reset(new GDataRootDirectory);
-  cache_ = GDataCache::CreateGDataCache().Pass();
+  cache_ = GDataCache::CreateGDataCache(gdata_cache_path_).Pass();
 
   PrefService* pref_service = profile_->GetPrefs();
   hide_hosted_docs_ = pref_service->GetBoolean(prefs::kDisableGDataHostedFiles);
 
   InitializePreferenceObserver();
 
   PostBlockingPoolSequencedTask(
       FROM_HERE,
       base::Bind(&GDataFileSystem::InitializeCacheOnBlockingPool,
                  base::Unretained(this)));
@@ skipping 1057 matching lines @@
         base::Bind(&RunGetFileCallbackHelper,
                    get_file_callback,
                    base::Owned(error),
                    base::Owned(temp_file_path),
                    base::Owned(mime_type),
                    base::Owned(file_type)));
     return;
   }
 
   // Returns absolute path of the file if it were cached or to be cached.
-  FilePath local_tmp_path = GetCacheFilePath(file_properties.resource_id,
-                                             file_properties.file_md5,
-                                             GDataCache::CACHE_TYPE_TMP,
-                                             CACHED_FILE_FROM_SERVER);
+  FilePath local_tmp_path = cache_->GetCacheFilePath(
+      file_properties.resource_id,
+      file_properties.file_md5,
+      GDataCache::CACHE_TYPE_TMP,
+      GDataCache::CACHED_FILE_FROM_SERVER);
   GetFileFromCacheByResourceIdAndMd5(
       file_properties.resource_id,
       file_properties.file_md5,
       base::Bind(
           &GDataFileSystem::OnGetFileFromCache,
           ui_weak_ptr_,
           GetFileFromCacheParams(file_path,
                                  local_tmp_path,
                                  file_properties.content_url,
                                  file_properties.resource_id,
@@ skipping 196 matching lines @@
   documents_service_->DownloadFile(
       params.virtual_file_path,
       params.local_tmp_path,
       content_url,
       base::Bind(&GDataFileSystem::OnFileDownloaded,
                  ui_weak_ptr_,
                  params),
       params.get_download_data_callback);
 }
 
-void GDataFileSystem::SetCachePaths(const FilePath& root_path) {
-  DCHECK(cache_paths_.empty());
-
-  // Insert into |cache_paths_| in order defined in enum CacheSubDirectoryType.
-  cache_paths_.push_back(root_path.Append(kGDataCacheMetaDir));
-  cache_paths_.push_back(root_path.Append(kGDataCachePinnedDir));
-  cache_paths_.push_back(root_path.Append(kGDataCacheOutgoingDir));
-  cache_paths_.push_back(root_path.Append(kGDataCachePersistentDir));
-  cache_paths_.push_back(root_path.Append(kGDataCacheTmpDir));
-  cache_paths_.push_back(root_path.Append(kGDataCacheTmpDownloadsDir));
-  cache_paths_.push_back(root_path.Append(kGDataCacheTmpDocumentsDir));
-}
-
 void GDataFileSystem::GetEntryInfoByPathAsync(
     const FilePath& file_path,
     const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::GetEntryInfoByPathAsyncOnUIThread,
                  ui_weak_ptr_,
                  file_path,
                  CreateRelayCallback(callback)));
@@ skipping 421 matching lines @@
   DCHECK(cache_file_path);
 
   base::AutoLock lock(lock_);  // For cache access.
 
   // Parse file path to obtain resource_id, md5 and extra_extension.
   std::string resource_id;
   std::string md5;
   std::string extra_extension;
   util::ParseCacheFilePath(file_path, &resource_id, &md5, &extra_extension);
   // The extra_extension shall be ".mounted" iff we're unmounting.
-  DCHECK(!to_mount == (extra_extension == kMountedArchiveFileExtension));
+  DCHECK(!to_mount ==
+         (extra_extension == GDataCache::kMountedArchiveFileExtension));
 
   // Get cache entry associated with the resource_id and md5
   scoped_ptr<GDataCache::CacheEntry> cache_entry = cache_->GetCacheEntry(
       resource_id, md5);
   if (!cache_entry.get()) {
     *error = base::PLATFORM_FILE_ERROR_NOT_FOUND;
     return;
   }
   if (to_mount == cache_entry->IsMounted()) {
     *error = base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
     return;
   }
 
   // Get the subdir type and path for the unmounted state.
   GDataCache::CacheSubDirectoryType unmounted_subdir =
       cache_entry->IsPinned() ? GDataCache::CACHE_TYPE_PERSISTENT :
                                 GDataCache::CACHE_TYPE_TMP;
-  FilePath unmounted_path = GetCacheFilePath(resource_id, md5, unmounted_subdir,
-                                             CACHED_FILE_FROM_SERVER);
+  FilePath unmounted_path = cache_->GetCacheFilePath(
+      resource_id, md5, unmounted_subdir, GDataCache::CACHED_FILE_FROM_SERVER);
 
   // Get the subdir type and path for the mounted state.
   GDataCache::CacheSubDirectoryType mounted_subdir =
       GDataCache::CACHE_TYPE_PERSISTENT;
-  FilePath mounted_path = GetCacheFilePath(resource_id, md5, mounted_subdir,
-                                           CACHED_FILE_MOUNTED);
+  FilePath mounted_path = cache_->GetCacheFilePath(
+      resource_id, md5, mounted_subdir, GDataCache::CACHED_FILE_MOUNTED);
 
   // Determine the source and destination paths for moving the cache blob.
   FilePath source_path;
   GDataCache::CacheSubDirectoryType dest_subdir;
   int cache_state = cache_entry->cache_state;
   if (to_mount) {
     source_path = unmounted_path;
     *cache_file_path = mounted_path;
     dest_subdir = mounted_subdir;
     cache_state = GDataCache::SetCacheMounted(cache_state);
@@ skipping 1219 matching lines @@
 }
 
 //===================== GDataFileSystem: Cache entry points ====================
 
 bool GDataFileSystem::IsUnderGDataCacheDirectory(const FilePath& path) const {
   return gdata_cache_path_ == path || gdata_cache_path_.IsParent(path);
 }
 
 FilePath GDataFileSystem::GetCacheDirectoryPath(
     GDataCache::CacheSubDirectoryType sub_dir_type) const {
-  DCHECK_LE(0, sub_dir_type);
-  DCHECK_GT(GDataCache::NUM_CACHE_TYPES, sub_dir_type);
-  return cache_paths_[sub_dir_type];
+  return cache_->GetCacheDirectoryPath(sub_dir_type);
 }
 
 FilePath GDataFileSystem::GetCacheFilePath(
     const std::string& resource_id,
     const std::string& md5,
     GDataCache::CacheSubDirectoryType sub_dir_type,
-    CachedFileOrigin file_origin) const {
-  DCHECK(sub_dir_type != GDataCache::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 == GDataCache::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 == GDataCache::CACHE_TYPE_PERSISTENT);
-     base_name += FilePath::kExtensionSeparator;
-     base_name += kMountedArchiveFileExtension;
-  }
-  return GetCacheDirectoryPath(sub_dir_type).Append(base_name);
+    GDataCache::CachedFileOrigin file_origin) const {
+  return cache_->GetCacheFilePath(resource_id, md5, sub_dir_type, file_origin);
 }
 
 void GDataFileSystem::StoreToCache(const std::string& resource_id,
                                    const std::string& md5,
                                    const FilePath& source_path,
                                    FileOperationType file_operation_type,
                                    const CacheOperationCallback& callback) {
   base::PlatformFileError* error =
       new base::PlatformFileError(base::PLATFORM_FILE_OK);
   PostBlockingPoolSequencedTaskAndReply(
@@ skipping 155 matching lines @@
       FROM_HERE,
       base::Bind(&GDataFileSystem::InitializeCacheOnBlockingPool,
                  base::Unretained(this)));
 }
 
 //========= GDataFileSystem: Cache tasks that ran on blocking pool ============
 
 void GDataFileSystem::InitializeCacheOnBlockingPool() {
   DCHECK(IsRunningSequenceOnCurrentThread(sequence_token_));
 
-  base::PlatformFileError error = CreateCacheDirectories(cache_paths_);
+  base::PlatformFileError error = CreateCacheDirectories(cache_->cache_paths());
   if (error != base::PLATFORM_FILE_OK)
     return;
 
   // Change permissions of cache persistent directory to u+rwx,og+x in order to
   // allow archive files in that directory to be mounted by cros-disks.
   error = ChangeFilePermissions(
       GetCacheDirectoryPath(GDataCache::CACHE_TYPE_PERSISTENT),
       S_IRWXU | S_IXGRP | S_IXOTH);
   if (error != base::PLATFORM_FILE_OK)
     return;
@@ skipping 30 matching lines @@
     FilePath* cache_file_path) {
   DCHECK(IsRunningSequenceOnCurrentThread(sequence_token_));
   DCHECK(error);
   DCHECK(cache_file_path);
 
   base::AutoLock lock(lock_);  // For cache access.
 
   scoped_ptr<GDataCache::CacheEntry> cache_entry = cache_->GetCacheEntry(
       resource_id, md5);
   if (cache_entry.get() && cache_entry->IsPresent()) {
-    CachedFileOrigin file_origin;
+    GDataCache::CachedFileOrigin file_origin;
     if (cache_entry->IsMounted()) {
-      file_origin = CACHED_FILE_MOUNTED;
+      file_origin = GDataCache::CACHED_FILE_MOUNTED;
     } else if (cache_entry->IsDirty()) {
-      file_origin = CACHED_FILE_LOCALLY_MODIFIED;
+      file_origin = GDataCache::CACHED_FILE_LOCALLY_MODIFIED;
     } else {
-      file_origin = CACHED_FILE_FROM_SERVER;
+      file_origin = GDataCache::CACHED_FILE_FROM_SERVER;
     }
-    *cache_file_path = GetCacheFilePath(
+    *cache_file_path = cache_->GetCacheFilePath(
         resource_id,
         md5,
         cache_entry->sub_dir_type,
         file_origin);
     *error = base::PLATFORM_FILE_OK;
   } else {
     *error = base::PLATFORM_FILE_ERROR_NOT_FOUND;
   }
 }
 
@@ skipping 55 matching lines @@
                    << ", md5=" << md5;
       *error = base::PLATFORM_FILE_ERROR_IN_USE;
       return;
     }
 
     cache_state |= cache_entry->cache_state;
 
     // If file is pinned, determines destination path.
     if (cache_entry->IsPinned()) {
       sub_dir_type = GDataCache::CACHE_TYPE_PERSISTENT;
-      dest_path = GetCacheFilePath(resource_id, md5, sub_dir_type,
-                                   CACHED_FILE_FROM_SERVER);
-      symlink_path = GetCacheFilePath(resource_id, std::string(),
-                                      GDataCache::CACHE_TYPE_PINNED,
-                                      CACHED_FILE_FROM_SERVER);
+      dest_path = cache_->GetCacheFilePath(resource_id, md5, sub_dir_type,
+                                           GDataCache::CACHED_FILE_FROM_SERVER);
+      symlink_path = cache_->GetCacheFilePath(
+          resource_id, std::string(), GDataCache::CACHE_TYPE_PINNED,
+          GDataCache::CACHED_FILE_FROM_SERVER);
     }
   }
 
   // File wasn't pinned or doesn't exist in cache, store in tmp dir.
   if (dest_path.empty()) {
     DCHECK_EQ(GDataCache::CACHE_TYPE_TMP, sub_dir_type);
-    dest_path = GetCacheFilePath(resource_id, md5, sub_dir_type,
-                                 CACHED_FILE_FROM_SERVER);
+    dest_path = cache_->GetCacheFilePath(resource_id, md5, sub_dir_type,
+                                         GDataCache::CACHED_FILE_FROM_SERVER);
   }
 
   *error = ModifyCacheState(
       source_path,
       dest_path,
       file_operation_type,
       symlink_path,
       !symlink_path.empty());  // create symlink
 
   // Determine search pattern for stale filenames corrresponding to resource_id,
@@ skipping 59 matching lines @@
   } 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(GDataCache::CACHE_TYPE_PERSISTENT, cache_entry->sub_dir_type);
-      dest_path = GetCacheFilePath(resource_id,
-                                   md5,
-                                   cache_entry->sub_dir_type,
-                                   CACHED_FILE_LOCALLY_MODIFIED);
+      dest_path = cache_->GetCacheFilePath(
+          resource_id,
+          md5,
+          cache_entry->sub_dir_type,
+          GDataCache::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,
-                                     CACHED_FILE_FROM_SERVER);
+      source_path = cache_->GetCacheFilePath(
+          resource_id,
+          md5,
+          cache_entry->sub_dir_type,
+          GDataCache::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->sub_dir_type == GDataCache::CACHE_TYPE_PINNED) {
         dest_path = source_path;
         create_symlink = false;
       } else {  // File exists, move it to persistent dir.
-        dest_path = GetCacheFilePath(resource_id,
-                                     md5,
-                                     GDataCache::CACHE_TYPE_PERSISTENT,
-                                     CACHED_FILE_FROM_SERVER);
+        dest_path = cache_->GetCacheFilePath(
+            resource_id,
+            md5,
+            GDataCache::CACHE_TYPE_PERSISTENT,
+            GDataCache::CACHED_FILE_FROM_SERVER);
       }
     }
   }
 
   // Create symlink in pinned dir.
   if (create_symlink) {
-    symlink_path = GetCacheFilePath(resource_id,
-                                    std::string(),
-                                    GDataCache::CACHE_TYPE_PINNED,
-                                    CACHED_FILE_FROM_SERVER);
+    symlink_path = cache_->GetCacheFilePath(
+        resource_id,
+        std::string(),
+        GDataCache::CACHE_TYPE_PINNED,
+        GDataCache::CACHED_FILE_FROM_SERVER);
   }
 
   *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.
@@ skipping 28 matching lines @@
   FilePath dest_path;
   GDataCache::CacheSubDirectoryType sub_dir_type =
       GDataCache::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 = GDataCache::CACHE_TYPE_PERSISTENT;
     DCHECK_EQ(sub_dir_type, cache_entry->sub_dir_type);
-    dest_path = GetCacheFilePath(resource_id,
-                                 md5,
-                                 cache_entry->sub_dir_type,
-                                 CACHED_FILE_LOCALLY_MODIFIED);
+    dest_path = cache_->GetCacheFilePath(
+        resource_id,
+        md5,
+        cache_entry->sub_dir_type,
+        GDataCache::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,
-                                   CACHED_FILE_FROM_SERVER);
+    source_path = cache_->GetCacheFilePath(resource_id,
+                                           md5,
+                                           cache_entry->sub_dir_type,
+                                           GDataCache::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->sub_dir_type == GDataCache::CACHE_TYPE_PINNED) {
       dest_path = source_path;
     } else {  // File exists, move it to tmp dir.
-      dest_path = GetCacheFilePath(resource_id, md5,
-                                   GDataCache::CACHE_TYPE_TMP,
-                                   CACHED_FILE_FROM_SERVER);
+      dest_path = cache_->GetCacheFilePath(resource_id, md5,
+                                           GDataCache::CACHE_TYPE_TMP,
+                                           GDataCache::CACHED_FILE_FROM_SERVER);
     }
   }
 
   // If file was pinned, get absolute path of symlink in pinned dir so as to
   // remove it.
   FilePath symlink_path;
   if (cache_entry->IsPinned()) {
-    symlink_path = GetCacheFilePath(resource_id,
+    symlink_path = cache_->GetCacheFilePath(resource_id,
                                     std::string(),
                                     GDataCache::CACHE_TYPE_PINNED,
-                                    CACHED_FILE_FROM_SERVER);
+                                    GDataCache::CACHED_FILE_FROM_SERVER);
   }
 
   *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) {
@@ skipping 37 matching lines @@
   // 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(GDataCache::CACHE_TYPE_PERSISTENT, cache_entry->sub_dir_type);
 
     // Determine symlink path in outgoing dir, so as to remove it.
-    FilePath symlink_path = GetCacheFilePath(
+    FilePath symlink_path = cache_->GetCacheFilePath(
         resource_id,
         std::string(),
         GDataCache::CACHE_TYPE_OUTGOING,
-        CACHED_FILE_FROM_SERVER);
+        GDataCache::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
     // if source and destination are different.
     *error = ModifyCacheState(
         FilePath(),  // non-applicable source path
         FilePath(),  // non-applicable dest path
         file_operation_type,
         symlink_path,
         false /* don't create symlink */);
 
     // Determine current path of dirty file.
     if (*error == base::PLATFORM_FILE_OK) {
-      *cache_file_path = GetCacheFilePath(
+      *cache_file_path = cache_->GetCacheFilePath(
           resource_id,
           md5,
           GDataCache::CACHE_TYPE_PERSISTENT,
-          CACHED_FILE_LOCALLY_MODIFIED);
+          GDataCache::CACHED_FILE_LOCALLY_MODIFIED);
     }
     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,
-                                          CACHED_FILE_FROM_SERVER);
+  FilePath source_path = cache_->GetCacheFilePath(
+      resource_id,
+      md5,
+      cache_entry->sub_dir_type,
+      GDataCache::CACHED_FILE_FROM_SERVER);
 
   // Determine destination path.
   GDataCache::CacheSubDirectoryType sub_dir_type =
       GDataCache::CACHE_TYPE_PERSISTENT;
-  *cache_file_path = GetCacheFilePath(resource_id,
-                                      md5,
-                                      sub_dir_type,
-                                      CACHED_FILE_LOCALLY_MODIFIED);
+  *cache_file_path = cache_->GetCacheFilePath(
+      resource_id,
+      md5,
+      sub_dir_type,
+      GDataCache::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(),
-                                    GDataCache::CACHE_TYPE_PINNED,
-                                    CACHED_FILE_FROM_SERVER);
+    symlink_path = cache_->GetCacheFilePath(
+        resource_id,
+        std::string(),
+        GDataCache::CACHE_TYPE_PINNED,
+        GDataCache::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) {
@@ skipping 38 matching lines @@
                  << resource_id
                  << ", md5=" << md5;
     *error = base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
     return;
   }
 
   // Dirty files must be in persistent dir.
   DCHECK_EQ(GDataCache::CACHE_TYPE_PERSISTENT, cache_entry->sub_dir_type);
 
   // Create symlink in outgoing dir.
-  FilePath symlink_path = GetCacheFilePath(
+  FilePath symlink_path = cache_->GetCacheFilePath(
       resource_id,
       std::string(),
       GDataCache::CACHE_TYPE_OUTGOING,
-      CACHED_FILE_FROM_SERVER);
+      GDataCache::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,
-                                          CACHED_FILE_LOCALLY_MODIFIED);
+  FilePath target_path = cache_->GetCacheFilePath(
+      resource_id,
+      md5,
+      cache_entry->sub_dir_type,
+      GDataCache::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 31 matching lines @@
                  << resource_id
                  << ", md5=" << md5;
     *error = base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
     return;
   }
 
   // File must be dirty and hence in persistent dir.
   DCHECK_EQ(GDataCache::CACHE_TYPE_PERSISTENT, cache_entry->sub_dir_type);
 
   // Get the current path of the file in cache.
-  FilePath source_path = GetCacheFilePath(resource_id,
-                                          md5,
-                                          cache_entry->sub_dir_type,
-                                          CACHED_FILE_LOCALLY_MODIFIED);
+  FilePath source_path = cache_->GetCacheFilePath(
+      resource_id,
+      md5,
+      cache_entry->sub_dir_type,
+      GDataCache::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.
   GDataCache::CacheSubDirectoryType sub_dir_type =
       cache_entry->IsPinned() ? GDataCache::CACHE_TYPE_PERSISTENT :
                                 GDataCache::CACHE_TYPE_TMP;
-  FilePath dest_path = GetCacheFilePath(resource_id,
-                                        md5,
-                                        sub_dir_type,
-                                        CACHED_FILE_FROM_SERVER);
+  FilePath dest_path = cache_->GetCacheFilePath(
+      resource_id,
+      md5,
+      sub_dir_type,
+      GDataCache::CACHED_FILE_FROM_SERVER);
 
   // Delete symlink in outgoing dir.
-  FilePath symlink_path = GetCacheFilePath(
+  FilePath symlink_path = cache_->GetCacheFilePath(
       resource_id,
       std::string(),
       GDataCache::CACHE_TYPE_OUTGOING,
-      CACHED_FILE_FROM_SERVER);
+      GDataCache::CACHED_FILE_FROM_SERVER);
 
   *error = ModifyCacheState(
       source_path,
       dest_path,
       file_operation_type,
       symlink_path,
       false /* don't create symlink */);
 
   // If file is pinned, update symlink in pinned dir.
   if (*error == base::PLATFORM_FILE_OK && cache_entry->IsPinned()) {
-    symlink_path = GetCacheFilePath(resource_id,
-                                    std::string(),
-                                    GDataCache::CACHE_TYPE_PINNED,
-                                    CACHED_FILE_FROM_SERVER);
+    symlink_path = cache_->GetCacheFilePath(
+        resource_id,
+        std::string(),
+        GDataCache::CACHE_TYPE_PINNED,
+        GDataCache::CACHED_FILE_FROM_SERVER);
 
     // Since there's no moving of files here, use |dest_path| for both
     // |source_path| and |dest_path|, because ModifyCacheState only moves files
     // if source and destination are different.
     *error = ModifyCacheState(dest_path,  // source path
-                             dest_path,  // destination path
-                             file_operation_type,
-                             symlink_path,
-                             true /* create symlink */);
+                              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 = GDataCache::ClearCacheDirty(cache_entry->cache_state);
     cache_->UpdateCache(resource_id, md5, sub_dir_type, cache_state);
   }
 }
 
 void GDataFileSystem::RemoveFromCacheOnBlockingPool(
@@ skipping 23 matching lines @@
     *error = base::PLATFORM_FILE_OK;
     return;
   }
 
   // Determine paths to delete all cache versions of |resource_id| in
   // persistent, tmp and pinned directories.
   std::vector<FilePath> paths_to_delete;
 
   // For files in persistent and tmp dirs, delete files that match
   // "<resource_id>.*".
-  paths_to_delete.push_back(GetCacheFilePath(
+  paths_to_delete.push_back(cache_->GetCacheFilePath(
       resource_id,
       kWildCard,
       GDataCache::CACHE_TYPE_PERSISTENT,
-      CACHED_FILE_FROM_SERVER));
-  paths_to_delete.push_back(GetCacheFilePath(
+      GDataCache::CACHED_FILE_FROM_SERVER));
+  paths_to_delete.push_back(cache_->GetCacheFilePath(
       resource_id,
       kWildCard,
       GDataCache::CACHE_TYPE_TMP,
-      CACHED_FILE_FROM_SERVER));
+      GDataCache::CACHED_FILE_FROM_SERVER));
 
   // For pinned files, filename is "<resource_id>" with no extension, so delete
   // "<resource_id>".
-  paths_to_delete.push_back(GetCacheFilePath(
+  paths_to_delete.push_back(cache_->GetCacheFilePath(
       resource_id,
       std::string(),
       GDataCache::CACHE_TYPE_PINNED,
-      CACHED_FILE_FROM_SERVER));
+      GDataCache::CACHED_FILE_FROM_SERVER));
 
   // Don't delete locally modified (i.e. dirty and possibly outgoing) files.
   // Since we're not deleting outgoing symlinks, we don't need to append
   // outgoing path to |paths_to_delete|.
-  FilePath path_to_keep = GetCacheFilePath(
+  FilePath path_to_keep = cache_->GetCacheFilePath(
       resource_id,
       std::string(),
       GDataCache::CACHE_TYPE_PERSISTENT,
-      CACHED_FILE_LOCALLY_MODIFIED);
+      GDataCache::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.
   cache_->RemoveFromCache(resource_id);
 
   *error = base::PLATFORM_FILE_OK;
 }
@@ skipping 78 matching lines @@
       // ignore this outgoing symlink and move on.
       GDataCache::CacheMap::iterator iter =
           cache_map->find(resource_id);
       if (iter != cache_map->end()) {  // Entry exists, update dirty state.
         iter->second.cache_state =
             GDataCache::SetCacheDirty(iter->second.cache_state);
       } else {
         NOTREACHED() << "Dirty cache file MUST have actual file blob";
       }
       continue;
-    } else if (extra_extension == kMountedArchiveFileExtension) {
+    } else if (extra_extension == GDataCache::kMountedArchiveFileExtension) {
       // Mounted archives in cache should be unmounted upon logout/shutdown.
       // But if we encounter a mounted file at start, delete it and create an
       // entry with not PRESENT state.
       DCHECK(sub_dir_type == GDataCache::CACHE_TYPE_PERSISTENT);
       file_util::Delete(current, false);
     } else {
       // Scanning other directories means that cache file is actually present.
       cache_state = GDataCache::SetCachePresent(cache_state);
     }
 
@@ skipping 261 matching lines @@
     base::PlatformFileError error,
     const std::string& resource_id,
     const std::string& md5) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!callback.is_null())
     callback.Run(error);
 }
 
 }  // namespace gdata