drive: Rename FileCache methods in a blocking pool centric manner

chrome/browser/chromeos/drive/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 "chrome/browser/chromeos/drive/file_cache.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 114 matching lines @@
 
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cache_resources); ++i) {
       const struct TestCacheResource& resource = test_cache_resources[i];
       // Copy file from data dir to cache.
       if (!std::string(resource.source_file).empty()) {
         base::FilePath source_path =
             google_apis::test_util::GetTestFilePath(
                 std::string("chromeos/") + resource.source_file);
 
         FileError error = FILE_ERROR_OK;
-        cache_->Store(
+        cache_->StoreOnUIThread(
             resource.resource_id,
             resource.md5,
             source_path,
             FileCache::FILE_OPERATION_COPY,
             google_apis::test_util::CreateCopyResultCallback(&error));
         google_apis::test_util::RunBlockingPoolTask();
         EXPECT_EQ(FILE_ERROR_OK, error);
       }
       // Pin.
       if (resource.is_pinned) {
         FileError error = FILE_ERROR_OK;
         EXPECT_CALL(*mock_cache_observer_,
                     OnCachePinned(resource.resource_id, resource.md5)).Times(1);
-        cache_->Pin(
+        cache_->PinOnUIThread(
             resource.resource_id,
             resource.md5,
             google_apis::test_util::CreateCopyResultCallback(&error));
         google_apis::test_util::RunBlockingPoolTask();
         EXPECT_EQ(FILE_ERROR_OK, error);
       }
       // Mark dirty.
       if (resource.is_dirty) {
         FileError error = FILE_ERROR_OK;
-        cache_->MarkDirty(
+        cache_->MarkDirtyOnUIThread(
             resource.resource_id,
             resource.md5,
             google_apis::test_util::CreateCopyResultCallback(&error));
         google_apis::test_util::RunBlockingPoolTask();
         EXPECT_EQ(FILE_ERROR_OK, error);
 
         EXPECT_CALL(*mock_cache_observer_,
                     OnCacheCommitted(resource.resource_id)).Times(1);
-        cache_->CommitDirty(
+        cache_->CommitDirtyOnUIThread(
             resource.resource_id,
             resource.md5,
             google_apis::test_util::CreateCopyResultCallback(&error));
         google_apis::test_util::RunBlockingPoolTask();
         EXPECT_EQ(FILE_ERROR_OK, error);
       }
     }
   }
 
   void TestGetFileFromCacheByResourceIdAndMd5(
       const std::string& resource_id,
       const std::string& md5,
       FileError expected_error,
       const std::string& expected_file_extension) {
     FileError error = FILE_ERROR_OK;
     base::FilePath cache_file_path;
-    cache_->GetFile(resource_id, md5,
-                    google_apis::test_util::CreateCopyResultCallback(
-                        &error, &cache_file_path));
+    cache_->GetFileOnUIThread(resource_id, md5,
+                              google_apis::test_util::CreateCopyResultCallback(
+                                  &error, &cache_file_path));
     google_apis::test_util::RunBlockingPoolTask();
 
     EXPECT_EQ(expected_error, error);
     if (error == FILE_ERROR_OK) {
       // Verify filename of |cache_file_path|.
       base::FilePath base_name = cache_file_path.BaseName();
       EXPECT_EQ(util::EscapeCacheFileName(resource_id) +
                 base::FilePath::kExtensionSeparator +
                 util::EscapeCacheFileName(
                     expected_file_extension.empty() ?
                     md5 : expected_file_extension),
                 base_name.value());
     } else {
       EXPECT_TRUE(cache_file_path.empty());
     }
   }
 
   void TestStoreToCache(
       const std::string& resource_id,
       const std::string& md5,
       const base::FilePath& source_path,
       FileError expected_error,
       int expected_cache_state,
       FileCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
     expected_sub_dir_type_ = expected_sub_dir_type;
 
     FileError error = FILE_ERROR_OK;
-    cache_->Store(resource_id, md5, source_path,
-                  FileCache::FILE_OPERATION_COPY,
-                  google_apis::test_util::CreateCopyResultCallback(&error));
+    cache_->StoreOnUIThread(
+        resource_id, md5, source_path,
+        FileCache::FILE_OPERATION_COPY,
+        google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     VerifyCacheFileState(error, resource_id, md5);
   }
 
   void TestStoreLocallyModifiedToCache(
       const std::string& resource_id,
       const std::string& md5,
       const base::FilePath& source_path,
       FileError expected_error,
       int expected_cache_state,
       FileCache::CacheSubDirectoryType expected_sub_dir_type,
       bool expected_outgoing_symlink) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
     expected_sub_dir_type_ = expected_sub_dir_type;
     expect_outgoing_symlink_ = expected_outgoing_symlink;
 
     FileError error = FILE_ERROR_OK;
-    cache_->StoreLocallyModified(
+    cache_->StoreLocallyModifiedOnUIThread(
         resource_id, md5, source_path,
         FileCache::FILE_OPERATION_COPY,
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     VerifyCacheFileState(error, resource_id, md5);
   }
 
   void TestRemoveFromCache(const std::string& resource_id,
                            FileError expected_error) {
     expected_error_ = expected_error;
 
     FileError error = FILE_ERROR_OK;
-    cache_->Remove(
+    cache_->RemoveOnUIThread(
         resource_id,
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     VerifyRemoveFromCache(error, resource_id, "");
   }
 
   void VerifyRemoveFromCache(FileError error,
                              const std::string& resource_id,
                              const std::string& md5) {
     EXPECT_EQ(expected_error_, error);
@@ skipping 76 matching lines @@
       const std::string& resource_id,
       const std::string& md5,
       FileError expected_error,
       int expected_cache_state,
       FileCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
     expected_sub_dir_type_ = expected_sub_dir_type;
 
     FileError error = FILE_ERROR_OK;
-    cache_->Pin(resource_id, md5,
-                google_apis::test_util::CreateCopyResultCallback(&error));
+    cache_->PinOnUIThread(
+        resource_id, md5,
+        google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     VerifyCacheFileState(error, resource_id, md5);
   }
 
   void TestUnpin(
       const std::string& resource_id,
       const std::string& md5,
       FileError expected_error,
       int expected_cache_state,
       FileCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
     expected_cache_state_ = expected_cache_state;
     expected_sub_dir_type_ = expected_sub_dir_type;
 
     FileError error = FILE_ERROR_OK;
-    cache_->Unpin(resource_id, md5,
-                  google_apis::test_util::CreateCopyResultCallback(&error));
+    cache_->UnpinOnUIThread(
+        resource_id, md5,
+        google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     VerifyCacheFileState(error, resource_id, md5);
   }
 
   void TestMarkDirty(const std::string& resource_id,
                      const std::string& md5,
                      FileError expected_error,
                      int expected_cache_state,
                      FileCache::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;
 
     FileError error = FILE_ERROR_OK;
-    cache_->MarkDirty(
+    cache_->MarkDirtyOnUIThread(
         resource_id, md5,
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
 
     VerifyCacheFileState(error, resource_id, md5);
 
     // Verify filename.
     if (error == FILE_ERROR_OK) {
       base::FilePath cache_file_path;
-      cache_->GetFile(resource_id, md5,
-                      google_apis::test_util::CreateCopyResultCallback(
-                          &error, &cache_file_path));
+      cache_->GetFileOnUIThread(
+          resource_id, md5,
+          google_apis::test_util::CreateCopyResultCallback(
+              &error, &cache_file_path));
       google_apis::test_util::RunBlockingPoolTask();
 
       EXPECT_EQ(FILE_ERROR_OK, error);
       base::FilePath base_name = cache_file_path.BaseName();
       EXPECT_EQ(util::EscapeCacheFileName(resource_id) +
                 base::FilePath::kExtensionSeparator +
                 "local",
                 base_name.value());
     }
   }
 
   void TestCommitDirty(
       const std::string& resource_id,
       const std::string& md5,
       FileError expected_error,
       int expected_cache_state,
       FileCache::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_ = true;
 
     FileError error = FILE_ERROR_OK;
-    cache_->CommitDirty(
+    cache_->CommitDirtyOnUIThread(
         resource_id, md5,
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     VerifyCacheFileState(error, resource_id, md5);
   }
 
   void TestClearDirty(
       const std::string& resource_id,
       const std::string& md5,
       FileError expected_error,
       int expected_cache_state,
       FileCache::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;
 
     FileError error = FILE_ERROR_OK;
-    cache_->ClearDirty(
+    cache_->ClearDirtyOnUIThread(
         resource_id, md5,
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     VerifyCacheFileState(error, resource_id, md5);
   }
 
   void TestMarkAsMounted(
       const std::string& resource_id,
       const std::string& md5,
       FileError expected_error,
       int expected_cache_state,
       FileCache::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;
 
     FileError error = FILE_ERROR_OK;
     base::FilePath cache_file_path;
-    cache_->MarkAsMounted(resource_id, md5,
-                          google_apis::test_util::CreateCopyResultCallback(
-                              &error, &cache_file_path));
+    cache_->MarkAsMountedOnUIThread(
+        resource_id, md5,
+        google_apis::test_util::CreateCopyResultCallback(
+            &error, &cache_file_path));
     google_apis::test_util::RunBlockingPoolTask();
 
     EXPECT_TRUE(file_util::PathExists(cache_file_path));
     EXPECT_EQ(cache_file_path,
               cache_->GetCacheFilePath(resource_id,
                                        md5,
                                        expected_sub_dir_type_,
                                        FileCache::CACHED_FILE_MOUNTED));
   }
 
   void TestMarkAsUnmounted(
       const std::string& resource_id,
       const std::string& md5,
       const base::FilePath& file_path,
       FileError expected_error,
       int expected_cache_state,
       FileCache::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;
 
     FileError error = FILE_ERROR_OK;
-    cache_->MarkAsUnmounted(
+    cache_->MarkAsUnmountedOnUIThread(
         file_path,
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
 
     base::FilePath cache_file_path;
-    cache_->GetFile(resource_id, md5,
-                    google_apis::test_util::CreateCopyResultCallback(
-                        &error, &cache_file_path));
+    cache_->GetFileOnUIThread(
+        resource_id, md5,
+        google_apis::test_util::CreateCopyResultCallback(
+            &error, &cache_file_path));
     google_apis::test_util::RunBlockingPoolTask();
     EXPECT_EQ(FILE_ERROR_OK, error);
 
     EXPECT_TRUE(file_util::PathExists(cache_file_path));
     EXPECT_EQ(cache_file_path,
               cache_->GetCacheFilePath(resource_id,
                                        md5,
                                        expected_sub_dir_type_,
                                        FileCache::CACHED_FILE_FROM_SERVER));
   }
@@ skipping 63 matching lines @@
                             FileCache::CachedFileOrigin file_origin) {
     return cache_->GetCacheFilePath(resource_id, md5, sub_dir_type,
                                     file_origin);
   }
 
   // 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 452 matching lines @@
       FileCache::CACHE_TYPE_TMP);
   TestMarkDirty(resource_id, md5, FILE_ERROR_OK,
                 test_util::TEST_CACHE_STATE_PRESENT |
                 test_util::TEST_CACHE_STATE_DIRTY |
                 test_util::TEST_CACHE_STATE_PERSISTENT,
                 FileCache::CACHE_TYPE_PERSISTENT);
 
   // Verifies dirty file exists.
   base::FilePath dirty_path;
   FileError error = FILE_ERROR_FAILED;
-  cache_->GetFile(
+  cache_->GetFileOnUIThread(
       resource_id, md5,
       google_apis::test_util::CreateCopyResultCallback(&error, &dirty_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
   EXPECT_TRUE(file_util::PathExists(dirty_path));
 
   // Pin the dirty file.
   TestPin(resource_id, md5, FILE_ERROR_OK,
           test_util::TEST_CACHE_STATE_PRESENT |
           test_util::TEST_CACHE_STATE_DIRTY |
@@ skipping 196 matching lines @@
                     FILE_ERROR_OK,
                     test_util::TEST_CACHE_STATE_PRESENT |
                     test_util::TEST_CACHE_STATE_MOUNTED |
                     test_util::TEST_CACHE_STATE_PERSISTENT,
                     FileCache::CACHE_TYPE_PERSISTENT);
   EXPECT_TRUE(CacheEntryExists(resource_id, md5));
 
   // Clear mounted state of the file.
   base::FilePath file_path;
   FileError error = FILE_ERROR_FAILED;
-  cache_->GetFile(
+  cache_->GetFileOnUIThread(
       resource_id, md5,
       google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   TestMarkAsUnmounted(resource_id, md5, file_path,
                       FILE_ERROR_OK,
                       test_util::TEST_CACHE_STATE_PRESENT,
                       FileCache::CACHE_TYPE_TMP);
   EXPECT_TRUE(CacheEntryExists(resource_id, md5));
 
   // Try to remove the file.
   TestRemoveFromCache(resource_id, FILE_ERROR_OK);
 }
 
 TEST_F(FileCacheTest, Iterate) {
   PrepareTestCacheResources();
 
   std::vector<std::string> resource_ids;
   std::vector<FileCacheEntry> cache_entries;
   bool completed = false;
-  cache_->Iterate(
+  cache_->IterateOnUIThread(
       base::Bind(&OnIterate, &resource_ids, &cache_entries),
       base::Bind(&OnIterateCompleted, &completed));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_TRUE(completed);
 
   sort(resource_ids.begin(), resource_ids.end());
   ASSERT_EQ(6U, resource_ids.size());
   EXPECT_EQ("dirty:existing", resource_ids[0]);
   EXPECT_EQ("dirty_and_pinned:existing", resource_ids[1]);
@@ skipping 17 matching lines @@
       resource_id, md5,
       google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
       FILE_ERROR_OK, test_util::TEST_CACHE_STATE_PRESENT,
       FileCache::CACHE_TYPE_TMP);
 
   // Verify that there's only one cached file.
   EXPECT_EQ(1U, CountCacheFiles(resource_id, md5));
 
   // Clear cache.
   bool success = false;
-  cache_->ClearAll(google_apis::test_util::CreateCopyResultCallback(&success));
+  cache_->ClearAllOnUIThread(
+      google_apis::test_util::CreateCopyResultCallback(&success));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_TRUE(success);
 
   // Verify that all the cache is removed.
   expected_error_ = FILE_ERROR_OK;
   VerifyRemoveFromCache(FILE_ERROR_OK, resource_id, md5);
   EXPECT_EQ(0U, CountCacheFiles(resource_id, md5));
 }
 
 TEST_F(FileCacheTest, StoreToCacheNoSpace) {
@@ skipping 67 matching lines @@
       google_apis::test_util::GetTestFilePath("chromeos/gdata/empty_feed.json"),
       FILE_ERROR_OK,
       test_util::TEST_CACHE_STATE_PRESENT |
       test_util::TEST_CACHE_STATE_PINNED |
       test_util::TEST_CACHE_STATE_PERSISTENT,
       FileCache::CACHE_TYPE_PERSISTENT);
 }
 
 }  // namespace internal
 }  // namespace drive