drive: Move temporary file removal responsiblity to FileCache

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 25 matching lines @@
   out_cache_entries->push_back(cache_entry);
 }
 
 // Called upon completion of Iterate().
 void OnIterateCompleted(bool* out_is_called) {
   *out_is_called = true;
 }
 
 }  // namespace
 
-class FileCacheTest : public testing::Test {
+// Tests FileCache methods from UI thread.
+class FileCacheTestOnUIThread : public testing::Test {
  protected:
-  FileCacheTest()
+  FileCacheTestOnUIThread()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         expected_error_(FILE_ERROR_OK),
         expected_cache_state_(0),
         expected_sub_dir_type_(FileCache::CACHE_TYPE_META),
         expected_success_(true) {
   }
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter);
@@ skipping 445 matching lines @@
   scoped_ptr<FakeFreeDiskSpaceGetter> fake_free_disk_space_getter_;
   scoped_ptr<StrictMock<MockCacheObserver> > mock_cache_observer_;
 
   FileError expected_error_;
   int expected_cache_state_;
   FileCache::CacheSubDirectoryType expected_sub_dir_type_;
   bool expected_success_;
   std::string expected_file_extension_;
 };
 
-TEST_F(FileCacheTest, GetCacheFilePath) {
+TEST_F(FileCacheTestOnUIThread, GetCacheFilePath) {
   // Use alphanumeric characters for resource id.
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   TestGetCacheFilePath(resource_id, md5,
                        resource_id + base::FilePath::kExtensionSeparator + md5);
 
   // Use non-alphanumeric characters for resource id, including '.' which is an
   // extension separator, to test that the characters are escaped and unescaped
   // correctly, and '.' doesn't mess up the filename format and operations.
   resource_id = "pdf:`~!@#$%^&*()-_=+[{|]}\\;',<.>/?";
   std::string escaped_resource_id = util::EscapeCacheFileName(resource_id);
   std::string escaped_md5 = util::EscapeCacheFileName(md5);
   TestGetCacheFilePath(
       resource_id, md5, escaped_resource_id +
       base::FilePath::kExtensionSeparator + escaped_md5);
 }
 
-TEST_F(FileCacheTest, StoreToCacheSimple) {
+TEST_F(FileCacheTestOnUIThread, StoreToCacheSimple) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // Store an existing file.
   TestStoreToCache(
       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);
 
@@ skipping 10 matching lines @@
       resource_id, md5,
       google_apis::test_util::GetTestFilePath("chromeos/gdata/empty_feed.json"),
       FILE_ERROR_OK, test_util::TEST_CACHE_STATE_PRESENT,
       FileCache::CACHE_TYPE_TMP);
 
   // Verify that there's only one file with name <resource_id>, i.e. previously
   // cached file with the different md5 should be deleted.
   EXPECT_EQ(1U, CountCacheFiles(resource_id, md5));
 }
 
-TEST_F(FileCacheTest, LocallyModifiedSimple) {
+TEST_F(FileCacheTestOnUIThread, LocallyModifiedSimple) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   const int kDirtyCacheState =
       test_util::TEST_CACHE_STATE_PRESENT |
       test_util::TEST_CACHE_STATE_DIRTY |
       test_util::TEST_CACHE_STATE_PERSISTENT;
 
   EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(resource_id)).Times(1);
   TestStoreLocallyModifiedToCache(
       resource_id, md5,
       google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
       FILE_ERROR_OK, kDirtyCacheState, FileCache::CACHE_TYPE_PERSISTENT);
 }
 
-TEST_F(FileCacheTest, GetFromCacheSimple) {
+TEST_F(FileCacheTestOnUIThread, GetFromCacheSimple) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   // First store a file to cache.
   TestStoreToCache(
       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);
 
   // Then try to get the existing file from cache.
   TestGetFileFromCacheByResourceIdAndMd5(
       resource_id, md5, FILE_ERROR_OK, md5);
 
   // Get file from cache with same resource id as existing file but different
   // md5.
   TestGetFileFromCacheByResourceIdAndMd5(
       resource_id, "9999", FILE_ERROR_NOT_FOUND, md5);
 
   // Get file from cache with different resource id from existing file but same
   // md5.
   resource_id = "document:1a2b";
   TestGetFileFromCacheByResourceIdAndMd5(
       resource_id, md5, FILE_ERROR_NOT_FOUND, md5);
 }
 
-TEST_F(FileCacheTest, RemoveFromCacheSimple) {
+TEST_F(FileCacheTestOnUIThread, RemoveFromCacheSimple) {
   // Use alphanumeric characters for resource id.
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   // First store a file to cache.
   TestStoreToCache(
       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);
 
   // Then try to remove existing file from cache.
   TestRemoveFromCache(resource_id, FILE_ERROR_OK);
 
   // Repeat using non-alphanumeric characters for resource id, including '.'
   // which is an extension separator.
   resource_id = "pdf:`~!@#$%^&*()-_=+[{|]}\\;',<.>/?";
   TestStoreToCache(
       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);
 
   TestRemoveFromCache(resource_id, FILE_ERROR_OK);
 }
 
-TEST_F(FileCacheTest, PinAndUnpin) {
+TEST_F(FileCacheTestOnUIThread, PinAndUnpin) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(2);
   EXPECT_CALL(*mock_cache_observer_, OnCacheUnpinned(resource_id, md5))
       .Times(1);
 
   // First store a file to cache.
   TestStoreToCache(
       resource_id, md5,
       google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
@@ skipping 39 matching lines @@
   resource_id = "not-in-cache:1a2b";
   // Because unpinning will fail, OnCacheUnpinned() won't be run.
   EXPECT_CALL(*mock_cache_observer_, OnCacheUnpinned(resource_id, md5))
       .Times(0);
 
   TestUnpin(resource_id, md5, FILE_ERROR_NOT_FOUND,
             test_util::TEST_CACHE_STATE_NONE,
             FileCache::CACHE_TYPE_TMP /* non-applicable */);
 }
 
-TEST_F(FileCacheTest, StoreToCachePinned) {
+TEST_F(FileCacheTestOnUIThread, StoreToCachePinned) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
 
   // Pin a non-existent file.
   TestPin(resource_id, md5, FILE_ERROR_OK,
           test_util::TEST_CACHE_STATE_PINNED,
           FileCache::CACHE_TYPE_TMP);
 
   // Store an existing file to a previously pinned file.
   TestStoreToCache(
       resource_id, md5,
       google_apis::test_util::GetTestFilePath("chromeos/gdata/root_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);
 
   // Store a non-existent file to a previously pinned and stored file.
   TestStoreToCache(resource_id, md5, base::FilePath("./non_existent.json"),
                    FILE_ERROR_FAILED,
                    test_util::TEST_CACHE_STATE_PRESENT |
                    test_util::TEST_CACHE_STATE_PINNED |
                    test_util::TEST_CACHE_STATE_PERSISTENT,
                    FileCache::CACHE_TYPE_PERSISTENT);
 }
 
-TEST_F(FileCacheTest, GetFromCachePinned) {
+TEST_F(FileCacheTestOnUIThread, GetFromCachePinned) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
 
   // Pin a non-existent file.
   TestPin(resource_id, md5, FILE_ERROR_OK,
           test_util::TEST_CACHE_STATE_PINNED,
           FileCache::CACHE_TYPE_TMP);
 
   // Get the non-existent pinned file from cache.
   TestGetFileFromCacheByResourceIdAndMd5(
       resource_id, md5, FILE_ERROR_NOT_FOUND, md5);
 
   // Store an existing file to the previously pinned non-existent file.
   TestStoreToCache(
       resource_id, md5,
       google_apis::test_util::GetTestFilePath("chromeos/gdata/root_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);
 
   // Get the previously pinned and stored file from cache.
   TestGetFileFromCacheByResourceIdAndMd5(
       resource_id, md5, FILE_ERROR_OK, md5);
 }
 
-TEST_F(FileCacheTest, RemoveFromCachePinned) {
+TEST_F(FileCacheTestOnUIThread, RemoveFromCachePinned) {
   // Use alphanumeric characters for resource_id.
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
 
   // Store a file to cache, and pin it.
   TestStoreToCache(
       resource_id, md5,
       google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
       FILE_ERROR_OK, test_util::TEST_CACHE_STATE_PRESENT,
@@ skipping 19 matching lines @@
       FileCache::CACHE_TYPE_TMP);
   TestPin(resource_id, md5, 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);
 
   TestRemoveFromCache(resource_id, FILE_ERROR_OK);
 }
 
-TEST_F(FileCacheTest, DirtyCacheSimple) {
+TEST_F(FileCacheTestOnUIThread, DirtyCacheSimple) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(resource_id)).Times(1);
 
   // First store a file to cache.
   TestStoreToCache(
       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);
@@ skipping 11 matching lines @@
                   test_util::TEST_CACHE_STATE_DIRTY |
                   test_util::TEST_CACHE_STATE_PERSISTENT,
                   FileCache::CACHE_TYPE_PERSISTENT);
 
   // Clear dirty state of the file.
   TestClearDirty(resource_id, md5, FILE_ERROR_OK,
                  test_util::TEST_CACHE_STATE_PRESENT,
                  FileCache::CACHE_TYPE_TMP);
 }
 
-TEST_F(FileCacheTest, DirtyCachePinned) {
+TEST_F(FileCacheTestOnUIThread, DirtyCachePinned) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
   EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(resource_id)).Times(1);
 
   // First store a file to cache and pin it.
   TestStoreToCache(
       resource_id, md5,
       google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
       FILE_ERROR_OK, test_util::TEST_CACHE_STATE_PRESENT,
@@ skipping 22 matching lines @@
 
   // Clear dirty state of the file.
   TestClearDirty(resource_id, md5, 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);
 }
 
 // Test is disabled because it is flaky (http://crbug.com/134146)
-TEST_F(FileCacheTest, PinAndUnpinDirtyCache) {
+TEST_F(FileCacheTestOnUIThread, PinAndUnpinDirtyCache) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
   EXPECT_CALL(*mock_cache_observer_, OnCacheUnpinned(resource_id, md5))
       .Times(1);
 
   // First store a file to cache and mark it as dirty.
   TestStoreToCache(
       resource_id, md5,
       google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
@@ skipping 30 matching lines @@
   TestUnpin(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);
 
   // Verify dirty file still exist at the same pathname.
   EXPECT_TRUE(file_util::PathExists(dirty_path));
 }
 
-TEST_F(FileCacheTest, DirtyCacheRepetitive) {
+TEST_F(FileCacheTestOnUIThread, DirtyCacheRepetitive) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(resource_id)).Times(3);
 
   // First store a file to cache.
   TestStoreToCache(
       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);
@@ skipping 44 matching lines @@
   TestClearDirty(resource_id, md5, FILE_ERROR_OK,
                  test_util::TEST_CACHE_STATE_PRESENT,
                  FileCache::CACHE_TYPE_TMP);
 
   // Again, clear dirty state of the file, which is no longer dirty.
   TestClearDirty(resource_id, md5, FILE_ERROR_INVALID_OPERATION,
                  test_util::TEST_CACHE_STATE_PRESENT,
                  FileCache::CACHE_TYPE_TMP);
 }
 
-TEST_F(FileCacheTest, DirtyCacheInvalid) {
+TEST_F(FileCacheTestOnUIThread, DirtyCacheInvalid) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // Mark a non-existent file dirty.
   TestMarkDirty(resource_id, md5, FILE_ERROR_NOT_FOUND,
                 test_util::TEST_CACHE_STATE_NONE,
                 FileCache::CACHE_TYPE_TMP);
 
   // Clear dirty state of a non-existent file.
   TestClearDirty(resource_id, md5, FILE_ERROR_NOT_FOUND,
@@ skipping 24 matching lines @@
       resource_id, md5,
       google_apis::test_util::GetTestFilePath(
           "chromeos/gdata/empty_feed.json"),
       FILE_ERROR_IN_USE,
       test_util::TEST_CACHE_STATE_PRESENT |
       test_util::TEST_CACHE_STATE_DIRTY |
       test_util::TEST_CACHE_STATE_PERSISTENT,
       FileCache::CACHE_TYPE_PERSISTENT);
 }
 
-TEST_F(FileCacheTest, RemoveFromDirtyCache) {
+TEST_F(FileCacheTestOnUIThread, RemoveFromDirtyCache) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(resource_id, md5)).Times(1);
   EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(resource_id)).Times(1);
 
   // Store a file to cache, pin it, mark it dirty and commit it.
   TestStoreToCache(
       resource_id, md5,
       google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
       FILE_ERROR_OK, test_util::TEST_CACHE_STATE_PRESENT,
@@ skipping 13 matching lines @@
                   test_util::TEST_CACHE_STATE_PRESENT |
                   test_util::TEST_CACHE_STATE_PINNED |
                   test_util::TEST_CACHE_STATE_DIRTY |
                   test_util::TEST_CACHE_STATE_PERSISTENT,
                   FileCache::CACHE_TYPE_PERSISTENT);
 
   // Try to remove the file.  Since file is dirty, it should not be removed.
   TestRemoveFromCache(resource_id, FILE_ERROR_OK);
 }
 
-TEST_F(FileCacheTest, MountUnmount) {
+TEST_F(FileCacheTestOnUIThread, MountUnmount) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // First store a file to cache in the tmp subdir.
   TestStoreToCache(
       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);
 
@@ skipping 19 matching lines @@
   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) {
+TEST_F(FileCacheTestOnUIThread, Iterate) {
   const std::vector<test_util::TestCacheResource> cache_resources(
       test_util::GetDefaultTestCacheResources());
   // Set mock expectations.
   for (size_t i = 0; i < cache_resources.size(); ++i) {
     if (cache_resources[i].is_pinned) {
       EXPECT_CALL(*mock_cache_observer_,
                   OnCachePinned(cache_resources[i].resource_id,
                                 cache_resources[i].md5)).Times(1);
     }
     if (cache_resources[i].is_dirty) {
@@ skipping 20 matching lines @@
   EXPECT_EQ("dirty:existing", resource_ids[0]);
   EXPECT_EQ("dirty_and_pinned:existing", resource_ids[1]);
   EXPECT_EQ("pinned:existing", resource_ids[2]);
   EXPECT_EQ("pinned:non-existent", resource_ids[3]);
   EXPECT_EQ("tmp:`~!@#$%^&*()-_=+[{|]}\\;',<.>/?", resource_ids[4]);
   EXPECT_EQ("tmp:resource_id", resource_ids[5]);
 
   ASSERT_EQ(6U, cache_entries.size());
 }
 
-
-TEST_F(FileCacheTest, ClearAll) {
+TEST_F(FileCacheTestOnUIThread, ClearAll) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // Store an existing file.
   TestStoreToCache(
       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_->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) {
+TEST_F(FileCacheTestOnUIThread, StoreToCacheNoSpace) {
   fake_free_disk_space_getter_->set_default_value(0);
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // Try to store an existing file.
   TestStoreToCache(
       resource_id, md5,
       google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
       FILE_ERROR_NO_SPACE,
@@ skipping 19 matching lines @@
       pool->GetSequencedTaskRunner(pool->GetSequenceToken()),
       NULL /* free_disk_space_getter */));
 
   bool success = true;
   cache->RequestInitialize(
       google_apis::test_util::CreateCopyResultCallback(&success));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_FALSE(success);
 }
 
-TEST_F(FileCacheTest, UpdatePinnedCache) {
+TEST_F(FileCacheTestOnUIThread, UpdatePinnedCache) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   std::string md5_modified("aaaaaa0000000000");
 
   // Store an existing file.
   TestStoreToCache(
       resource_id, md5,
       google_apis::test_util::GetTestFilePath("chromeos/gdata/root_feed.json"),
       FILE_ERROR_OK,
       test_util::TEST_CACHE_STATE_PRESENT,
@@ skipping 13 matching lines @@
   TestStoreToCache(
       resource_id, md5_modified,
       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);
 }
 
+// Tests FileCache methods working with the blocking task runner.
+class FileCacheTest : public testing::Test {
+ protected:
+  FileCacheTest() : ui_thread_(content::BrowserThread::UI, &message_loop_) {}
+
+  virtual void SetUp() OVERRIDE {
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+    fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter);
+
+    cache_.reset(new FileCache(temp_dir_.path(),
+                               message_loop_.message_loop_proxy(),
+                               fake_free_disk_space_getter_.get()));
+
+    bool success = false;
+    cache_->RequestInitialize(
+        google_apis::test_util::CreateCopyResultCallback(&success));
+    message_loop_.RunUntilIdle();
+    ASSERT_TRUE(success);
+  }
+
+  virtual void TearDown() OVERRIDE {
+    cache_.reset();
+  }
+
+  base::MessageLoopForUI message_loop_;
+  content::TestBrowserThread ui_thread_;
+  base::ScopedTempDir temp_dir_;
+
+  scoped_ptr<FileCache, test_util::DestroyHelperForTests> cache_;
+  scoped_ptr<FakeFreeDiskSpaceGetter> fake_free_disk_space_getter_;
+};
+
+TEST_F(FileCacheTest, FreeDiskSpaceIfNeededFor) {
+  base::FilePath src_file;
+  ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
+
+  // Store a file as a 'temporary' file and remember the path.
+  const std::string resource_id_tmp = "id_tmp", md5_tmp = "md5_tmp";
+  ASSERT_EQ(FILE_ERROR_OK,
+            cache_->Store(resource_id_tmp, md5_tmp, src_file,
+                          FileCache::FILE_OPERATION_COPY));
+  base::FilePath tmp_path;
+  ASSERT_EQ(FILE_ERROR_OK,
+            cache_->GetFile(resource_id_tmp, md5_tmp, &tmp_path));
+
+  // Store a file as a pinned file and remember the path.
+  const std::string resource_id_pinned = "id_pinned", md5_pinned = "md5_pinned";
+  ASSERT_EQ(FILE_ERROR_OK,
+            cache_->Store(resource_id_pinned, md5_pinned, src_file,
+                          FileCache::FILE_OPERATION_COPY));
+  ASSERT_EQ(FILE_ERROR_OK, cache_->Pin(resource_id_pinned, md5_pinned));
+  base::FilePath pinned_path;
+  ASSERT_EQ(FILE_ERROR_OK,
+            cache_->GetFile(resource_id_pinned, md5_pinned, &pinned_path));
+
+  // Call FreeDiskSpaceIfNeededFor().
+  fake_free_disk_space_getter_->set_default_value(test_util::kLotsOfSpace);
+  fake_free_disk_space_getter_->PushFakeValue(0);
+  const int64 kNeededBytes = 1;
+  EXPECT_TRUE(cache_->FreeDiskSpaceIfNeededFor(kNeededBytes));
+
+  // Only 'temporary' file gets removed.
+  FileCacheEntry entry;
+  EXPECT_FALSE(cache_->GetCacheEntry(resource_id_tmp, md5_tmp, &entry));
+  EXPECT_FALSE(file_util::PathExists(tmp_path));
+
+  EXPECT_TRUE(cache_->GetCacheEntry(resource_id_pinned, md5_pinned, &entry));
+  EXPECT_TRUE(file_util::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));
+}
+
 }  // namespace internal
 }  // namespace drive