AppCache: Provide a way to override the default quota for an origin. The inte...

webkit/appcache/appcache_storage_impl_unittest.cc

 // Copyright (c) 2010 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 <stack>
 
 #include "base/message_loop.h"
 #include "base/thread.h"
 #include "base/waitable_event.h"
 #include "net/base/net_errors.h"
@@ skipping 55 matching lines @@
 TestThreadProvider thread_provider;
 
 }  // namespace
 
 class AppCacheStorageImplTest : public testing::Test {
  public:
   class MockStorageDelegate : public AppCacheStorage::Delegate {
    public:
     explicit MockStorageDelegate(AppCacheStorageImplTest* test)
         : loaded_cache_id_(0), stored_group_success_(false),
-          obsoleted_success_(false), found_cache_id_(kNoCacheId),
-          found_blocked_by_policy_(false), test_(test) {
+          would_exceed_quota_(false), obsoleted_success_(false),
+          found_cache_id_(kNoCacheId), found_blocked_by_policy_(false),
+          test_(test) {
     }
 
     void OnCacheLoaded(AppCache* cache, int64 cache_id) {
       loaded_cache_ = cache;
       loaded_cache_id_ = cache_id;
       test_->ScheduleNextTask();
     }
 
     void OnGroupLoaded(AppCacheGroup* group, const GURL& manifest_url) {
       loaded_group_ = group;
       loaded_manifest_url_ = manifest_url;
       loaded_groups_newest_cache_ = group ? group->newest_complete_cache()
                                           : NULL;
       test_->ScheduleNextTask();
     }
 
     void OnGroupAndNewestCacheStored(
         AppCacheGroup* group, AppCache* newest_cache, bool success,
         bool would_exceed_quota) {
       stored_group_ = group;
       stored_group_success_ = success;
+      would_exceed_quota_ = would_exceed_quota;
       test_->ScheduleNextTask();
     }
 
     void OnGroupMadeObsolete(AppCacheGroup* group, bool success) {
       obsoleted_group_ = group;
       obsoleted_success_ = success;
       test_->ScheduleNextTask();
     }
 
     void OnMainResponseFound(const GURL& url, const AppCacheEntry& entry,
                              const AppCacheEntry& fallback_entry,
                              int64 cache_id, const GURL& manifest_url,
                              bool was_blocked_by_policy) {
       found_url_ = url;
       found_entry_ = entry;
       found_fallback_entry_ = fallback_entry;
       found_cache_id_ = cache_id;
       found_manifest_url_ = manifest_url;
       found_blocked_by_policy_ = was_blocked_by_policy;
       test_->ScheduleNextTask();
     }
 
     scoped_refptr<AppCache> loaded_cache_;
     int64 loaded_cache_id_;
     scoped_refptr<AppCacheGroup> loaded_group_;
     GURL loaded_manifest_url_;
     scoped_refptr<AppCache> loaded_groups_newest_cache_;
     scoped_refptr<AppCacheGroup> stored_group_;
     bool stored_group_success_;
+    bool would_exceed_quota_;
     scoped_refptr<AppCacheGroup> obsoleted_group_;
     bool obsoleted_success_;
     GURL found_url_;
     AppCacheEntry found_entry_;
     AppCacheEntry found_fallback_entry_;
     int64 found_cache_id_;
     GURL found_manifest_url_;
     bool found_blocked_by_policy_;
     AppCacheStorageImplTest* test_;
   };
@@ skipping 387 matching lines @@
     EXPECT_EQ(1U, entry_records.size());
     EXPECT_EQ(1 , entry_records[0].cache_id);
     EXPECT_EQ(kEntryUrl, entry_records[0].url);
     EXPECT_EQ(AppCacheEntry::MASTER, entry_records[0].flags);
     EXPECT_EQ(1, entry_records[0].response_id);
     EXPECT_EQ(100, entry_records[0].response_size);
 
     TestFinished();
   }
 
+  // FailStoreGroup  --------------------------------------
+
+  void FailStoreGroup() {
+    // Store a group and its newest cache. Should complete asyncly.
+    PushNextTask(NewRunnableMethod(
+       this, &AppCacheStorageImplTest::Verify_FailStoreGroup));
+
+    // Set a low quota to force a failure.
+    const GURL kOrigin(kManifestUrl.GetOrigin());
+    EXPECT_EQ(-1L, storage()->GetOriginQuotaInMemory(kOrigin));
+    storage()->SetOriginQuotaInMemory(kManifestUrl.GetOrigin(), 0);
+    EXPECT_EQ(0L, storage()->GetOriginQuotaInMemory(kOrigin));
+
+    // Setup some preconditions. Create a group and newest cache that
+    // appear to be "unstored".
+    group_ = new AppCacheGroup(
+        service(), kManifestUrl, storage()->NewGroupId());
+    cache_ = new AppCache(service(), storage()->NewCacheId());
+    cache_->AddEntry(kManifestUrl,
+                     AppCacheEntry(AppCacheEntry::MANIFEST, 1, 1024));
+    // Hold a ref to the cache simulate the UpdateJob holding that ref,
+    // and hold a ref to the group to simulate the CacheHost holding that ref.
+
+    // Conduct the store test.
+    storage()->StoreGroupAndNewestCache(group_, cache_, delegate());
+    EXPECT_FALSE(delegate()->stored_group_success_);  // Expected to be async.
+  }
+
+  void Verify_FailStoreGroup() {
+    EXPECT_FALSE(delegate()->stored_group_success_);
+    EXPECT_TRUE(delegate()->would_exceed_quota_);
+
+    // Should not have been stored in the database.
+    AppCacheDatabase::GroupRecord group_record;
+    AppCacheDatabase::CacheRecord cache_record;
+    EXPECT_FALSE(database()->FindGroup(group_->group_id(), &group_record));
+    EXPECT_FALSE(database()->FindCache(cache_->cache_id(), &cache_record));
+
+    const GURL kOrigin(kManifestUrl.GetOrigin());
+    storage()->ResetOriginQuotaInMemory(kOrigin);
+    EXPECT_EQ(-1L, storage()->GetOriginQuotaInMemory(kOrigin));
+
+    TestFinished();
+  }
+
   // MakeGroupObsolete  -------------------------------
 
   void MakeGroupObsolete() {
     // Make a group obsolete, should complete asyncly.
     PushNextTask(NewRunnableMethod(
        this, &AppCacheStorageImplTest::Verify_MakeGroupObsolete));
 
     // Setup some preconditions. Create a group and newest cache that
     // appears to be "stored" and "currently in use".
     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
@@ skipping 454 matching lines @@
 }
 
 TEST_F(AppCacheStorageImplTest, StoreExistingGroup) {
   RunTestOnIOThread(&AppCacheStorageImplTest::StoreExistingGroup);
 }
 
 TEST_F(AppCacheStorageImplTest, StoreExistingGroupExistingCache) {
   RunTestOnIOThread(&AppCacheStorageImplTest::StoreExistingGroupExistingCache);
 }
 
+TEST_F(AppCacheStorageImplTest, FailStoreGroup) {
+  RunTestOnIOThread(&AppCacheStorageImplTest::FailStoreGroup);
+}
+
 TEST_F(AppCacheStorageImplTest, MakeGroupObsolete) {
   RunTestOnIOThread(&AppCacheStorageImplTest::MakeGroupObsolete);
 }
 
 TEST_F(AppCacheStorageImplTest, MarkEntryAsForeign) {
   RunTestOnIOThread(&AppCacheStorageImplTest::MarkEntryAsForeign);
 }
 
 TEST_F(AppCacheStorageImplTest, MarkEntryAsForeignWithLoadInProgress) {
   RunTestOnIOThread(
@@ skipping 44 matching lines @@
       &AppCacheStorageImplTest::FindMainResponseExclusionsInWorkingSet);
 }
 
 // That's all folks!
 
 }  // namespace appcache
 
 // AppCacheStorageImplTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheStorageImplTest);