drive: Rename FileCache methods in a blocking pool centric manner

chrome/browser/chromeos/drive/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 "chrome/browser/chromeos/drive/file_system.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 263 matching lines @@
       return entry->resource_id();
     else
       return "";
   }
 
   // Helper function to call GetCacheEntry from origin thread.
   bool GetCacheEntryFromOriginThread(const std::string& resource_id,
                                      const std::string& md5,
                                      FileCacheEntry* cache_entry) {
     bool result = false;
-    cache_->GetCacheEntry(resource_id, md5,
-                          google_apis::test_util::CreateCopyResultCallback(
-                              &result, cache_entry));
+    cache_->GetCacheEntryOnUIThread(
+        resource_id, md5,
+        google_apis::test_util::CreateCopyResultCallback(&result, cache_entry));
     google_apis::test_util::RunBlockingPoolTask();
     return result;
   }
 
   // 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) {
     FileCacheEntry cache_entry;
     return GetCacheEntryFromOriginThread(resource_id, md5, &cache_entry);
   }
@@ skipping 758 matching lines @@
   file_system_->TransferFileFromRemoteToLocal(
       remote_src_file_path,
       local_dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // The content is "x"s of the file size.
   base::FilePath cache_file_path;
-  cache_->GetFile(file->resource_id(),
-                  file->file_specific_info().file_md5(),
-                  google_apis::test_util::CreateCopyResultCallback(
-                      &error, &cache_file_path));
+  cache_->GetFileOnUIThread(file->resource_id(),
+                            file->file_specific_info().file_md5(),
+                            google_apis::test_util::CreateCopyResultCallback(
+                                &error, &cache_file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   const std::string kExpectedContent = "xxxxxxxxxx";
   std::string cache_file_data;
   EXPECT_TRUE(file_util::ReadFileToString(cache_file_path, &cache_file_data));
   EXPECT_EQ(kExpectedContent, cache_file_data);
 
   std::string local_dest_file_data;
   EXPECT_TRUE(file_util::ReadFileToString(local_dest_file_path,
@@ skipping 593 matching lines @@
 
   // Store something of the file size in the temporary cache directory.
   const std::string content(file_size, 'x');
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   const base::FilePath tmp_file =
       temp_dir.path().AppendASCII("something.txt");
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(tmp_file, content));
 
   FileError error = FILE_ERROR_FAILED;
-  cache_->Store("<resource_id>", "<md5>", tmp_file,
-                internal::FileCache::FILE_OPERATION_COPY,
-                google_apis::test_util::CreateCopyResultCallback(&error));
+  cache_->StoreOnUIThread(
+      "<resource_id>", "<md5>", tmp_file,
+      internal::FileCache::FILE_OPERATION_COPY,
+      google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(CacheEntryExists("<resource_id>", "<md5>"));
 
   base::FilePath file_path;
   entry.reset();
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
                                   &error, &file_path, &entry));
   google_apis::test_util::RunBlockingPoolTask();
@@ skipping 38 matching lines @@
 TEST_F(DriveFileSystemTest, GetFileByPath_FromCache) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetEntryInfoByPathSync(file_in_root));
 
   // Store something as cached version of this file.
   FileError error = FILE_ERROR_OK;
-  cache_->Store(entry->resource_id(),
-                entry->file_specific_info().file_md5(),
-                google_apis::test_util::GetTestFilePath(
-                    "chromeos/gdata/root_feed.json"),
-                internal::FileCache::FILE_OPERATION_COPY,
-                google_apis::test_util::CreateCopyResultCallback(&error));
+  cache_->StoreOnUIThread(
+      entry->resource_id(),
+      entry->file_specific_info().file_md5(),
+      google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
+      internal::FileCache::FILE_OPERATION_COPY,
+      google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   base::FilePath file_path;
   entry.reset();
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
                                   &error, &file_path, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
@@ skipping 140 matching lines @@
 TEST_F(DriveFileSystemTest, GetFileByResourceId_FromCache) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetEntryInfoByPathSync(file_in_root));
 
   // Store something as cached version of this file.
   FileError error = FILE_ERROR_FAILED;
-  cache_->Store(entry->resource_id(),
-                entry->file_specific_info().file_md5(),
-                google_apis::test_util::GetTestFilePath(
-                    "chromeos/gdata/root_feed.json"),
-                internal::FileCache::FILE_OPERATION_COPY,
-                google_apis::test_util::CreateCopyResultCallback(&error));
+  cache_->StoreOnUIThread(
+      entry->resource_id(),
+      entry->file_specific_info().file_md5(),
+      google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
+      internal::FileCache::FILE_OPERATION_COPY,
+      google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // The file is obtained from the cache.
   // Hence the downloading should work even if the drive service is offline.
   fake_drive_service_->set_offline(true);
 
   std::string resource_id = entry->resource_id();
   base::FilePath file_path;
   entry.reset();
@@ skipping 16 matching lines @@
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // This is a file defined in root_feed.json.
   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   const std::string kResourceId("file:2_file_resource_id");
   const std::string kMd5("3b4382ebefec6e743578c76bbd0575ce");
 
   // Pin the file so it'll be store in "persistent" directory.
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(kResourceId, kMd5)).Times(1);
   FileError error = FILE_ERROR_OK;
-  cache_->Pin(kResourceId, kMd5,
-              google_apis::test_util::CreateCopyResultCallback(&error));
+  cache_->PinOnUIThread(
+      kResourceId, kMd5,
+      google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // First store a file to cache.
-  cache_->Store(kResourceId,
-                kMd5,
-                // Anything works.
-                google_apis::test_util::GetTestFilePath(
-                    "chromeos/gdata/root_feed.json"),
-                internal::FileCache::FILE_OPERATION_COPY,
-                google_apis::test_util::CreateCopyResultCallback(&error));
+  cache_->StoreOnUIThread(
+      kResourceId,
+      kMd5,
+      // Anything works.
+      google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
+      internal::FileCache::FILE_OPERATION_COPY,
+      google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // Add the dirty bit.
-  cache_->MarkDirty(kResourceId, kMd5,
-                    google_apis::test_util::CreateCopyResultCallback(&error));
+  cache_->MarkDirtyOnUIThread(
+      kResourceId, kMd5,
+      google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // Commit the dirty bit.
   EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(kResourceId)).Times(1);
-  cache_->CommitDirty(kResourceId, kMd5,
-                      google_apis::test_util::CreateCopyResultCallback(&error));
+  cache_->CommitDirtyOnUIThread(
+      kResourceId, kMd5,
+      google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // We'll notify the directory change to the observer upon completion.
   EXPECT_CALL(*mock_directory_observer_,
               OnDirectoryChanged(Eq(util::GetDriveMyDriveRootPath())))
       .Times(1);
 
   // Check the number of files in the root directory. We'll compare the
   // number after updating a file.
@@ skipping 193 matching lines @@
   EXPECT_EQ(kExpectedContent, cache_file_data);
 
   FileCacheEntry cache_entry;
   EXPECT_TRUE(GetCacheEntryFromOriginThread(file_resource_id, file_md5,
                                             &cache_entry));
   EXPECT_TRUE(cache_entry.is_present());
   EXPECT_TRUE(cache_entry.is_dirty());
   EXPECT_TRUE(cache_entry.is_persistent());
 
   base::FilePath cache_file_path;
-  cache_->GetFile(file_resource_id, file_md5,
-                  google_apis::test_util::CreateCopyResultCallback(
-                      &error, &cache_file_path));
+  cache_->GetFileOnUIThread(file_resource_id, file_md5,
+                            google_apis::test_util::CreateCopyResultCallback(
+                                &error, &cache_file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
   EXPECT_EQ(cache_file_path, opened_file_path);
 
   // Close kFileInRoot ("drive/root/File 1.txt").
   file_system_->CloseFile(
       kFileInRoot,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
@@ skipping 46 matching lines @@
 TEST_F(DriveFileSystemTest, MarkCacheFileAsMountedAndUnmounted) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetEntryInfoByPathSync(file_in_root));
   ASSERT_TRUE(entry);
 
   // Write to cache.
   FileError error = FILE_ERROR_FAILED;
-  cache_->Store(entry->resource_id(),
-                entry->file_specific_info().file_md5(),
-                google_apis::test_util::GetTestFilePath(
-                    "chromeos/gdata/root_feed.json"),
-                internal::FileCache::FILE_OPERATION_COPY,
-                google_apis::test_util::CreateCopyResultCallback(&error));
+  cache_->StoreOnUIThread(
+      entry->resource_id(),
+      entry->file_specific_info().file_md5(),
+      google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
+      internal::FileCache::FILE_OPERATION_COPY,
+      google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(FILE_ERROR_OK, error);
 
   // Test for mounting.
   base::FilePath file_path;
   file_system_->MarkCacheFileAsMounted(
       file_in_root,
       google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   bool success = false;
   FileCacheEntry cache_entry;
-  cache_->GetCacheEntry(
+  cache_->GetCacheEntryOnUIThread(
       entry->resource_id(),
       entry->file_specific_info().file_md5(),
       google_apis::test_util::CreateCopyResultCallback(&success, &cache_entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_TRUE(success);
   EXPECT_TRUE(cache_entry.is_mounted());
 
   // Test for unmounting.
   error = FILE_ERROR_FAILED;
   file_system_->MarkCacheFileAsUnmounted(
       file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   success = false;
-  cache_->GetCacheEntry(
+  cache_->GetCacheEntryOnUIThread(
       entry->resource_id(),
       entry->file_specific_info().file_md5(),
       google_apis::test_util::CreateCopyResultCallback(&success, &cache_entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_TRUE(success);
   EXPECT_FALSE(cache_entry.is_mounted());
 }
 
 // TODO(kinaba): crbug.com/237066
@@ skipping 49 matching lines @@
 
   // Create fails if the parent directory does not exist.
   file_system_->CreateFile(
       kFileInNonExistingDirectory, false,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_NOT_A_DIRECTORY, error);
 }
 
 }   // namespace drive