AppCache + Quota integration

webkit/appcache/appcache_storage_impl_unittest.cc

 // Copyright (c) 2011 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/threading/thread.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/net_errors.h"
@@ skipping 312 matching lines @@
     // load should complete syncly.
 
     // Setup some preconditions. Make an 'unstored' cache for
     // us to load. The ctor should put it in the working set.
     int64 cache_id = storage()->NewCacheId();
     scoped_refptr<AppCache> cache(new AppCache(service(), cache_id));
 
     // Conduct the test.
     storage()->LoadCache(cache_id, delegate());
     EXPECT_EQ(cache_id, delegate()->loaded_cache_id_);
     EXPECT_EQ(cache.get(), delegate()->loaded_cache_.get());

[michaeln, 2011/06/08 18:09:54]

verify access notification

     TestFinished();
   }
 
   // CreateGroup  --------------------------------------------
 
   void CreateGroupInEmptyOrigin() {
     // Attempt to load a group that doesn't exist, one should
     // be created for us, but not stored.
 
     // Since the origin has no groups, the storage class will respond
     // syncly.
     storage()->LoadOrCreateGroup(kManifestUrl, delegate());
     Verify_CreateGroup();
   }
 
   void CreateGroupInPopulatedOrigin() {
     // Attempt to load a group that doesn't exist, one should
     // be created for us, but not stored.
     PushNextTask(NewRunnableMethod(
        this, &AppCacheStorageImplTest::Verify_CreateGroup));
 
     // Since the origin has groups, storage class will have to
     // consult the database and completion will be async.
-    storage()->origins_with_groups_.insert(kManifestUrl.GetOrigin());
+    storage()->usage_map_[kManifestUrl.GetOrigin()] = 10;
 
     storage()->LoadOrCreateGroup(kManifestUrl, delegate());
     EXPECT_FALSE(delegate()->loaded_group_.get());
   }
 
   void Verify_CreateGroup() {

[michaeln, 2011/06/08 18:09:54]

verify access notification

     EXPECT_EQ(kManifestUrl, delegate()->loaded_manifest_url_);
     EXPECT_TRUE(delegate()->loaded_group_.get());
     EXPECT_TRUE(delegate()->loaded_group_->HasOneRef());
     EXPECT_FALSE(delegate()->loaded_group_->newest_complete_cache());
 
     // Should not have been stored in the database.
     AppCacheDatabase::GroupRecord record;
     EXPECT_FALSE(database()->FindGroup(
         delegate()->loaded_group_->group_id(), &record));
 
@@ skipping 25 matching lines @@
     EXPECT_EQ(1, delegate()->loaded_cache_id_);
 
     // The group should also have been loaded.
     EXPECT_TRUE(delegate()->loaded_cache_->owning_group());
     EXPECT_TRUE(delegate()->loaded_cache_->owning_group()->HasOneRef());
     EXPECT_EQ(1, delegate()->loaded_cache_->owning_group()->group_id());
 
     // Drop things from the working set.
     delegate()->loaded_cache_ = NULL;
     EXPECT_FALSE(delegate()->loaded_group_);
 

[michaeln, 2011/06/08 18:09:54]

verify access notification

     // Conduct the group load test, also complete asyncly.
     PushNextTask(NewRunnableMethod(
        this, &AppCacheStorageImplTest::Verify_LoadGroup_Far_Hit));
 
     storage()->LoadOrCreateGroup(kManifestUrl, delegate());
   }
 
   void Verify_LoadGroup_Far_Hit() {
     EXPECT_TRUE(delegate()->loaded_group_);
     EXPECT_EQ(kManifestUrl, delegate()->loaded_manifest_url_);
     EXPECT_TRUE(delegate()->loaded_group_->newest_complete_cache());
     delegate()->loaded_groups_newest_cache_ = NULL;
     EXPECT_TRUE(delegate()->loaded_group_->HasOneRef());

[michaeln, 2011/06/08 18:09:54]

verify access notification

     TestFinished();
   }
 
   // StoreNewGroup  --------------------------------------
 
   void StoreNewGroup() {
     // Store a group and its newest cache. Should complete asyncly.
     PushNextTask(NewRunnableMethod(
        this, &AppCacheStorageImplTest::Verify_StoreNewGroup));
 
     // 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());

[michaeln, 2011/06/08 18:09:54]

add an Entry to have a non-zero cache size

     // 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_);
   }
 
   void Verify_StoreNewGroup() {
     EXPECT_TRUE(delegate()->stored_group_success_);
     EXPECT_EQ(group_.get(), delegate()->stored_group_.get());
     EXPECT_EQ(cache_.get(), group_->newest_complete_cache());
     EXPECT_TRUE(cache_->is_complete());
 
     // Should have been stored in the database.
     AppCacheDatabase::GroupRecord group_record;
     AppCacheDatabase::CacheRecord cache_record;
     EXPECT_TRUE(database()->FindGroup(group_->group_id(), &group_record));
     EXPECT_TRUE(database()->FindCache(cache_->cache_id(), &cache_record));

[michaeln, 2011/06/08 18:09:54]

also verify notification of the modification

     TestFinished();
   }
 
   // StoreExistingGroup  --------------------------------------
 
   void StoreExistingGroup() {
     // Store a group and its newest cache. Should complete asyncly.
     PushNextTask(NewRunnableMethod(
        this, &AppCacheStorageImplTest::Verify_StoreExistingGroup));
 
     // Setup some preconditions. Create a group and old complete cache
     // that appear to be "stored"
     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
 
     // And a newest unstored complete cache.
     cache2_ = new AppCache(service(), 2);

[michaeln, 2011/06/08 18:09:54]

ditto add an entry

 
     // Conduct the test.
     storage()->StoreGroupAndNewestCache(group_, cache2_, delegate());
     EXPECT_FALSE(delegate()->stored_group_success_);
   }
 
   void Verify_StoreExistingGroup() {
     EXPECT_TRUE(delegate()->stored_group_success_);
     EXPECT_EQ(group_.get(), delegate()->stored_group_.get());
     EXPECT_EQ(cache2_.get(), group_->newest_complete_cache());
     EXPECT_TRUE(cache2_->is_complete());
 
     // The new cache should have been stored in the database.
     AppCacheDatabase::GroupRecord group_record;
     AppCacheDatabase::CacheRecord cache_record;
     EXPECT_TRUE(database()->FindGroup(1, &group_record));
     EXPECT_TRUE(database()->FindCache(2, &cache_record));
 
     // The old cache should have been deleted
     EXPECT_FALSE(database()->FindCache(1, &cache_record));

[michaeln, 2011/06/08 18:09:54]

ditto verify modification notification

     TestFinished();
   }
 
   // StoreExistingGroupExistingCache  -------------------------------
 
   void StoreExistingGroupExistingCache() {
     // Store a group with updates to its existing newest complete cache.
     // Setup some preconditions. Create a group and a complete cache that
     // appear to be "stored".
 
@@ skipping 29 matching lines @@
     EXPECT_TRUE(expected_update_time == cache_record.update_time);
     EXPECT_EQ(100, cache_record.cache_size);
 
     std::vector<AppCacheDatabase::EntryRecord> entry_records;
     EXPECT_TRUE(database()->FindEntriesForCache(1, &entry_records));
     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);

[michaeln, 2011/06/08 18:09:54]

verify modification notification

 
     TestFinished();
   }
 
   // FailStoreGroup  --------------------------------------
 
   void FailStoreGroup() {
     // Store a group and its newest cache. Should complete asyncly.
     PushNextTask(NewRunnableMethod(
        this, &AppCacheStorageImplTest::Verify_FailStoreGroup));
@@ skipping 19 matching lines @@
     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));
 
     TestFinished();
   }
 

[michaeln, 2011/06/08 18:09:54]

add a test for querying the quotaMgr for the space available, perhaps two, one
where the QM returns immediately and another where it's async

   // 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);
-    EXPECT_FALSE(storage()->origins_with_groups_.empty());
+    EXPECT_FALSE(storage()->usage_map_.empty());
 
     // Also insert some related records.
     AppCacheDatabase::EntryRecord entry_record;
     entry_record.cache_id = 1;
     entry_record.flags = AppCacheEntry::FALLBACK;
     entry_record.response_id = 1;
     entry_record.url = kEntryUrl;
     EXPECT_TRUE(database()->InsertEntry(&entry_record));
 
     AppCacheDatabase::FallbackNameSpaceRecord fallback_namespace_record;
@@ skipping 11 matching lines @@
 
     // Conduct the test.
     storage()->MakeGroupObsolete(group_, delegate());
     EXPECT_FALSE(group_->is_obsolete());
   }
 
   void Verify_MakeGroupObsolete() {
     EXPECT_TRUE(delegate()->obsoleted_success_);
     EXPECT_EQ(group_.get(), delegate()->obsoleted_group_.get());
     EXPECT_TRUE(group_->is_obsolete());
-    EXPECT_TRUE(storage()->origins_with_groups_.empty());
+    EXPECT_TRUE(storage()->usage_map_.empty());
 
     // The cache and group have been deleted from the database.
     AppCacheDatabase::GroupRecord group_record;
     AppCacheDatabase::CacheRecord cache_record;
     EXPECT_FALSE(database()->FindGroup(1, &group_record));
     EXPECT_FALSE(database()->FindCache(1, &cache_record));
 
     // The related records should have been deleted too.
     std::vector<AppCacheDatabase::EntryRecord> entry_records;
     database()->FindEntriesForCache(1, &entry_records);
     EXPECT_TRUE(entry_records.empty());
     std::vector<AppCacheDatabase::FallbackNameSpaceRecord> fallback_records;
     database()->FindFallbackNameSpacesForCache(1, &fallback_records);
     EXPECT_TRUE(fallback_records.empty());
     std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelist_records;
     database()->FindOnlineWhiteListForCache(1, &whitelist_records);
     EXPECT_TRUE(whitelist_records.empty());

[michaeln, 2011/06/08 18:09:54]

verify modification notification

 
     TestFinished();
   }
 
   // MarkEntryAsForeign  -------------------------------
 
   void MarkEntryAsForeign() {
     // Setup some preconditions. Create a cache with an entry
     // in storage and in the working set.
     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
@@ skipping 481 matching lines @@
       group_record.group_id = group_id;
       group_record.manifest_url = manifest_url;
       group_record.origin = manifest_url.GetOrigin();
       EXPECT_TRUE(database()->InsertGroup(&group_record));
       AppCacheDatabase::CacheRecord cache_record;
       cache_record.cache_id = cache_id;
       cache_record.group_id = group_id;
       cache_record.online_wildcard = false;
       cache_record.update_time = kZeroTime;
       EXPECT_TRUE(database()->InsertCache(&cache_record));
-      storage()->origins_with_groups_.insert(manifest_url.GetOrigin());
+      storage()->usage_map_[manifest_url.GetOrigin()] = 10;
     }
   }
 
   // Data members --------------------------------------------------
 
   scoped_ptr<base::WaitableEvent> test_finished_event_;
   std::stack<Task*> task_stack_;
   MockAppCachePolicy policy_;
   scoped_ptr<AppCacheService> service_;
   scoped_ptr<MockStorageDelegate> delegate_;
@@ skipping 96 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);