//chrome/browser and //components A-E: Change ScopedTempDir::path() to GetPath()

components/drive/chromeos/file_cache_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 "components/drive/chromeos/file_cache.h"
 
 #include <linux/fs.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <sys/ioctl.h>
@@ skipping 52 matching lines @@
   return (GetFileAttributes(file_path) & FS_NODUMP_FL) == FS_NODUMP_FL;
 }
 
 }  // namespace
 
 // Tests FileCache methods working with the blocking task runner.
 class FileCacheTest : public testing::Test {
  protected:
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-    const base::FilePath metadata_dir = temp_dir_.path().AppendASCII("meta");
-    cache_files_dir_ = temp_dir_.path().Append(kCacheFileDirectory);
+    const base::FilePath metadata_dir = temp_dir_.GetPath().AppendASCII("meta");
+    cache_files_dir_ = temp_dir_.GetPath().Append(kCacheFileDirectory);
 
     ASSERT_TRUE(base::CreateDirectory(metadata_dir));
     ASSERT_TRUE(base::CreateDirectory(cache_files_dir_));
 
     fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter);
 
     metadata_storage_.reset(new ResourceMetadataStorage(
         metadata_dir,
         base::ThreadTaskRunnerHandle::Get().get()));
     ASSERT_TRUE(metadata_storage_->Initialize());
@@ skipping 51 matching lines @@
 
   // Store files. This file should not be moved.
   ResourceEntry entry;
   entry.set_local_id("id_foo");
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   EXPECT_EQ(FILE_ERROR_OK, cache_->Store("id_foo", "md5", src_path,
                                          FileCache::FILE_OPERATION_COPY));
 
   // Set up files in the cache directory. These files should be moved.
   const base::FilePath file_directory =
-      temp_dir_.path().Append(kCacheFileDirectory);
+      temp_dir_.GetPath().Append(kCacheFileDirectory);
   ASSERT_TRUE(base::CopyFile(src_path, file_directory.AppendASCII("id_bar")));
   ASSERT_TRUE(base::CopyFile(src_path, file_directory.AppendASCII("id_baz")));
 
   // Insert a dirty entry with "id_baz" to |recovered_cache_info|.
   // This should not prevent the file from being recovered.
   ResourceMetadataStorage::RecoveredCacheInfoMap recovered_cache_info;
   recovered_cache_info["id_baz"].is_dirty = true;
   recovered_cache_info["id_baz"].title = "baz.png";
 
   // Recover files.
-  const base::FilePath dest_directory = temp_dir_.path().AppendASCII("dest");
+  const base::FilePath dest_directory = temp_dir_.GetPath().AppendASCII("dest");
   EXPECT_TRUE(cache_->RecoverFilesFromCacheDirectory(dest_directory,
                                                      recovered_cache_info));
 
   // Only two files should be recovered.
   EXPECT_TRUE(base::PathExists(dest_directory));
   // base::FileEnumerator does not guarantee the order.
   if (base::PathExists(dest_directory.AppendASCII("baz00000001.png"))) {
     EXPECT_TRUE(base::ContentsEqual(
         src_path,
         dest_directory.AppendASCII("baz00000001.png")));
     EXPECT_TRUE(base::ContentsEqual(
         src_path,
         dest_directory.AppendASCII("image00000002.png")));
   } else {
     EXPECT_TRUE(base::ContentsEqual(
         src_path,
         dest_directory.AppendASCII("image00000001.png")));
     EXPECT_TRUE(base::ContentsEqual(
         src_path,
         dest_directory.AppendASCII("baz00000002.png")));
   }
   EXPECT_FALSE(base::PathExists(
       dest_directory.AppendASCII("image00000003.png")));
 }
 
 TEST_F(FileCacheTest, FreeDiskSpaceIfNeededFor) {
   base::FilePath src_file;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
+  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &src_file));
 
   // Store a file as a 'temporary' file and remember the path.
   const std::string id_tmp = "id_tmp", md5_tmp = "md5_tmp";
   const time_t last_accessed_tmp = 1;
   const base::FilePath& tmp_path =
       AddTestEntry(id_tmp, md5_tmp, last_accessed_tmp, src_file);
 
   // Store a file as a pinned file and remember the path.
   const std::string id_pinned = "id_pinned", md5_pinned = "md5_pinned";
   const time_t last_accessed_pinned = 1;
@@ skipping 19 matching lines @@
   EXPECT_TRUE(base::PathExists(pinned_path));
 
   // Returns false when disk space cannot be freed.
   fake_free_disk_space_getter_->set_default_value(0);
   EXPECT_FALSE(cache_->FreeDiskSpaceIfNeededFor(kNeededBytes));
 }
 
 TEST_F(FileCacheTest, EvictDriveCacheInLRU) {
   // Create temporary file.
   base::FilePath src_file;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
+  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &src_file));
   ASSERT_EQ(kTemporaryFileSizeInBytes,
             base::WriteFile(src_file, "abcdefghij", kTemporaryFileSizeInBytes));
 
   // Add entries.
   const std::string id_a = "id_a", md5_a = "md5_a";
   const time_t last_accessed_a = 1;
   const base::FilePath& a_path =
       AddTestEntry(id_a, md5_a, last_accessed_a, src_file);
 
   const std::string id_pinned = "id_pinned", md5_pinned = "md5_pinned";
@@ skipping 38 matching lines @@
   // Entry C should not be evicted.
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id_c, &entry));
   EXPECT_TRUE(entry.file_specific_info().cache_state().is_present());
   EXPECT_TRUE(base::PathExists(c_path));
 }
 
 // Test case for deleting invalid cache files which don't have corresponding
 // metadata.
 TEST_F(FileCacheTest, EvictInvalidCacheFile) {
   base::FilePath src_file;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
+  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &src_file));
 
   // Add entries.
   const std::string id_a = "id_a", md5_a = "md5_a";
   const time_t last_accessed_a = 1;
   const base::FilePath& a_path =
       AddTestEntry(id_a, md5_a, last_accessed_a, src_file);
 
   const std::string id_b = "id_b", md5_b = "md5_b";
   const time_t last_accessed_b = 2;
   const base::FilePath& b_path =
@@ skipping 21 matching lines @@
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, metadata_storage_->GetEntry(id_b, &entry));
   EXPECT_FALSE(base::PathExists(b_path));
 }
 
 TEST_F(FileCacheTest, TooManyCacheFiles) {
   const size_t kMaxNumOfEvictedCacheFiles = 50;
   cache_->SetMaxNumOfEvictedCacheFilesForTest(kMaxNumOfEvictedCacheFiles);
 
   // Create temporary file.
   base::FilePath src_file;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
+  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &src_file));
   ASSERT_EQ(kTemporaryFileSizeInBytes,
             base::WriteFile(src_file, "abcdefghij", kTemporaryFileSizeInBytes));
 
   // Add kNumOfTestFiles=kMaxNumOfEvictedCacheFiles*2 entries.
   std::vector<base::FilePath> paths;
   const int32_t kNumOfTestFiles = kMaxNumOfEvictedCacheFiles * 2;
   for (int i = 0; i < kNumOfTestFiles; ++i) {
     // Set last accessed in reverse order to the file name. i.e. If you sort
     // files in name-asc order, they will be last access desc order.
     paths.push_back(AddTestEntry(
@@ skipping 17 matching lines @@
       (kMaxNumOfEvictedCacheFiles * 3 / 2) * kTemporaryFileSizeInBytes;
   EXPECT_FALSE(cache_->FreeDiskSpaceIfNeededFor(kNeededBytes));
 
   for (uint32_t i = 0; i < kNumOfTestFiles; ++i) {
     // Assert that only first kMaxNumOfEvictedCacheFiles exist.
     ASSERT_EQ(i < kMaxNumOfEvictedCacheFiles, base::PathExists(paths[i]));
   }
 }
 
 TEST_F(FileCacheTest, GetFile) {
-  const base::FilePath src_file_path = temp_dir_.path().Append("test.dat");
+  const base::FilePath src_file_path = temp_dir_.GetPath().Append("test.dat");
   const std::string src_contents = "test";
   EXPECT_TRUE(google_apis::test_util::WriteStringToFile(src_file_path,
                                                         src_contents));
   std::string id("id1");
   std::string md5(base::MD5String(src_contents));
 
   const base::FilePath cache_file_directory =
-      temp_dir_.path().Append(kCacheFileDirectory);
+      temp_dir_.GetPath().Append(kCacheFileDirectory);
 
   // Try to get an existing file from cache.
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   EXPECT_EQ(FILE_ERROR_OK, cache_->Store(id, md5, src_file_path,
                                          FileCache::FILE_OPERATION_COPY));
   base::FilePath cache_file_path;
   EXPECT_EQ(FILE_ERROR_OK, cache_->GetFile(id, &cache_file_path));
   EXPECT_EQ(
@@ skipping 25 matching lines @@
   EXPECT_EQ(
       cache_file_directory.AppendASCII(util::EscapeCacheFileName(id)).value(),
       cache_file_path.value());
 
   contents.clear();
   EXPECT_TRUE(base::ReadFileToString(cache_file_path, &contents));
   EXPECT_EQ(src_contents, contents);
 }
 
 TEST_F(FileCacheTest, Store) {
-  const base::FilePath src_file_path = temp_dir_.path().Append("test.dat");
+  const base::FilePath src_file_path = temp_dir_.GetPath().Append("test.dat");
   const std::string src_contents = "test";
   EXPECT_TRUE(google_apis::test_util::WriteStringToFile(src_file_path,
                                                         src_contents));
   std::string id("id");
   std::string md5(base::MD5String(src_contents));
 
   // Store a file.
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
@@ skipping 27 matching lines @@
   EXPECT_FALSE(HasRemovableFlag((dest_file_path)));
 
   // No free space available.
   fake_free_disk_space_getter_->set_default_value(0);
 
   EXPECT_EQ(FILE_ERROR_NO_LOCAL_SPACE, cache_->Store(
       id, md5, src_file_path, FileCache::FILE_OPERATION_COPY));
 }
 
 TEST_F(FileCacheTest, PinAndUnpin) {
-  const base::FilePath src_file_path = temp_dir_.path().Append("test.dat");
+  const base::FilePath src_file_path = temp_dir_.GetPath().Append("test.dat");
   const std::string src_contents = "test";
   EXPECT_TRUE(google_apis::test_util::WriteStringToFile(src_file_path,
                                                         src_contents));
   std::string id("id_present");
   std::string md5(base::MD5String(src_contents));
 
   // Store a file.
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
@@ skipping 33 matching lines @@
   EXPECT_EQ(FILE_ERROR_OK, cache_->Unpin(id_non_present));
 
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id_non_present, &entry));
   EXPECT_FALSE(entry.file_specific_info().has_cache_state());
 
   // Unpin a file that doesn't exist in cache and is not pinned.
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, cache_->Unpin("id_non_existent"));
 }
 
 TEST_F(FileCacheTest, MountUnmount) {
-  const base::FilePath src_file_path = temp_dir_.path().Append("test.dat");
+  const base::FilePath src_file_path = temp_dir_.GetPath().Append("test.dat");
   const std::string src_contents = "test";
   EXPECT_TRUE(google_apis::test_util::WriteStringToFile(src_file_path,
                                                         src_contents));
   std::string id("id_present");
   std::string md5(base::MD5String(src_contents));
 
   // Store a file.
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
@@ skipping 10 matching lines @@
   // Clear mounted state of the file.
   EXPECT_EQ(FILE_ERROR_OK, cache_->MarkAsUnmounted(cache_file_path));
 
   // Try to remove again.
   EXPECT_EQ(FILE_ERROR_OK, cache_->Remove(id));
 }
 
 TEST_F(FileCacheTest, OpenForWrite) {
   // Prepare a file.
   base::FilePath src_file;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
+  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &src_file));
 
   const std::string id = "id";
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   ASSERT_EQ(FILE_ERROR_OK, cache_->Store(id, "md5", src_file,
                                          FileCache::FILE_OPERATION_COPY));
   EXPECT_EQ(0, entry.file_info().last_modified());
 
   // Entry is not dirty nor opened.
@@ skipping 33 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(cache_->IsOpenedForWrite(id));
 
   // Try to open non-existent file.
   EXPECT_EQ(FILE_ERROR_NOT_FOUND,
             cache_->OpenForWrite("nonexistent_id", &file_closer1));
 }
 
 TEST_F(FileCacheTest, UpdateMd5) {
   // Store test data.
-  const base::FilePath src_file_path = temp_dir_.path().Append("test.dat");
+  const base::FilePath src_file_path = temp_dir_.GetPath().Append("test.dat");
   const std::string contents_before = "before";
   EXPECT_TRUE(google_apis::test_util::WriteStringToFile(src_file_path,
                                                         contents_before));
   std::string id("id1");
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   EXPECT_EQ(FILE_ERROR_OK, cache_->Store(id, base::MD5String(contents_before),
                                          src_file_path,
                                          FileCache::FILE_OPERATION_COPY));
@@ skipping 21 matching lines @@
   // Update MD5.
   EXPECT_EQ(FILE_ERROR_OK, cache_->UpdateMd5(id));
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id, &entry));
   EXPECT_EQ(base::MD5String(contents_after),
             entry.file_specific_info().cache_state().md5());
 }
 
 TEST_F(FileCacheTest, ClearDirty) {
   // Prepare a file.
   base::FilePath src_file;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
+  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &src_file));
 
   const std::string id = "id";
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   ASSERT_EQ(FILE_ERROR_OK, cache_->Store(id, "md5", src_file,
                                          FileCache::FILE_OPERATION_COPY));
 
   const base::FilePath dest_file = GetCacheFilePath(id);
   EXPECT_TRUE(HasRemovableFlag((dest_file)));
@@ skipping 16 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, cache_->ClearDirty(id));
 
   // Entry is not dirty.
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id, &entry));
   EXPECT_FALSE(entry.file_specific_info().cache_state().is_dirty());
   EXPECT_TRUE(HasRemovableFlag((dest_file)));
 }
 
 TEST_F(FileCacheTest, Remove) {
-  const base::FilePath src_file_path = temp_dir_.path().Append("test.dat");
+  const base::FilePath src_file_path = temp_dir_.GetPath().Append("test.dat");
   const std::string src_contents = "test";
   EXPECT_TRUE(google_apis::test_util::WriteStringToFile(src_file_path,
                                                         src_contents));
   std::string id("id");
   std::string md5(base::MD5String(src_contents));
 
   // First store a file to cache.
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   base::FilePath src_file;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
+  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &src_file));
   EXPECT_EQ(FILE_ERROR_OK, cache_->Store(
       id, md5, src_file_path, FileCache::FILE_OPERATION_COPY));
 
   base::FilePath cache_file_path;
   EXPECT_EQ(FILE_ERROR_OK, cache_->GetFile(id, &cache_file_path));
 
   // Then try to remove existing file from cache.
   EXPECT_EQ(FILE_ERROR_OK, cache_->Remove(id));
   EXPECT_FALSE(base::PathExists(cache_file_path));
 }
 
 TEST_F(FileCacheTest, RenameCacheFilesToNewFormat) {
   const base::FilePath file_directory =
-      temp_dir_.path().Append(kCacheFileDirectory);
+      temp_dir_.GetPath().Append(kCacheFileDirectory);
 
   // File with an old style "<prefix>:<ID>.<MD5>" name.
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(
       file_directory.AppendASCII("file:id_koo.md5"), "koo"));
 
   // File with multiple extensions should be removed.
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(
       file_directory.AppendASCII("id_kyu.md5.mounted"), "kyu (mounted)"));
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(
       file_directory.AppendASCII("id_kyu.md5"), "kyu"));
@@ skipping 19 matching lines @@
   EXPECT_EQ("koo", contents);
   contents.clear();
   EXPECT_TRUE(base::ReadFileToString(file_directory.AppendASCII("id_kyu"),
                                      &contents));
   EXPECT_EQ("kyu", contents);
 }
 
 TEST_F(FileCacheTest, FixMetadataAndFileAttributes) {
   // Create test files and metadata.
   base::FilePath temp_file;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_file));
+  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &temp_file));
 
   // Entry A: pinned cache file.
   const std::string id_a = "id_a";
   ResourceEntry entry_a;
   entry_a.set_local_id(id_a);
   FileCacheEntry* file_cache_entry_a =
       entry_a.mutable_file_specific_info()->mutable_cache_state();
   file_cache_entry_a->set_is_present(true);
   file_cache_entry_a->set_is_pinned(true);
   file_cache_entry_a->set_is_dirty(false);
@@ skipping 101 matching lines @@
 
 TEST_F(FileCacheTest, ClearAll) {
   const std::string id("1a2b");
   const std::string md5("abcdef0123456789");
 
   // Store an existing file.
   ResourceEntry entry;
   entry.set_local_id(id);
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->PutEntry(entry));
   base::FilePath src_file;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
+  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &src_file));
   ASSERT_EQ(FILE_ERROR_OK,
             cache_->Store(id, md5, src_file, FileCache::FILE_OPERATION_COPY));
 
   // Clear cache.
   EXPECT_TRUE(cache_->ClearAll());
 
   // Verify that the cache is removed.
   EXPECT_TRUE(base::IsDirectoryEmpty(cache_files_dir_));
 }
 
 }  // namespace internal
 }  // namespace drive