gdata: Get rid of GetGDataCacheTmpDirectory() and friends

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 1682 matching lines @@
 
     base::PlatformFileError* error =
         new base::PlatformFileError(base::PLATFORM_FILE_OK);
     FilePath* temp_file_path = new FilePath;
     std::string* mime_type = new std::string;
     GDataFileType* file_type = new GDataFileType(REGULAR_FILE);
     PostBlockingPoolSequencedTaskAndReply(
         kGDataFileSystemToken,
         FROM_HERE,
         base::Bind(&GDataFileSystem::CreateDocumentJsonFileOnIOThreadPool,
-                   GetGDataTempDocumentFolderPath(),
+                   GetCacheDirectoryPath(
+                       GDataRootDirectory::CACHE_TYPE_TMP_DOCUMENTS),
                    file_properties.alternate_url,
                    file_properties.resource_id,
                    error,
                    temp_file_path,
                    mime_type,
                    file_type),
         base::Bind(&RunGetFileCallbackHelper,
                    callback,
                    base::Owned(error),
                    base::Owned(temp_file_path),
@@ skipping 109 matching lines @@
   *has_enough_space = HasEnoughSpaceFor(num_bytes);
   if (*has_enough_space)
     return;
 
   // Otherwise, try to free up the disk space.
   DVLOG(1) << "Freeing up disk space for " << num_bytes;
   base::AutoLock lock(lock_);  // To access the cache map.
   // First remove temporary files from the cache map.
   root_->RemoveTemporaryFilesFromCacheMap();
   // Then remove all files under "tmp" directory.
-  RemoveAllFiles(GetGDataCacheTmpDirectory());
+  RemoveAllFiles(GetCacheDirectoryPath(GDataRootDirectory::CACHE_TYPE_TMP));
 
   // Check the disk space again.
   *has_enough_space = HasEnoughSpaceFor(num_bytes);
 }
 
 void GDataFileSystem::FreeDiskSpaceIfNeeded(bool* has_enough_space) {
   FreeDiskSpaceIfNeededFor(0, has_enough_space);
 }
 
 void GDataFileSystem::StartDownloadFileIfEnoughSpace(
@@ skipping 171 matching lines @@
   if (regular_file) {
     properties->file_md5 = regular_file->file_md5();
     properties->mime_type = regular_file->content_mime_type();
     properties->content_url = regular_file->content_url();
     properties->alternate_url = regular_file->alternate_url();
     properties->is_hosted_document = regular_file->is_hosted_document();
   }
   return true;
 }
 
-bool GDataFileSystem::IsUnderGDataCacheDirectory(const FilePath& path) const {
-  return gdata_cache_path_ == path || gdata_cache_path_.IsParent(path);
-}
-
-FilePath GDataFileSystem::GetGDataCacheTmpDirectory() const {
-  return cache_paths_[GDataRootDirectory::CACHE_TYPE_TMP];
-}
-
-FilePath GDataFileSystem::GetGDataTempDownloadFolderPath() const {
-  return cache_paths_[GDataRootDirectory::CACHE_TYPE_TMP_DOWNLOADS];
-}
-
-FilePath GDataFileSystem::GetGDataTempDocumentFolderPath() const {
-  return cache_paths_[GDataRootDirectory::CACHE_TYPE_TMP_DOCUMENTS];
-}
-
-FilePath GDataFileSystem::GetGDataCachePinnedDirectory() const {
-  return cache_paths_[GDataRootDirectory::CACHE_TYPE_PINNED];
-}
-
-FilePath GDataFileSystem::GetGDataCachePersistentDirectory() const {
-  return cache_paths_[GDataRootDirectory::CACHE_TYPE_PERSISTENT];
-}
-
 base::WeakPtr<GDataFileSystem> GDataFileSystem::GetWeakPtrForCurrentThread() {
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     return ui_weak_ptr_factory_->GetWeakPtr();
   } else if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     if (!io_weak_ptr_factory_.get()) {
       io_weak_ptr_factory_.reset(
           new base::WeakPtrFactory<GDataFileSystem>(this));
     }
     return io_weak_ptr_factory_->GetWeakPtr();
   }
@@ skipping 345 matching lines @@
   if (!params->callback.is_null()) {
     FindEntryByPathOnCallingThread(params->search_file_path, params->callback);
   }
 }
 
 void GDataFileSystem::LoadRootFeedFromCache(
     bool should_load_from_server,
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   const FilePath path =
-      cache_paths_[GDataRootDirectory::CACHE_TYPE_META].Append(
+      GetCacheDirectoryPath(GDataRootDirectory::CACHE_TYPE_META).Append(
           kFilesystemProtoFile);
   LoadRootFeedParams* params = new LoadRootFeedParams(search_file_path,
                                                       should_load_from_server,
                                                       callback);
   BrowserThread::GetBlockingPool()->PostTaskAndReply(FROM_HERE,
       base::Bind(&LoadProtoOnIOThreadPool, path, params),
       base::Bind(&GDataFileSystem::OnProtoLoaded,
                  GetWeakPtrForCurrentThread(),
                  base::Owned(params)));
 }
@@ skipping 53 matching lines @@
 void GDataFileSystem::SaveFileSystemAsProto() {
   DVLOG(1) << "SaveFileSystemAsProto";
   base::AutoLock lock(lock_);  // To access root_.
 
   if (!ShouldSerializeFileSystemNow(root_->serialized_size(),
                                     root_->last_serialized())) {
     return;
   }
 
   const FilePath path =
-      cache_paths_[GDataRootDirectory::CACHE_TYPE_META].Append(
+      GetCacheDirectoryPath(GDataRootDirectory::CACHE_TYPE_META).Append(
           kFilesystemProtoFile);
   scoped_ptr<std::string> serialized_proto(new std::string());
   root_->SerializeToString(serialized_proto.get());
   root_->set_last_serialized(base::Time::Now());
   root_->set_serialized_size(serialized_proto->size());
   PostBlockingPoolSequencedTask(kGDataFileSystemToken, FROM_HERE,
       base::Bind(&SaveProtoOnIOThreadPool, path,
                  base::Passed(serialized_proto.Pass())));
 }
 
@@ skipping 104 matching lines @@
 }
 
 void GDataFileSystem::SaveFeed(scoped_ptr<base::Value> feed,
                                const FilePath& name) {
   InitializeCacheIfNecessary();
 
   PostBlockingPoolSequencedTask(
       kGDataFileSystemToken,
       FROM_HERE,
       base::Bind(&SaveFeedOnIOThreadPool,
-                 cache_paths_[GDataRootDirectory::CACHE_TYPE_META].Append(
-                     name),
+                 GetCacheDirectoryPath(
+                     GDataRootDirectory::CACHE_TYPE_META).Append(name),
                  base::Passed(&feed)));
 }
 
 void GDataFileSystem::OnRemovedDocument(
     const FileOperationCallback& callback,
     const FilePath& file_path,
     GDataErrorCode status,
     const GURL& document_url) {
   base::PlatformFileError error = GDataToPlatformError(status);
 
@@ skipping 680 matching lines @@
     hide_hosted_docs_ = hide;
     root_path = root_->GetFilePath();
   }
 
   // Kick of directory refresh when this setting changes.
   NotifyDirectoryChanged(root_path);
 }
 
 //===================== GDataFileSystem: Cache entry points ====================
 
+bool GDataFileSystem::IsUnderGDataCacheDirectory(const FilePath& path) const {
+  return gdata_cache_path_ == path || gdata_cache_path_.IsParent(path);
+}
+
+FilePath GDataFileSystem::GetCacheDirectoryPath(
+    GDataRootDirectory::CacheSubDirectoryType sub_dir_type) const {
+  DCHECK_LE(0, sub_dir_type);
+  DCHECK_GT(GDataRootDirectory::NUM_CACHE_TYPES, sub_dir_type);
+  return cache_paths_[sub_dir_type];
+}
+
 FilePath GDataFileSystem::GetCacheFilePath(
     const std::string& resource_id,
     const std::string& md5,
     GDataRootDirectory::CacheSubDirectoryType sub_dir_type,
     CachedFileOrigin file_origin) const {
   DCHECK(sub_dir_type != GDataRootDirectory::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 == GDataRootDirectory::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 == GDataRootDirectory::CACHE_TYPE_PERSISTENT);
      base_name += FilePath::kExtensionSeparator;
      base_name += kMountedArchiveFileExtension;
   }
-  return cache_paths_[sub_dir_type].Append(base_name);
+  return GetCacheDirectoryPath(sub_dir_type).Append(base_name);
 }
 
 void GDataFileSystem::StoreToCache(const std::string& resource_id,
                                    const std::string& md5,
                                    const FilePath& source_path,
                                    FileOperationType file_operation_type,
                                    const CacheOperationCallback& callback) {
   InitializeCacheIfNecessary();
 
   base::PlatformFileError* error =
@@ skipping 168 matching lines @@
 //========= GDataFileSystem: Cache tasks that ran on io thread pool ============
 
 void GDataFileSystem::InitializeCacheOnIOThreadPool() {
   base::PlatformFileError error = CreateCacheDirectories(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(
-      cache_paths_[GDataRootDirectory::CACHE_TYPE_PERSISTENT],
+      GetCacheDirectoryPath(GDataRootDirectory::CACHE_TYPE_PERSISTENT),
       S_IRWXU | S_IXGRP | S_IXOTH);
   if (error != base::PLATFORM_FILE_OK)
     return;
 
   // Scan cache persistent and tmp directories to enumerate all files and create
   // corresponding entries for cache map.
   GDataRootDirectory::CacheMap cache_map;
   ScanCacheDirectory(GDataRootDirectory::CACHE_TYPE_PERSISTENT, &cache_map);
   ScanCacheDirectory(GDataRootDirectory::CACHE_TYPE_TMP, &cache_map);
 
@@ skipping 728 matching lines @@
       kGDataFileSystemToken,
       FROM_HERE,
       base::Bind(&GDataFileSystem::InitializeCacheOnIOThreadPool,
                  base::Unretained(this)));
 }
 
 void GDataFileSystem::ScanCacheDirectory(
     GDataRootDirectory::CacheSubDirectoryType sub_dir_type,
     GDataRootDirectory::CacheMap* cache_map) {
   file_util::FileEnumerator enumerator(
-      cache_paths_[sub_dir_type],
+      GetCacheDirectoryPath(sub_dir_type),
       false,  // not recursive
       static_cast<file_util::FileEnumerator::FileType>(
           file_util::FileEnumerator::FILES |
           file_util::FileEnumerator::SHOW_SYM_LINKS),
       kWildCard);
   for (FilePath current = enumerator.Next(); !current.empty();
        current = enumerator.Next()) {
     // Extract resource_id and md5 from filename.
     std::string resource_id;
     std::string md5;
@@ skipping 135 matching lines @@
   pref_registrar_->Init(profile_->GetPrefs());
   pref_registrar_->Add(prefs::kDisableGDataHostedFiles, this);
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata