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"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_database.h"
 #include "webkit/appcache/appcache_entry.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_policy.h"
 #include "webkit/appcache/appcache_service.h"
 #include "webkit/appcache/appcache_storage_impl.h"
+#include "webkit/quota/quota_manager.h"
 #include "webkit/tools/test_shell/simple_appcache_system.h"
 
 namespace appcache {
 
 namespace {
 
 const base::Time kZeroTime;
 const GURL kManifestUrl("http://blah/manifest");
 const GURL kManifestUrl2("http://blah/manifest2");
 const GURL kManifestUrl3("http://blah/manifest3");
 const GURL kEntryUrl("http://blah/entry");
 const GURL kEntryUrl2("http://blah/entry2");
 const GURL kFallbackNamespace("http://blah/fallback_namespace/");
 const GURL kFallbackNamespace2("http://blah/fallback_namespace/longer");
 const GURL kFallbackTestUrl("http://blah/fallback_namespace/longer/test");
 const GURL kOnlineNamespace("http://blah/online_namespace");
 const GURL kOnlineNamespaceWithinFallback(
     "http://blah/fallback_namespace/online/");
+const GURL kOrigin(kManifestUrl.GetOrigin());
 
 const int kManifestEntryIdOffset = 100;
 const int kFallbackEntryIdOffset = 1000;
 
+const GURL kDefaultEntryUrl("http://blah/makecacheandgroup_default_entry");
+const int kDefaultEntrySize = 10;
+const int kDefaultEntryIdOffset = 12345;
+
+const int kMockQuota = 5000;
+
 // For the duration of this test case, we hijack the AppCacheThread API
 // calls and implement them in terms of the io and db threads created here.
 
 scoped_ptr<base::Thread> io_thread;
 scoped_ptr<base::Thread> db_thread;
 
 class TestThreadProvider : public SimpleAppCacheSystem::ThreadProvider {
  public:
   virtual bool PostTask(
       int id,
@@ skipping 118 matching lines @@
       return can_create_return_value_;
     }
 
     bool can_load_return_value_;
     int can_create_return_value_;
     GURL requested_manifest_url_;
     net::CompletionCallback* callback_;
     AppCacheStorageImplTest* test_;
   };
 
+  class MockQuotaManager : public quota::QuotaManager {
+   public:
+    MockQuotaManager()
+      : QuotaManager(true /* is_incognito */, FilePath(),
+                     io_thread->message_loop_proxy(),
+                     db_thread->message_loop_proxy(),
+                     NULL),
+        async_(false) {}
+
+    virtual void GetUsageAndQuota(
+        const GURL& origin, quota::StorageType type,
+        GetUsageAndQuotaCallback* callback) {
+      EXPECT_EQ(kOrigin, origin);
+      EXPECT_EQ(quota::kStorageTypeTemporary, type);
+      if (async_) {
+        MessageLoop::current()->PostTask(FROM_HERE,
+            NewRunnableMethod(this, &MockQuotaManager::CallCallbackAndDelete,
+                              callback));
+        return;
+      }
+      CallCallbackAndDelete(callback);
+    }
+
+    void CallCallbackAndDelete(GetUsageAndQuotaCallback* callback) {
+      callback->Run(quota::kQuotaStatusOk, 0, kMockQuota);
+      delete callback;
+    }
+
+    bool async_;
+  };
+
+  class MockQuotaManagerProxy : public quota::QuotaManagerProxy {
+   public:
+    MockQuotaManagerProxy()
+        : QuotaManagerProxy(NULL, NULL),
+          notify_storage_accessed_count_(0),
+          notify_storage_modified_count_(0),
+          last_delta_(0),
+          mock_manager_(new MockQuotaManager) {
+      manager_ = mock_manager_;
+    }
+
+    virtual void NotifyStorageAccessed(quota::QuotaClient::ID client_id,
+                                       const GURL& origin,
+                                       quota::StorageType type) {
+      EXPECT_EQ(quota::QuotaClient::kAppcache, client_id);
+      EXPECT_EQ(quota::kStorageTypeTemporary, type);
+      ++notify_storage_accessed_count_;
+      last_origin_ = origin;
+    }
+
+    virtual void NotifyStorageModified(quota::QuotaClient::ID client_id,
+                                       const GURL& origin,
+                                       quota::StorageType type,
+                                       int64 delta) {
+      EXPECT_EQ(quota::QuotaClient::kAppcache, client_id);
+      EXPECT_EQ(quota::kStorageTypeTemporary, type);
+      ++notify_storage_modified_count_;
+      last_origin_ = origin;
+      last_delta_ = delta;
+    }
+
+    // Not needed for our tests.
+    virtual void RegisterClient(quota::QuotaClient* client) {}
+    virtual void NotifyOriginInUse(const GURL& origin) {}
+    virtual void NotifyOriginNoLongerInUse(const GURL& origin) {}
+
+    int notify_storage_accessed_count_;
+    int notify_storage_modified_count_;
+    GURL last_origin_;
+    int last_delta_;
+    scoped_refptr<MockQuotaManager> mock_manager_;
+  };
+
   // Helper class run a test on our io_thread. The io_thread
   // is spun up once and reused for all tests.
   template <class Method>
   class WrapperTask : public Task {
    public:
     WrapperTask(AppCacheStorageImplTest* test, Method method)
         : test_(test), method_(method) {
     }
 
     virtual void Run() {
@@ skipping 47 matching lines @@
     test_finished_event_ .reset(new base::WaitableEvent(false, false));
     io_thread->message_loop()->PostTask(
         FROM_HERE, new WrapperTask<Method>(this, method));
     test_finished_event_->Wait();
   }
 
   void SetUpTest() {
     DCHECK(MessageLoop::current() == io_thread->message_loop());
     service_.reset(new AppCacheService(NULL));
     service_->Initialize(FilePath(), NULL);
+    mock_quota_manager_proxy_ = new MockQuotaManagerProxy();
+    service_->quota_manager_proxy_ = mock_quota_manager_proxy_;
     delegate_.reset(new MockStorageDelegate(this));
   }
 
   void TearDownTest() {
     DCHECK(MessageLoop::current() == io_thread->message_loop());
     storage()->CancelDelegateCallbacks(delegate());
     group_ = NULL;
     cache_ = NULL;
     cache2_ = NULL;
+    mock_quota_manager_proxy_ = NULL;
     delegate_.reset();
     service_.reset();
     FlushDbThreadTasks();
   }
 
   void TestFinished() {
     // We unwind the stack prior to finishing up to let stack
     // based objects get deleted.
     DCHECK(MessageLoop::current() == io_thread->message_loop());
     MessageLoop::current()->PostTask(FROM_HERE,
@@ skipping 40 matching lines @@
     PushNextTask(NewRunnableMethod(
         this, &AppCacheStorageImplTest::Verify_LoadCache_Miss));
 
     storage()->LoadCache(111, delegate());
     EXPECT_NE(111, delegate()->loaded_cache_id_);
   }
 
   void Verify_LoadCache_Miss() {
     EXPECT_EQ(111, delegate()->loaded_cache_id_);
     EXPECT_FALSE(delegate()->loaded_cache_);
+    EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_accessed_count_);
+    EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
     TestFinished();
   }
 
   // LoadCache_NearHit -------------------------------------------------
 
   void LoadCache_NearHit() {
     // Attempt to load a cache that is currently in use
     // and does not require loading from storage. This
     // 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());
+    EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_accessed_count_);
+    EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
     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_[kOrigin] = kDefaultEntrySize;
 
     storage()->LoadOrCreateGroup(kManifestUrl, delegate());
     EXPECT_FALSE(delegate()->loaded_group_.get());
   }
 
   void Verify_CreateGroup() {
     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));
 
+    EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_accessed_count_);
+    EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
+
     TestFinished();
   }
 
   // LoadGroupAndCache_FarHit  --------------------------------------
 
   void LoadGroupAndCache_FarHit() {
     // Attempt to load a cache that is not currently in use
     // and does require loading from disk. This
     // load should complete asyncly.
     PushNextTask(NewRunnableMethod(
@@ skipping 12 matching lines @@
   void Verify_LoadCache_Far_Hit() {
     EXPECT_TRUE(delegate()->loaded_cache_);
     EXPECT_TRUE(delegate()->loaded_cache_->HasOneRef());
     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());
 
+    EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_accessed_count_);
+    EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
+
     // Drop things from the working set.
     delegate()->loaded_cache_ = NULL;
     EXPECT_FALSE(delegate()->loaded_group_);
 
     // 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());
+    EXPECT_EQ(2, mock_quota_manager_proxy_->notify_storage_accessed_count_);
+    EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
     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());
+    cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, 1,
+                                              kDefaultEntrySize));
     // 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.
 
+    // Have the quota manager retrun asyncly for this test.
+    mock_quota_manager_proxy_->mock_manager_->async_ = true;
+
     // 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));
+
+    // Verify quota bookkeeping
+    EXPECT_EQ(kDefaultEntrySize, storage()->usage_map_[kOrigin]);
+    EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_modified_count_);
+    EXPECT_EQ(kOrigin, mock_quota_manager_proxy_->last_origin_);
+    EXPECT_EQ(kDefaultEntrySize, mock_quota_manager_proxy_->last_delta_);
+
     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);
+    EXPECT_EQ(kDefaultEntrySize, storage()->usage_map_[kOrigin]);
 
     // And a newest unstored complete cache.
     cache2_ = new AppCache(service(), 2);
+    cache2_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::MASTER, 1,
+                                               kDefaultEntrySize + 100));
 
     // 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));
+
+    // Verify quota bookkeeping
+    EXPECT_EQ(kDefaultEntrySize + 100, storage()->usage_map_[kOrigin]);
+    EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_modified_count_);
+    EXPECT_EQ(kOrigin, mock_quota_manager_proxy_->last_origin_);
+    EXPECT_EQ(100, mock_quota_manager_proxy_->last_delta_);
+
     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".
 
     // Setup some preconditions. Create a group and old complete cache
     // that appear to be "stored"
     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
+    EXPECT_EQ(kDefaultEntrySize, storage()->usage_map_[kOrigin]);
 
     // Change the cache.
     base::Time now = base::Time::Now();
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::MASTER, 1, 100));
     cache_->set_update_time(now);
 
     PushNextTask(NewRunnableMethod(
        this, &AppCacheStorageImplTest::Verify_StoreExistingGroupExistingCache,
        now));
 
     // Conduct the test.
     EXPECT_EQ(cache_, group_->newest_complete_cache());
     storage()->StoreGroupAndNewestCache(group_, cache_, delegate());
     EXPECT_FALSE(delegate()->stored_group_success_);
   }
 
   void Verify_StoreExistingGroupExistingCache(
       base::Time expected_update_time) {
     EXPECT_TRUE(delegate()->stored_group_success_);
     EXPECT_EQ(cache_, group_->newest_complete_cache());
 
     AppCacheDatabase::CacheRecord cache_record;
     EXPECT_TRUE(database()->FindCache(1, &cache_record));
     EXPECT_EQ(1, cache_record.cache_id);
     EXPECT_EQ(1, cache_record.group_id);
     EXPECT_FALSE(cache_record.online_wildcard);
     EXPECT_TRUE(expected_update_time == cache_record.update_time);
-    EXPECT_EQ(100, cache_record.cache_size);
+    EXPECT_EQ(100 + kDefaultEntrySize, 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(2U, entry_records.size());
+    if (entry_records[0].url == kDefaultEntryUrl)
+      entry_records.erase(entry_records.begin());
     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);
 
+    // Verify quota bookkeeping
+    EXPECT_EQ(100 + kDefaultEntrySize, storage()->usage_map_[kOrigin]);
+    EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_modified_count_);
+    EXPECT_EQ(kOrigin, mock_quota_manager_proxy_->last_origin_);
+    EXPECT_EQ(100, mock_quota_manager_proxy_->last_delta_);
+
     TestFinished();
   }
 
   // FailStoreGroup  --------------------------------------
 
   void FailStoreGroup() {
     // Store a group and its newest cache. Should complete asyncly.
     PushNextTask(NewRunnableMethod(
        this, &AppCacheStorageImplTest::Verify_FailStoreGroup));
 
@@ skipping 16 matching lines @@
   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));
 
+    EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_accessed_count_);
+    EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
+
     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);
-    EXPECT_FALSE(storage()->origins_with_groups_.empty());
+    EXPECT_EQ(kDefaultEntrySize, storage()->usage_map_[kOrigin]);
 
     // 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());
 
+    // Verify quota bookkeeping
+    EXPECT_TRUE(storage()->usage_map_.empty());
+    EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_modified_count_);
+    EXPECT_EQ(kOrigin, mock_quota_manager_proxy_->last_origin_);
+    EXPECT_EQ(-kDefaultEntrySize, mock_quota_manager_proxy_->last_delta_);
+
     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);
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT));
@@ skipping 175 matching lines @@
     cache_->fallback_namespaces_.push_back(
         FallbackNamespace(kFallbackNamespace2, kEntryUrl2));
     cache_->fallback_namespaces_.push_back(
         FallbackNamespace(kFallbackNamespace, kEntryUrl));
     AppCacheDatabase::CacheRecord cache_record;
     std::vector<AppCacheDatabase::EntryRecord> entries;
     std::vector<AppCacheDatabase::FallbackNameSpaceRecord> fallbacks;
     std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
     cache_->ToDatabaseRecords(group_,
         &cache_record, &entries, &fallbacks, &whitelists);
-    EXPECT_TRUE(database()->InsertEntryRecords(entries));
+
+    std::vector<AppCacheDatabase::EntryRecord>::const_iterator iter =
+        entries.begin();
+    while (iter != entries.end()) {
+      // MakeCacheAndGroup has inserted  the default entry record already
+      if (iter->url != kDefaultEntryUrl)
+        EXPECT_TRUE(database()->InsertEntry(&(*iter)));
+      ++iter;
+    }
+
     EXPECT_TRUE(database()->InsertFallbackNameSpaceRecords(fallbacks));
     EXPECT_TRUE(database()->InsertOnlineWhiteListRecords(whitelists));
     if (drop_from_working_set) {
       EXPECT_TRUE(cache_->HasOneRef());
       cache_ = NULL;
       EXPECT_TRUE(group_->HasOneRef());
       group_ = NULL;
     }
 
     // Conduct the test. The test url is in both fallback namespace urls,
@@ skipping 268 matching lines @@
     return storage()->database_;
   }
 
   MockStorageDelegate* delegate() {
     return delegate_.get();
   }
 
   void MakeCacheAndGroup(
       const GURL& manifest_url, int64 group_id, int64 cache_id,
       bool add_to_database) {
+    AppCacheEntry default_entry(
+        AppCacheEntry::EXPLICIT, cache_id + kDefaultEntryIdOffset,
+        kDefaultEntrySize);
     group_ = new AppCacheGroup(service(), manifest_url, group_id);
     cache_ = new AppCache(service(), cache_id);
+    cache_->AddEntry(kDefaultEntryUrl, default_entry);
     cache_->set_complete(true);
     group_->AddCache(cache_);
     if (add_to_database) {
       AppCacheDatabase::GroupRecord group_record;
       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;
+      cache_record.cache_size = kDefaultEntrySize;
       EXPECT_TRUE(database()->InsertCache(&cache_record));
-      storage()->origins_with_groups_.insert(manifest_url.GetOrigin());
+      AppCacheDatabase::EntryRecord entry_record;
+      entry_record.cache_id = cache_id;
+      entry_record.url = kDefaultEntryUrl;
+      entry_record.flags = default_entry.types();
+      entry_record.response_id = default_entry.response_id();
+      entry_record.response_size = default_entry.response_size();
+      EXPECT_TRUE(database()->InsertEntry(&entry_record));
+
+      storage()->usage_map_[manifest_url.GetOrigin()] =
+          default_entry.response_size();
     }
   }
 
   // Data members --------------------------------------------------
 
   scoped_ptr<base::WaitableEvent> test_finished_event_;
   std::stack<Task*> task_stack_;
   MockAppCachePolicy policy_;
   scoped_ptr<AppCacheService> service_;
   scoped_ptr<MockStorageDelegate> delegate_;
+  scoped_refptr<MockQuotaManagerProxy> mock_quota_manager_proxy_;
   scoped_refptr<AppCacheGroup> group_;
   scoped_refptr<AppCache> cache_;
   scoped_refptr<AppCache> cache2_;
 };
 
 
 TEST_F(AppCacheStorageImplTest, LoadCache_Miss) {
   RunTestOnIOThread(&AppCacheStorageImplTest::LoadCache_Miss);
 }
 
@@ skipping 86 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);