gdata: Move GDataCache::CacheEntry out of GDataCache

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 213 matching lines @@
       DVLOG(1) << "Deleted " << current.value();
   }
 }
 
 // Appends |resource_id| ID to |to_fetch| if the file is pinned but not
 // fetched (not present locally), or to |to_upload| if the file is dirty
 // but not uploaded.
 void CollectBacklog(std::vector<std::string>* to_fetch,
                     std::vector<std::string>* to_upload,
                     const std::string& resource_id,
-                    const GDataCache::CacheEntry& cache_entry) {
+                    const GDataCacheEntry& cache_entry) {
   DCHECK(to_fetch);
   DCHECK(to_upload);
 
   if (cache_entry.IsPinned() && !cache_entry.IsPresent())
     to_fetch->push_back(resource_id);
 
   if (cache_entry.IsDirty())
     to_upload->push_back(resource_id);
 }
 
 // Appends |resource_id| ID to |resource_ids| if the file is pinned and
 // present (cached locally).
 void CollectExistingPinnedFile(std::vector<std::string>* resource_ids,
                                const std::string& resource_id,
-                               const GDataCache::CacheEntry& cache_entry) {
+                               const GDataCacheEntry& cache_entry) {
   DCHECK(resource_ids);
 
   if (cache_entry.IsPinned() && cache_entry.IsPresent())
     resource_ids->push_back(resource_id);
 }
 
 // Runs callback with pointers dereferenced.
 // Used to implement SetMountedStateOnUIThread.
 void RunSetMountedStateCallback(const SetMountedStateCallback& callback,
                                 base::PlatformFileError* error,
@@ skipping 56 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(resource_ids);
 
   if (!callback.is_null())
     callback.Run(*resource_ids);
 }
 
 // Runs callback with pointers dereferenced.
 // Used to implement GetCacheEntryOnUIThread().
 void RunGetCacheEntryCallback(
-    const GDataCache::GetCacheEntryCallback& callback,
+    const GetCacheEntryCallback& callback,
     bool* success,
-    GDataCache::CacheEntry* cache_entry) {
+    GDataCacheEntry* cache_entry) {
   DCHECK(success);
   DCHECK(cache_entry);
 
   if (!callback.is_null())
     callback.Run(*success, *cache_entry);
 }
 
 }  // namespace
 
-std::string GDataCache::CacheEntry::ToString() const {
+std::string GDataCacheEntry::ToString() const {
   std::vector<std::string> cache_states;
   if (IsPresent())
     cache_states.push_back("present");
   if (IsPinned())
     cache_states.push_back("pinned");
   if (IsDirty())
     cache_states.push_back("dirty");
   if (IsPersistent())
     cache_states.push_back("persistent");
 
@@ skipping 72 matching lines @@
   observers_.RemoveObserver(observer);
 }
 
 void GDataCache::GetCacheEntryOnUIThread(
     const std::string& resource_id,
     const std::string& md5,
     const GetCacheEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   bool* success = new bool(false);
-  GDataCache::CacheEntry* cache_entry = new GDataCache::CacheEntry;
+  GDataCacheEntry* cache_entry = new GDataCacheEntry;
   pool_->GetSequencedTaskRunner(sequence_token_)->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&GDataCache::GetCacheEntryHelper,
                  base::Unretained(this),
                  resource_id,
                  md5,
                  success,
                  cache_entry),
       base::Bind(&RunGetCacheEntryCallback,
                  callback,
@@ skipping 262 matching lines @@
 }
 
 void GDataCache::RequestInitializeOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   pool_->GetSequencedTaskRunner(sequence_token_)->PostTask(
       FROM_HERE,
       base::Bind(&GDataCache::Initialize, base::Unretained(this)));
 }
 
-scoped_ptr<GDataCache::CacheEntry> GDataCache::GetCacheEntry(
+scoped_ptr<GDataCacheEntry> GDataCache::GetCacheEntry(
     const std::string& resource_id,
     const std::string& md5) {
   AssertOnSequencedWorkerPool();
   return metadata_->GetCacheEntry(resource_id, md5);
 }
 
 // static
 GDataCache* GDataCache::CreateGDataCacheOnUIThread(
     const FilePath& cache_root_path,
     base::SequencedWorkerPool* pool,
@@ skipping 48 matching lines @@
 }
 
 void GDataCache::GetFile(const std::string& resource_id,
                          const std::string& md5,
                          base::PlatformFileError* error,
                          FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
   DCHECK(cache_file_path);
 
-  scoped_ptr<CacheEntry> cache_entry = GetCacheEntry(
+  scoped_ptr<GDataCacheEntry> cache_entry = GetCacheEntry(
       resource_id, md5);
   if (cache_entry.get() && cache_entry->IsPresent()) {
     CachedFileOrigin file_origin;
     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->GetSubDirectoryType(),
+        GetSubDirectoryType(*cache_entry),
         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,
                        FileOperationType file_operation_type,
                        base::PlatformFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   FilePath dest_path;
   FilePath symlink_path;
-  CacheEntry new_cache_entry(md5, CACHE_STATE_NONE);
+  GDataCacheEntry new_cache_entry(md5, CACHE_STATE_NONE);
   CacheSubDirectoryType sub_dir_type = CACHE_TYPE_TMP;
 
-  scoped_ptr<CacheEntry> cache_entry = GetCacheEntry(resource_id, md5);
+  scoped_ptr<GDataCacheEntry> cache_entry = GetCacheEntry(resource_id, md5);
 
   // If file was previously pinned, store it in persistent dir and create
   // symlink in pinned dir.
   if (cache_entry.get()) {  // File exists in cache.
     // If file is dirty or mounted, return error.
     if (cache_entry->IsDirty() || cache_entry->IsMounted()) {
       LOG(WARNING) << "Can't store a file to replace a "
                    << (cache_entry->IsDirty() ? "dirty" : "mounted")
                    << " file: res_id=" << resource_id
                    << ", md5=" << md5;
@@ skipping 61 matching lines @@
                      const std::string& md5,
                      FileOperationType file_operation_type,
                      base::PlatformFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   FilePath source_path;
   FilePath dest_path;
   FilePath symlink_path;
   bool create_symlink = true;
-  CacheEntry new_cache_entry(md5, CACHE_STATE_NONE);
+  GDataCacheEntry new_cache_entry(md5, CACHE_STATE_NONE);
   CacheSubDirectoryType sub_dir_type = CACHE_TYPE_PERSISTENT;
 
-  scoped_ptr<CacheEntry> cache_entry = GetCacheEntry(resource_id, md5);
+  scoped_ptr<GDataCacheEntry> cache_entry = GetCacheEntry(resource_id, md5);
 
   if (!cache_entry.get()) {  // Entry does not exist in cache.
     // Set both |dest_path| and |source_path| to /dev/null, so that:
     // 1) ModifyCacheState won't move files when |source_path| and |dest_path|
     //    are the same.
     // 2) symlinks to /dev/null will be picked up by GDataSyncClient to download
     //    pinned files that don't exist in cache.
     dest_path = FilePath::FromUTF8Unsafe(util::kSymLinkToDevNull);
     source_path = dest_path;
 
     // Set sub_dir_type to TMP. The file will be first downloaded in 'tmp',
     // then moved to 'persistent'.
     sub_dir_type = CACHE_TYPE_TMP;
   } else {  // File exists in cache, determines destination path.
     new_cache_entry.set_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(cache_entry->IsPersistent());
       dest_path = GetCacheFilePath(resource_id,
                                    md5,
-                                   cache_entry->GetSubDirectoryType(),
+                                   GetSubDirectoryType(*cache_entry),
                                    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->GetSubDirectoryType(),
+                                     GetSubDirectoryType(*cache_entry),
                                      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 28 matching lines @@
   }
 }
 
 void GDataCache::Unpin(const std::string& resource_id,
                        const std::string& md5,
                        FileOperationType file_operation_type,
                        base::PlatformFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
-  scoped_ptr<CacheEntry> cache_entry = GetCacheEntry(resource_id, md5);
+  scoped_ptr<GDataCacheEntry> cache_entry = GetCacheEntry(resource_id, md5);
 
   // Unpinning a file means its entry must exist in cache.
   if (!cache_entry.get()) {
     LOG(WARNING) << "Can't unpin a file that wasn't pinned or cached: res_id="
                  << resource_id
                  << ", md5=" << md5;
     *error = base::PLATFORM_FILE_ERROR_NOT_FOUND;
     return;
   }
 
   // Entry exists in cache, determines source and destination paths.
 
   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(cache_entry->IsPersistent());
     dest_path = GetCacheFilePath(resource_id,
                                  md5,
-                                 cache_entry->GetSubDirectoryType(),
+                                 GetSubDirectoryType(*cache_entry),
                                  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->GetSubDirectoryType(),
+                                   GetSubDirectoryType(*cache_entry),
                                    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 14 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.
-    CacheEntry new_cache_entry(md5, cache_entry->cache_state());
+    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);
   }
 }
 
 void GDataCache::SetMountedState(const FilePath& file_path,
                                  bool to_mount,
                                  base::PlatformFileError *error,
                                  FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
   DCHECK(cache_file_path);
 
   // 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 == util::kMountedArchiveFileExtension));
 
   // Get cache entry associated with the resource_id and md5
-  scoped_ptr<CacheEntry> cache_entry = GetCacheEntry(
+  scoped_ptr<GDataCacheEntry> cache_entry = 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.
   CacheSubDirectoryType unmounted_subdir =
       cache_entry->IsPinned() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
   FilePath unmounted_path = GetCacheFilePath(
       resource_id, md5, unmounted_subdir, CACHED_FILE_FROM_SERVER);
 
   // Get the subdir type and path for the mounted state.
   CacheSubDirectoryType mounted_subdir = CACHE_TYPE_PERSISTENT;
   FilePath mounted_path = GetCacheFilePath(
       resource_id, md5, mounted_subdir, CACHED_FILE_MOUNTED);
 
   // Determine the source and destination paths for moving the cache blob.
   FilePath source_path;
   CacheSubDirectoryType dest_subdir;
-  CacheEntry new_cache_entry(md5, cache_entry->cache_state());
+  GDataCacheEntry new_cache_entry(md5, cache_entry->cache_state());
   if (to_mount) {
     source_path = unmounted_path;
     *cache_file_path = mounted_path;
     dest_subdir = mounted_subdir;
     new_cache_entry.SetMounted(true);
   } else {
     source_path = mounted_path;
     *cache_file_path = unmounted_path;
     dest_subdir = unmounted_subdir;
     new_cache_entry.SetMounted(false);
@@ skipping 15 matching lines @@
                            base::PlatformFileError* error,
                            FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
   DCHECK(cache_file_path);
 
   // If file has already been marked dirty in previous instance of chrome, we
   // would have lost the md5 info during cache initialization, because the file
   // would have been renamed to .local extension.
   // So, search for entry in cache without comparing md5.
-  scoped_ptr<CacheEntry> cache_entry =
+  scoped_ptr<GDataCacheEntry> cache_entry =
       GetCacheEntry(resource_id, std::string());
 
   // Marking a file dirty means its entry and actual file blob must exist in
   // cache.
   if (!cache_entry.get() || !cache_entry->IsPresent()) {
     LOG(WARNING) << "Can't mark dirty a file that wasn't cached: res_id="
                  << resource_id
                  << ", md5=" << md5;
     *error = base::PLATFORM_FILE_ERROR_NOT_FOUND;
     return;
@@ skipping 36 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->GetSubDirectoryType(),
+      GetSubDirectoryType(*cache_entry),
       CACHED_FILE_FROM_SERVER);
 
   // Determine destination path.
   const 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.
-    CacheEntry new_cache_entry(md5, cache_entry->cache_state());
+    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);
   }
 }
 
 void GDataCache::CommitDirty(const std::string& resource_id,
                              const std::string& md5,
                              FileOperationType file_operation_type,
                              base::PlatformFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   // If file has already been marked dirty in previous instance of chrome, we
   // would have lost the md5 info during cache initialization, because the file
   // would have been renamed to .local extension.
   // So, search for entry in cache without comparing md5.
-  scoped_ptr<CacheEntry> cache_entry =
+  scoped_ptr<GDataCacheEntry> cache_entry =
       GetCacheEntry(resource_id, std::string());
 
   // Committing a file dirty means its entry and actual file blob must exist in
   // cache.
   if (!cache_entry.get() || !cache_entry->IsPresent()) {
     LOG(WARNING) << "Can't commit dirty a file that wasn't cached: res_id="
                  << resource_id
                  << ", md5=" << md5;
     *error = base::PLATFORM_FILE_ERROR_NOT_FOUND;
     return;
@@ skipping 14 matching lines @@
 
   // 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->GetSubDirectoryType(),
+                                          GetSubDirectoryType(*cache_entry),
                                           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 */);
 }
 
 void GDataCache::ClearDirty(const std::string& resource_id,
                             const std::string& md5,
                             FileOperationType file_operation_type,
                             base::PlatformFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   // |md5| is the new .<md5> extension to rename the file to.
   // So, search for entry in cache without comparing md5.
-  scoped_ptr<CacheEntry> cache_entry =
+  scoped_ptr<GDataCacheEntry> cache_entry =
       GetCacheEntry(resource_id, std::string());
 
   // Clearing a dirty file means its entry and actual file blob must exist in
   // cache.
   if (!cache_entry.get() || !cache_entry->IsPresent()) {
     LOG(WARNING) << "Can't clear dirty state of a file that wasn't cached: "
                  << "res_id=" << resource_id
                  << ", md5=" << md5;
     *error = base::PLATFORM_FILE_ERROR_NOT_FOUND;
     return;
   }
 
   // If a file is not dirty (it should have been marked dirty via
   // 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(cache_entry->IsPersistent());
 
   // Get the current path of the file in cache.
   FilePath source_path = GetCacheFilePath(resource_id,
                                           md5,
-                                          cache_entry->GetSubDirectoryType(),
+                                          GetSubDirectoryType(*cache_entry),
                                           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.
   const CacheSubDirectoryType sub_dir_type =
       cache_entry->IsPinned() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
   FilePath dest_path = GetCacheFilePath(resource_id,
                                         md5,
                                         sub_dir_type,
@@ skipping 23 matching lines @@
     // if source and destination are different.
     *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.
-    CacheEntry new_cache_entry(md5, cache_entry->cache_state());
+    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);
   }
 }
 
 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.
   // So, search for entry in cache without taking md5 into account.
-  scoped_ptr<CacheEntry> cache_entry =
+  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() ?
                  (cache_entry->IsDirty() ? "dirty" : "mounted") :
                  "non-existent")
@@ skipping 90 matching lines @@
   if (!callback.is_null())
     callback.Run(*error, resource_id, md5);
 
   if (*error == base::PLATFORM_FILE_OK)
     FOR_EACH_OBSERVER(Observer, observers_, OnCacheCommitted(resource_id));
 }
 
 void GDataCache::GetCacheEntryHelper(const std::string& resource_id,
                                      const std::string& md5,
                                      bool* success,
-                                     GDataCache::CacheEntry* cache_entry) {
+                                     GDataCacheEntry* cache_entry) {
   AssertOnSequencedWorkerPool();
   DCHECK(success);
   DCHECK(cache_entry);
 
-  scoped_ptr<GDataCache::CacheEntry> value(GetCacheEntry(resource_id, md5));
+  scoped_ptr<GDataCacheEntry> value(GetCacheEntry(resource_id, md5));
   *success = value.get();
   if (*success)
     *cache_entry = *value;
 }
 
 // static
 FilePath GDataCache::GetCacheRootPath(Profile* profile) {
   FilePath cache_base_path;
   chrome::GetUserCacheDirectory(profile->GetPath(), &cache_base_path);
   FilePath cache_root_path =
@@ skipping 29 matching lines @@
       // Error creating this directory, record error and proceed with next one.
       success = false;
       PLOG(ERROR) << "Error creating directory " << paths_to_create[i].value();
     } else {
       DVLOG(1) << "Created directory " << paths_to_create[i].value();
     }
   }
   return success;
 }
 
+// static
+GDataCache::CacheSubDirectoryType GDataCache::GetSubDirectoryType(
+    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