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

chrome/browser/chromeos/gdata/gdata_file_system_unittest.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 <errno.h>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 293 matching lines @@
   bool RemoveEntry(const FilePath& file_path) {
     return file_system_->RemoveEntryFromFileSystem(file_path) ==
         base::PLATFORM_FILE_OK;
   }
 
   FilePath GetCachePathForFile(GDataFile* file) {
     return file_system_->GetCacheFilePath(
         file->resource_id(),
         file->file_md5(),
         GDataCache::CACHE_TYPE_TMP,
-        GDataFileSystem::CACHED_FILE_FROM_SERVER);
+        GDataCache::CACHED_FILE_FROM_SERVER);
   }
 
   GDataEntry* FindEntry(const FilePath& file_path) {
     GDataEntry* entry = NULL;
     file_system_->root_->FindEntryByPath(
         file_path, base::Bind(&ReadOnlyFindEntryCallback, &entry));
     return entry;
   }
 
   void FindAndTestFilePath(const FilePath& file_path) {
@@ skipping 82 matching lines @@
     scoped_ptr<GDataDirectoryProto> directory_proto =
         callback_helper_->directory_proto_.Pass();
     return (directory->resource_id() ==
             directory_proto->gdata_entry().resource_id());
   }
 
   FilePath GetCacheFilePath(
       const std::string& resource_id,
       const std::string& md5,
       GDataCache::CacheSubDirectoryType sub_dir_type,
-      GDataFileSystem::CachedFileOrigin file_origin) {
+      GDataCache::CachedFileOrigin file_origin) {
     return file_system_->GetCacheFilePath(resource_id, md5, sub_dir_type,
                                           file_origin);
   }
 
   // Returns true if the cache entry exists for the given resource ID and MD5.
   bool CacheEntryExists(const std::string& resource_id,
                         const std::string& md5) {
     return file_system_->cache_->GetCacheEntry(resource_id, md5).get();
   }
 
   // Returns true if the cache file exists for the given resource ID and MD5.
   bool CacheFileExists(const std::string& resource_id,
                        const std::string& md5) {
     const FilePath file_path = file_system_->GetCacheFilePath(
         resource_id,
         md5,
         GDataCache::CACHE_TYPE_TMP,
-        GDataFileSystem::CACHED_FILE_FROM_SERVER);
+        GDataCache::CACHED_FILE_FROM_SERVER);
     return file_util::PathExists(file_path);
   }
 
   void TestGetCacheFilePath(const std::string& resource_id,
                             const std::string& md5,
                             const std::string& expected_filename) {
     FilePath actual_path = file_system_->GetCacheFilePath(
         resource_id,
         md5,
         GDataCache::CACHE_TYPE_TMP,
-        GDataFileSystem::CACHED_FILE_FROM_SERVER);
+        GDataCache::CACHED_FILE_FROM_SERVER);
     FilePath expected_path =
-        file_system_->cache_paths_[GDataCache::CACHE_TYPE_TMP];
+        file_system_->cache_->cache_paths()[GDataCache::CACHE_TYPE_TMP];
     expected_path = expected_path.Append(expected_filename);
     EXPECT_EQ(expected_path, actual_path);
 
     FilePath base_name = actual_path.BaseName();
 
     // FilePath::Extension returns ".", so strip it.
     std::string unescaped_md5 = util::UnescapeCacheFileName(
         base_name.Extension().substr(1));
     EXPECT_EQ(md5, unescaped_md5);
     std::string unescaped_resource_id = util::UnescapeCacheFileName(
@@ skipping 81 matching lines @@
     if (cache_entry.get())
       EXPECT_TRUE(cache_entry->IsDirty());
 
     // If entry doesn't exist, verify that:
     // - no files with "<resource_id>.* exists in persistent and tmp dirs
     // - no "<resource_id>" symlink exists in pinned and outgoing dirs.
     std::vector<PathToVerify> paths_to_verify;
     paths_to_verify.push_back(  // Index 0: CACHE_TYPE_TMP.
         PathToVerify(file_system_->GetCacheFilePath(resource_id, "*",
                      GDataCache::CACHE_TYPE_TMP,
-                     GDataFileSystem::CACHED_FILE_FROM_SERVER), FilePath()));
+                     GDataCache::CACHED_FILE_FROM_SERVER), FilePath()));
     paths_to_verify.push_back(  // Index 1: CACHE_TYPE_PERSISTENT.
         PathToVerify(file_system_->GetCacheFilePath(resource_id, "*",
                      GDataCache::CACHE_TYPE_PERSISTENT,
-                     GDataFileSystem::CACHED_FILE_FROM_SERVER), FilePath()));
+                     GDataCache::CACHED_FILE_FROM_SERVER), FilePath()));
     paths_to_verify.push_back(  // Index 2: CACHE_TYPE_PINNED.
         PathToVerify(file_system_->GetCacheFilePath(resource_id, "",
                      GDataCache::CACHE_TYPE_PINNED,
-                     GDataFileSystem::CACHED_FILE_FROM_SERVER), FilePath()));
+                     GDataCache::CACHED_FILE_FROM_SERVER), FilePath()));
     paths_to_verify.push_back(  // Index 3: CACHE_TYPE_OUTGOING.
         PathToVerify(file_system_->GetCacheFilePath(resource_id, "",
                      GDataCache::CACHE_TYPE_OUTGOING,
-                     GDataFileSystem::CACHED_FILE_FROM_SERVER), FilePath()));
+                     GDataCache::CACHED_FILE_FROM_SERVER), FilePath()));
     if (!cache_entry.get()) {
       for (size_t i = 0; i < paths_to_verify.size(); ++i) {
         file_util::FileEnumerator enumerator(
             paths_to_verify[i].path_to_scan.DirName(), false /* not recursive*/,
             static_cast<file_util::FileEnumerator::FileType>(
                 file_util::FileEnumerator::FILES |
                 file_util::FileEnumerator::SHOW_SYM_LINKS),
             paths_to_verify[i].path_to_scan.BaseName().value());
         EXPECT_TRUE(enumerator.Next().empty());
       }
     } else {
       // Entry is dirty, verify that:
       // - no files with "<resource_id>.*" exist in tmp dir
       // - only 1 "<resource_id>.local" exists in persistent dir
       // - only 1 <resource_id> exists in outgoing dir
       // - if entry is pinned, only 1 <resource_id> exists in pinned dir.
 
       // Change expected_existing_path of CACHE_TYPE_PERSISTENT (index 1).
       paths_to_verify[1].expected_existing_path =
           GetCacheFilePath(resource_id,
                            std::string(),
                            GDataCache::CACHE_TYPE_PERSISTENT,
-                           GDataFileSystem::CACHED_FILE_LOCALLY_MODIFIED);
+                           GDataCache::CACHED_FILE_LOCALLY_MODIFIED);
 
       // Change expected_existing_path of CACHE_TYPE_OUTGOING (index 3).
       paths_to_verify[3].expected_existing_path =
           GetCacheFilePath(resource_id,
                            std::string(),
                            GDataCache::CACHE_TYPE_OUTGOING,
-                           GDataFileSystem::CACHED_FILE_FROM_SERVER);
+                           GDataCache::CACHED_FILE_FROM_SERVER);
 
       if (cache_entry->IsPinned()) {
          // Change expected_existing_path of CACHE_TYPE_PINNED (index 2).
          paths_to_verify[2].expected_existing_path =
              GetCacheFilePath(resource_id,
                               std::string(),
                               GDataCache::CACHE_TYPE_PINNED,
-                              GDataFileSystem::CACHED_FILE_FROM_SERVER);
+                              GDataCache::CACHED_FILE_FROM_SERVER);
       }
 
       for (size_t i = 0; i < paths_to_verify.size(); ++i) {
         const struct PathToVerify& verify = paths_to_verify[i];
         file_util::FileEnumerator enumerator(
             verify.path_to_scan.DirName(), false /* not recursive*/,
             static_cast<file_util::FileEnumerator::FileType>(
                 file_util::FileEnumerator::FILES |
                 file_util::FileEnumerator::SHOW_SYM_LINKS),
             verify.path_to_scan.BaseName().value());
@@ skipping 174 matching lines @@
                              bool to_mount,
                              base::PlatformFileError error,
                              const FilePath& file_path) {
     ++num_callback_invocations_;
     EXPECT_TRUE(file_util::PathExists(file_path));
     EXPECT_TRUE(file_path == file_system_->GetCacheFilePath(
         resource_id,
         md5,
         expected_sub_dir_type_,
         to_mount ?
-            GDataFileSystemInterface::CACHED_FILE_MOUNTED :
-            GDataFileSystemInterface::CACHED_FILE_FROM_SERVER));
+            GDataCache::CACHED_FILE_MOUNTED :
+            GDataCache::CACHED_FILE_FROM_SERVER));
   }
 
   void TestSetMountedState(
       const std::string& resource_id,
       const std::string& md5,
       const FilePath& file_path,
       bool to_mount,
       base::PlatformFileError expected_error,
       int expected_cache_state,
       GDataCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
     expected_sub_dir_type_ = expected_sub_dir_type;
     expect_outgoing_symlink_ = false;
 
     file_system_->SetMountedState(file_path, to_mount,
         base::Bind(&GDataFileSystemTest::VerifySetMountedState,
                    base::Unretained(this), resource_id, md5, to_mount));
 
     RunAllPendingForIO();
   }
 
   void PrepareForInitCacheTest() {
     RunAllPendingForIO();  // Allow InitializeCacheOnBlockingPool to finish.
 
     DVLOG(1) << "PrepareForInitCacheTest start";
     // Create gdata cache sub directories.
     ASSERT_TRUE(file_util::CreateDirectory(
-        file_system_->cache_paths_[GDataCache::CACHE_TYPE_PERSISTENT]));
+        file_system_->cache_->cache_paths()[
+            GDataCache::CACHE_TYPE_PERSISTENT]));
     ASSERT_TRUE(file_util::CreateDirectory(
-        file_system_->cache_paths_[GDataCache::CACHE_TYPE_TMP]));
+        file_system_->cache_->cache_paths()[GDataCache::CACHE_TYPE_TMP]));
     ASSERT_TRUE(file_util::CreateDirectory(
-        file_system_->cache_paths_[GDataCache::CACHE_TYPE_PINNED]));
+        file_system_->cache_->cache_paths()[GDataCache::CACHE_TYPE_PINNED]));
     ASSERT_TRUE(file_util::CreateDirectory(
-        file_system_->cache_paths_[GDataCache::CACHE_TYPE_OUTGOING]));
+        file_system_->cache_->cache_paths()[GDataCache::CACHE_TYPE_OUTGOING]));
 
     // Dump some files into cache dirs so that
     // GDataFileSystem::InitializeCacheOnBlockingPool would scan through them
     // and populate cache map accordingly.
 
     // Copy files from data dir to cache dir to act as cached files.
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(initial_cache_resources); ++i) {
       const struct InitialCacheResource& resource = initial_cache_resources[i];
       // Determine gdata cache file absolute path according to cache state.
       FilePath dest_path = file_system_->GetCacheFilePath(
           resource.resource_id,
           resource.md5,
           GDataCache::IsCachePinned(resource.cache_state) ||
               GDataCache::IsCacheDirty(resource.cache_state) ?
                   GDataCache::CACHE_TYPE_PERSISTENT :
                   GDataCache::CACHE_TYPE_TMP,
           GDataCache::IsCacheDirty(resource.cache_state) ?
-              GDataFileSystem::CACHED_FILE_LOCALLY_MODIFIED :
-              GDataFileSystem::CACHED_FILE_FROM_SERVER);
+              GDataCache::CACHED_FILE_LOCALLY_MODIFIED :
+              GDataCache::CACHED_FILE_FROM_SERVER);
 
       // Copy file from data dir to cache subdir, naming it per cache files
       // convention.
       if (GDataCache::IsCachePresent(resource.cache_state)) {
         FilePath source_path = GetTestFilePath(resource.source_file);
         ASSERT_TRUE(file_util::CopyFile(source_path, dest_path));
       } else {
         dest_path = FilePath(FILE_PATH_LITERAL(kSymLinkToDevNull));
       }
 
       // Create symbolic link in pinned dir, naming it per cache files
       // convention.
       if (GDataCache::IsCachePinned(resource.cache_state)) {
         FilePath link_path = file_system_->GetCacheFilePath(
             resource.resource_id,
             "",
             GDataCache::CACHE_TYPE_PINNED,
-            GDataFileSystem::CACHED_FILE_FROM_SERVER);
+            GDataCache::CACHED_FILE_FROM_SERVER);
         ASSERT_TRUE(file_util::CreateSymbolicLink(dest_path, link_path));
       }
 
       // Create symbolic link in outgoing dir, naming it per cache files
       // convention.
       if (GDataCache::IsCacheDirty(resource.cache_state)) {
         FilePath link_path = file_system_->GetCacheFilePath(
             resource.resource_id,
             "",
             GDataCache::CACHE_TYPE_OUTGOING,
-            GDataFileSystem::CACHED_FILE_FROM_SERVER);
+            GDataCache::CACHED_FILE_FROM_SERVER);
         ASSERT_TRUE(file_util::CreateSymbolicLink(dest_path, link_path));
       }
     }
     DVLOG(1) << "PrepareForInitCacheTest finished";
     // Temporarily remove the mock sync client while rescanning. Otherwise,
     // OnCacheInitialized() is called again here, which breaks the
     // expectation set in SetUp().
     file_system_->RemoveObserver(mock_sync_client_.get());
     file_system_->RequestInitializeCacheForTesting();  // Force a re-scan.
     RunAllPendingForIO();  // Wait until the initialization is done.
@@ skipping 47 matching lines @@
 
     // Verify actual cache file.
     FilePath dest_path = file_system_->GetCacheFilePath(
         resource_id,
         md5,
         GDataCache::IsCachePinned(expected_cache_state_) ||
             GDataCache::IsCacheDirty(expected_cache_state_) ?
                 GDataCache::CACHE_TYPE_PERSISTENT :
                 GDataCache::CACHE_TYPE_TMP,
         GDataCache::IsCacheDirty(expected_cache_state_) ?
-            GDataFileSystem::CACHED_FILE_LOCALLY_MODIFIED :
-            GDataFileSystem::CACHED_FILE_FROM_SERVER);
+            GDataCache::CACHED_FILE_LOCALLY_MODIFIED :
+            GDataCache::CACHED_FILE_FROM_SERVER);
     bool exists = file_util::PathExists(dest_path);
     if (GDataCache::IsCachePresent(expected_cache_state_))
       EXPECT_TRUE(exists);
     else
       EXPECT_FALSE(exists);
 
     // Verify symlink in pinned dir.
     FilePath symlink_path = file_system_->GetCacheFilePath(
         resource_id,
         std::string(),
         GDataCache::CACHE_TYPE_PINNED,
-        GDataFileSystem::CACHED_FILE_FROM_SERVER);
+        GDataCache::CACHED_FILE_FROM_SERVER);
     // Check that pin symlink exists, without deferencing to target path.
     exists = file_util::IsLink(symlink_path);
     if (GDataCache::IsCachePinned(expected_cache_state_)) {
       EXPECT_TRUE(exists);
       FilePath target_path;
       EXPECT_TRUE(file_util::ReadSymbolicLink(symlink_path, &target_path));
       if (GDataCache::IsCachePresent(expected_cache_state_))
         EXPECT_EQ(dest_path, target_path);
       else
         EXPECT_EQ(kSymLinkToDevNull, target_path.value());
     } else {
       EXPECT_FALSE(exists);
     }
 
     // Verify symlink in outgoing dir.
     symlink_path = file_system_->GetCacheFilePath(
         resource_id,
         std::string(),
         GDataCache::CACHE_TYPE_OUTGOING,
-        GDataFileSystem::CACHED_FILE_FROM_SERVER);
+        GDataCache::CACHED_FILE_FROM_SERVER);
     // Check that outgoing symlink exists, without deferencing to target path.
     exists = file_util::IsLink(symlink_path);
     if (expect_outgoing_symlink_ &&
         GDataCache::IsCacheDirty(expected_cache_state_)) {
       EXPECT_TRUE(exists);
       FilePath target_path;
       EXPECT_TRUE(file_util::ReadSymbolicLink(symlink_path, &target_path));
       EXPECT_TRUE(target_path.value() != kSymLinkToDevNull);
       if (GDataCache::IsCachePresent(expected_cache_state_))
         EXPECT_EQ(dest_path, target_path);
@@ skipping 1347 matching lines @@
                    base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Verify that there's only one file with name <resource_id>, i.e. previously
   // cached file with the different md5 should be deleted.
   FilePath path = GetCacheFilePath(resource_id, "*",
       (GDataCache::IsCachePinned(expected_cache_state_)) ?
           GDataCache::CACHE_TYPE_PERSISTENT :
           GDataCache::CACHE_TYPE_TMP,
-      GDataFileSystem::CACHED_FILE_FROM_SERVER);
+      GDataCache::CACHED_FILE_FROM_SERVER);
   file_util::FileEnumerator enumerator(path.DirName(), false,
                                        file_util::FileEnumerator::FILES,
                                        path.BaseName().value());
   size_t num_files_found = 0;
   for (FilePath current = enumerator.Next(); !current.empty();
        current = enumerator.Next()) {
     ++num_files_found;
     EXPECT_EQ(util::EscapeCacheFileName(resource_id) +
               FilePath::kExtensionSeparator +
               util::EscapeCacheFileName(md5),
@@ skipping 306 matching lines @@
                    GDataCache::CACHE_TYPE_TMP);
   TestMarkDirty(resource_id, md5, base::PLATFORM_FILE_OK,
                 GDataCache::CACHE_STATE_PRESENT | GDataCache::CACHE_STATE_DIRTY,
                 GDataCache::CACHE_TYPE_PERSISTENT);
 
   // Verifies dirty file exists.
   FilePath dirty_path = GetCacheFilePath(
       resource_id,
       md5,
       GDataCache::CACHE_TYPE_PERSISTENT,
-      GDataFileSystem::CACHED_FILE_LOCALLY_MODIFIED);
+      GDataCache::CACHED_FILE_LOCALLY_MODIFIED);
   EXPECT_TRUE(file_util::PathExists(dirty_path));
 
   // Pin the dirty file.
   TestPin(resource_id, md5, base::PLATFORM_FILE_OK,
           GDataCache::CACHE_STATE_PRESENT | GDataCache::CACHE_STATE_DIRTY |
           GDataCache::CACHE_STATE_PINNED,
           GDataCache::CACHE_TYPE_PERSISTENT);
 
   // Verify dirty file still exist at the same pathname.
   EXPECT_TRUE(file_util::PathExists(dirty_path));
@@ skipping 1012 matching lines @@
   // First store a file to cache in the tmp subdir.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
                    base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Mark the file mounted.
   num_callback_invocations_ = 0;
   file_path = file_system_->GetCacheFilePath(
       resource_id, md5,
       GDataCache::CACHE_TYPE_TMP,
-      GDataFileSystemInterface::CACHED_FILE_FROM_SERVER);
+      GDataCache::CACHED_FILE_FROM_SERVER);
   TestSetMountedState(resource_id, md5, file_path, true,
                       base::PLATFORM_FILE_OK,
                       GDataCache::CACHE_STATE_PRESENT |
                       GDataCache::CACHE_STATE_MOUNTED,
                       GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
   EXPECT_TRUE(CacheEntryExists(resource_id, md5));
 
   // Clear mounted state of the file.
   num_callback_invocations_ = 0;
   file_path = file_system_->GetCacheFilePath(
       resource_id,
       md5,
       GDataCache::CACHE_TYPE_PERSISTENT,
-      GDataFileSystemInterface::CACHED_FILE_MOUNTED);
+      GDataCache::CACHED_FILE_MOUNTED);
   TestSetMountedState(resource_id, md5, file_path, false,
                       base::PLATFORM_FILE_OK,
                       GDataCache::CACHE_STATE_PRESENT,
                       GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
   EXPECT_TRUE(CacheEntryExists(resource_id, md5));
 
   // Try to remove the file.
   num_callback_invocations_ = 0;
   TestRemoveFromCache(resource_id, base::PLATFORM_FILE_OK);
@@ skipping 80 matching lines @@
   // Verify that the file was properly closed.
   EXPECT_EQ(base::PLATFORM_FILE_OK, callback_helper_->last_error_);
 
   // Verify that the cache state was changed as expected.
   VerifyCacheStateAfterCloseFile(callback_helper_->last_error_,
                                  file_resource_id,
                                  file_md5);
 }
 
 }   // namespace gdata