Check for space before storing files to the cache.

chrome/browser/chromeos/gdata/gdata_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 <vector>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 791 matching lines @@
   std::string escaped_resource_id = util::EscapeCacheFileName(resource_id);
   std::string escaped_md5 = util::EscapeCacheFileName(md5);
   num_callback_invocations_ = 0;
   TestGetCacheFilePath(resource_id, md5,
                        escaped_resource_id + FilePath::kExtensionSeparator +
                        escaped_md5);
   EXPECT_EQ(0, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, StoreToCacheSimple) {
+  EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
+      .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
+
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // Store an existing file.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Store a non-existent file to the same |resource_id| and |md5|.
@@ skipping 12 matching lines @@
                    GDATA_FILE_OK, test_util::TEST_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.
   EXPECT_EQ(1U, CountCacheFiles(resource_id, md5));
 }
 
 TEST_F(GDataCacheTest, GetFromCacheSimple) {
+  EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
+      .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
+
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   // First store a file to cache.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Then try to get the existing file from cache.
   num_callback_invocations_ = 0;
   TestGetFileFromCacheByResourceIdAndMd5(
@@ skipping 10 matching lines @@
   // Get file from cache with different resource id from existing file but same
   // md5.
   num_callback_invocations_ = 0;
   resource_id = "document:1a2b";
   TestGetFileFromCacheByResourceIdAndMd5(
       resource_id, md5, GDATA_FILE_ERROR_NOT_FOUND, md5);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, RemoveFromCacheSimple) {
+  EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
+      .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
+
   // 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, GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Then try to remove existing file from cache.
   num_callback_invocations_ = 0;
@@ skipping 79 matching lines @@
       .Times(0);
 
   num_callback_invocations_ = 0;
   TestUnpin(resource_id, md5, GDATA_FILE_ERROR_NOT_FOUND,
             test_util::TEST_CACHE_STATE_NONE,
             GDataCache::CACHE_TYPE_TMP /* non-applicable */);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, StoreToCachePinned) {
+  EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
+      .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
+
   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, GDATA_FILE_OK,
           test_util::TEST_CACHE_STATE_PINNED,
           GDataCache::CACHE_TYPE_TMP);
 
   // Store an existing file to a previously pinned file.
@@ skipping 11 matching lines @@
   TestStoreToCache(resource_id, md5, FilePath("./non_existent.json"),
                    GDATA_FILE_ERROR_FAILED,
                    test_util::TEST_CACHE_STATE_PRESENT |
                    test_util::TEST_CACHE_STATE_PINNED |
                    test_util::TEST_CACHE_STATE_PERSISTENT,
                    GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, GetFromCachePinned) {
+  EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
+      .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
+
   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, GDATA_FILE_OK,
           test_util::TEST_CACHE_STATE_PINNED,
           GDataCache::CACHE_TYPE_TMP);
 
   // Get the non-existent pinned file from cache.
@@ skipping 11 matching lines @@
                    GDataCache::CACHE_TYPE_PERSISTENT);
 
   // Get the previously pinned and stored file from cache.
   num_callback_invocations_ = 0;
   TestGetFileFromCacheByResourceIdAndMd5(
       resource_id, md5, GDATA_FILE_OK, md5);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, RemoveFromCachePinned) {
+  EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
+      .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
+
   // 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, GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   TestPin(resource_id, md5, GDATA_FILE_OK,
@@ skipping 20 matching lines @@
           test_util::TEST_CACHE_STATE_PINNED |
           test_util::TEST_CACHE_STATE_PERSISTENT,
           GDataCache::CACHE_TYPE_PERSISTENT);
 
   num_callback_invocations_ = 0;
   TestRemoveFromCache(resource_id, GDATA_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, DirtyCacheSimple) {
+  EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
+      .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
+
   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, GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Mark the file dirty.
@@ skipping 16 matching lines @@
 
   // Clear dirty state of the file.
   num_callback_invocations_ = 0;
   TestClearDirty(resource_id, md5, GDATA_FILE_OK,
                  test_util::TEST_CACHE_STATE_PRESENT,
                  GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, DirtyCachePinned) {
+  EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
+      .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
+
   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, GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   TestPin(resource_id, md5, GDATA_FILE_OK,
@@ skipping 77 matching lines @@
             test_util::TEST_CACHE_STATE_PRESENT |
             test_util::TEST_CACHE_STATE_DIRTY |
             test_util::TEST_CACHE_STATE_PERSISTENT,
             GDataCache::CACHE_TYPE_PERSISTENT);
 
   // Verify dirty file still exist at the same pathname.
   EXPECT_TRUE(file_util::PathExists(dirty_path));
 }
 
 TEST_F(GDataCacheTest, DirtyCacheRepetitive) {
+  EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
+      .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
+
   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, GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Mark the file dirty.
@@ skipping 60 matching lines @@
 
   // Again, clear dirty state of the file, which is no longer dirty.
   num_callback_invocations_ = 0;
   TestClearDirty(resource_id, md5, GDATA_FILE_ERROR_INVALID_OPERATION,
                  test_util::TEST_CACHE_STATE_PRESENT,
                  GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, DirtyCacheInvalid) {
+  EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
+      .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
+
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // Mark a non-existent file dirty.
   num_callback_invocations_ = 0;
   TestMarkDirty(resource_id, md5, GDATA_FILE_ERROR_NOT_FOUND,
                 test_util::TEST_CACHE_STATE_NONE,
                 GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
@@ skipping 42 matching lines @@
   TestStoreToCache(resource_id, md5, GetTestFilePath("subdir_feed.json"),
                    GDATA_FILE_ERROR_IN_USE,
                    test_util::TEST_CACHE_STATE_PRESENT |
                    test_util::TEST_CACHE_STATE_DIRTY |
                    test_util::TEST_CACHE_STATE_PERSISTENT,
                    GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, RemoveFromDirtyCache) {
+  EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
+      .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
+
   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, GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   TestPin(resource_id, md5, GDATA_FILE_OK,
@@ skipping 15 matching lines @@
                   GDataCache::CACHE_TYPE_PERSISTENT);
 
   // Try to remove the file.  Since file is dirty, it and the corresponding
   // pinned and outgoing symlinks should not be removed.
   num_callback_invocations_ = 0;
   TestRemoveFromCache(resource_id, GDATA_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, MountUnmount) {
+  EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
+      .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
+
   FilePath file_path;
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // First store a file to cache in the tmp subdir.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Mark the file mounted.
@@ skipping 77 matching lines @@
   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]);
 }
 
 
 TEST_F(GDataCacheTest, ClearAllOnUIThread) {
   PrepareForInitCacheTest();
 
+  EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
+      .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
+
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // Store an existing file.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Verify that there's only one cached file.
   EXPECT_EQ(1U, CountCacheFiles(resource_id, md5));
 
   // Clear cache.
   GDataFileError error = GDATA_FILE_OK;
   FilePath file_path;
   cache_->ClearAllOnUIThread(base::Bind(&OnClearAll,
                                         &error,
                                         &file_path));
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_OK, error);
 
   // Verify that all the cache is removed.
   VerifyRemoveFromCache(error, resource_id, md5);
   EXPECT_EQ(0U, CountCacheFiles(resource_id, md5));
 }
 
+TEST_F(GDataCacheTest, StoreToCacheNoSpace) {
+  EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
+      .Times(AtLeast(1)).WillRepeatedly(Return(0));
+
+  std::string resource_id("pdf:1a2b");
+  std::string md5("abcdef0123456789");
+
+  // Try to store an existing file.
+  TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
+                   GDATA_FILE_ERROR_NO_SPACE,
+                   test_util::TEST_CACHE_STATE_NONE,
+                   GDataCache::CACHE_TYPE_TMP);
+  EXPECT_EQ(1, num_callback_invocations_);
+
+  // Verify that there's no files added.
+  EXPECT_EQ(0U, CountCacheFiles(resource_id, md5));
+}
+
+
 }   // namespace gdata