summaryrefslogtreecommitdiffstats
path: root/webkit/browser/appcache/appcache_storage_impl_unittest.cc
diff options
context:
space:
mode:
Diffstat (limited to 'webkit/browser/appcache/appcache_storage_impl_unittest.cc')
-rw-r--r--webkit/browser/appcache/appcache_storage_impl_unittest.cc1645
1 files changed, 1645 insertions, 0 deletions
diff --git a/webkit/browser/appcache/appcache_storage_impl_unittest.cc b/webkit/browser/appcache/appcache_storage_impl_unittest.cc
new file mode 100644
index 0000000..81d9ae4
--- /dev/null
+++ b/webkit/browser/appcache/appcache_storage_impl_unittest.cc
@@ -0,0 +1,1645 @@
+// 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 <stack>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/callback.h"
+#include "base/message_loop.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/thread.h"
+#include "net/base/net_errors.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "webkit/browser/appcache/appcache.h"
+#include "webkit/browser/appcache/appcache_database.h"
+#include "webkit/browser/appcache/appcache_entry.h"
+#include "webkit/browser/appcache/appcache_group.h"
+#include "webkit/browser/appcache/appcache_service.h"
+#include "webkit/browser/appcache/appcache_storage_impl.h"
+#include "webkit/browser/quota/quota_manager.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 kInterceptNamespace("http://blah/intercept_namespace/");
+const GURL kInterceptNamespace2("http://blah/intercept_namespace/longer/");
+const GURL kInterceptTestUrl("http://blah/intercept_namespace/longer/test");
+const GURL kInterceptPatternNamespace("http://blah/intercept_pattern/*/bar");
+const GURL kInterceptPatternTestPositiveUrl(
+ "http://blah/intercept_pattern/foo/bar");
+const GURL kInterceptPatternTestNegativeUrl(
+ "http://blah/intercept_pattern/foo/not_bar");
+const GURL kFallbackPatternNamespace("http://blah/fallback_pattern/*/bar");
+const GURL kFallbackPatternTestPositiveUrl(
+ "http://blah/fallback_pattern/foo/bar");
+const GURL kFallbackPatternTestNegativeUrl(
+ "http://blah/fallback_pattern/foo/not_bar");
+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;
+
+scoped_ptr<base::Thread> io_thread;
+scoped_ptr<base::Thread> db_thread;
+
+} // 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),
+ would_exceed_quota_(false), obsoleted_success_(false),
+ found_cache_id_(kNoCacheId), test_(test) {
+ }
+
+ virtual void OnCacheLoaded(AppCache* cache, int64 cache_id) OVERRIDE {
+ loaded_cache_ = cache;
+ loaded_cache_id_ = cache_id;
+ test_->ScheduleNextTask();
+ }
+
+ virtual void OnGroupLoaded(AppCacheGroup* group,
+ const GURL& manifest_url) OVERRIDE {
+ loaded_group_ = group;
+ loaded_manifest_url_ = manifest_url;
+ loaded_groups_newest_cache_ = group ? group->newest_complete_cache()
+ : NULL;
+ test_->ScheduleNextTask();
+ }
+
+ virtual void OnGroupAndNewestCacheStored(
+ AppCacheGroup* group, AppCache* newest_cache, bool success,
+ bool would_exceed_quota) OVERRIDE {
+ stored_group_ = group;
+ stored_group_success_ = success;
+ would_exceed_quota_ = would_exceed_quota;
+ test_->ScheduleNextTask();
+ }
+
+ virtual void OnGroupMadeObsolete(AppCacheGroup* group,
+ bool success) OVERRIDE {
+ obsoleted_group_ = group;
+ obsoleted_success_ = success;
+ test_->ScheduleNextTask();
+ }
+
+ virtual void OnMainResponseFound(const GURL& url,
+ const AppCacheEntry& entry,
+ const GURL& namespace_entry_url,
+ const AppCacheEntry& fallback_entry,
+ int64 cache_id,
+ int64 group_id,
+ const GURL& manifest_url) OVERRIDE {
+ found_url_ = url;
+ found_entry_ = entry;
+ found_namespace_entry_url_ = namespace_entry_url;
+ found_fallback_entry_ = fallback_entry;
+ found_cache_id_ = cache_id;
+ found_group_id_ = group_id;
+ found_manifest_url_ = manifest_url;
+ 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_;
+ GURL found_namespace_entry_url_;
+ AppCacheEntry found_fallback_entry_;
+ int64 found_cache_id_;
+ int64 found_group_id_;
+ GURL found_manifest_url_;
+ AppCacheStorageImplTest* test_;
+ };
+
+ class MockQuotaManager : public quota::QuotaManager {
+ public:
+ MockQuotaManager()
+ : QuotaManager(true /* is_incognito */, base::FilePath(),
+ io_thread->message_loop_proxy(),
+ db_thread->message_loop_proxy(),
+ NULL),
+ async_(false) {}
+
+ virtual void GetUsageAndQuota(
+ const GURL& origin,
+ quota::StorageType type,
+ const GetUsageAndQuotaCallback& callback) OVERRIDE {
+ EXPECT_EQ(kOrigin, origin);
+ EXPECT_EQ(quota::kStorageTypeTemporary, type);
+ if (async_) {
+ base::MessageLoop::current()->PostTask(
+ FROM_HERE,
+ base::Bind(&MockQuotaManager::CallCallback,
+ base::Unretained(this),
+ callback));
+ return;
+ }
+ CallCallback(callback);
+ }
+
+ void CallCallback(const GetUsageAndQuotaCallback& callback) {
+ callback.Run(quota::kQuotaStatusOk, 0, kMockQuota);
+ }
+
+ bool async_;
+
+ protected:
+ virtual ~MockQuotaManager() {}
+ };
+
+ 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_.get();
+ }
+
+ virtual void NotifyStorageAccessed(quota::QuotaClient::ID client_id,
+ const GURL& origin,
+ quota::StorageType type) OVERRIDE {
+ 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) OVERRIDE {
+ 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) OVERRIDE {}
+ virtual void NotifyOriginInUse(const GURL& origin) OVERRIDE {}
+ virtual void NotifyOriginNoLongerInUse(const GURL& origin) OVERRIDE {}
+
+ int notify_storage_accessed_count_;
+ int notify_storage_modified_count_;
+ GURL last_origin_;
+ int last_delta_;
+ scoped_refptr<MockQuotaManager> mock_manager_;
+
+ protected:
+ virtual ~MockQuotaManagerProxy() {}
+ };
+
+ template <class Method>
+ void RunMethod(Method method) {
+ (this->*method)();
+ }
+
+ // Helper callback to run a test on our io_thread. The io_thread is spun up
+ // once and reused for all tests.
+ template <class Method>
+ void MethodWrapper(Method method) {
+ SetUpTest();
+
+ // Ensure InitTask execution prior to conducting a test.
+ FlushDbThreadTasks();
+
+ // We also have to wait for InitTask completion call to be performed
+ // on the IO thread prior to running the test. Its guaranteed to be
+ // queued by this time.
+ base::MessageLoop::current()->PostTask(
+ FROM_HERE,
+ base::Bind(&AppCacheStorageImplTest::RunMethod<Method>,
+ base::Unretained(this),
+ method));
+ }
+
+ static void SetUpTestCase() {
+ io_thread.reset(new base::Thread("AppCacheTest.IOThread"));
+ base::Thread::Options options(base::MessageLoop::TYPE_IO, 0);
+ ASSERT_TRUE(io_thread->StartWithOptions(options));
+
+ db_thread.reset(new base::Thread("AppCacheTest::DBThread"));
+ ASSERT_TRUE(db_thread->Start());
+ }
+
+ static void TearDownTestCase() {
+ io_thread.reset(NULL);
+ db_thread.reset(NULL);
+ }
+
+ // Test harness --------------------------------------------------
+
+ AppCacheStorageImplTest() {
+ }
+
+ template <class Method>
+ void RunTestOnIOThread(Method method) {
+ test_finished_event_ .reset(new base::WaitableEvent(false, false));
+ io_thread->message_loop()->PostTask(
+ FROM_HERE, base::Bind(&AppCacheStorageImplTest::MethodWrapper<Method>,
+ base::Unretained(this), method));
+ test_finished_event_->Wait();
+ }
+
+ void SetUpTest() {
+ DCHECK(base::MessageLoop::current() == io_thread->message_loop());
+ service_.reset(new AppCacheService(NULL));
+ service_->Initialize(
+ base::FilePath(), db_thread->message_loop_proxy(), NULL);
+ mock_quota_manager_proxy_ = new MockQuotaManagerProxy();
+ service_->quota_manager_proxy_ = mock_quota_manager_proxy_;
+ delegate_.reset(new MockStorageDelegate(this));
+ }
+
+ void TearDownTest() {
+ DCHECK(base::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(base::MessageLoop::current() == io_thread->message_loop());
+ base::MessageLoop::current()->PostTask(
+ FROM_HERE,
+ base::Bind(&AppCacheStorageImplTest::TestFinishedUnwound,
+ base::Unretained(this)));
+ }
+
+ void TestFinishedUnwound() {
+ TearDownTest();
+ test_finished_event_->Signal();
+ }
+
+ void PushNextTask(const base::Closure& task) {
+ task_stack_.push(task);
+ }
+
+ void ScheduleNextTask() {
+ DCHECK(base::MessageLoop::current() == io_thread->message_loop());
+ if (task_stack_.empty()) {
+ return;
+ }
+ base::MessageLoop::current()->PostTask(FROM_HERE, task_stack_.top());
+ task_stack_.pop();
+ }
+
+ static void SignalEvent(base::WaitableEvent* event) {
+ event->Signal();
+ }
+
+ void FlushDbThreadTasks() {
+ // We pump a task thru the db thread to ensure any tasks previously
+ // scheduled on that thread have been performed prior to return.
+ base::WaitableEvent event(false, false);
+ db_thread->message_loop()->PostTask(
+ FROM_HERE, base::Bind(&AppCacheStorageImplTest::SignalEvent, &event));
+ event.Wait();
+ }
+
+ // LoadCache_Miss ----------------------------------------------------
+
+ void LoadCache_Miss() {
+ // Attempt to load a cache that doesn't exist. Should
+ // complete asynchronously.
+ PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_LoadCache_Miss,
+ base::Unretained(this)));
+
+ 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_.get());
+ 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(storage(), 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(base::Bind(&AppCacheStorageImplTest::Verify_CreateGroup,
+ base::Unretained(this)));
+
+ // Since the origin has groups, storage class will have to
+ // consult the database and completion will be async.
+ 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 asynchronously.
+ PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_LoadCache_Far_Hit,
+ base::Unretained(this)));
+
+ // Setup some preconditions. Create a group and newest cache that
+ // appear to be "stored" and "not currently in use".
+ MakeCacheAndGroup(kManifestUrl, 1, 1, true);
+ group_ = NULL;
+ cache_ = NULL;
+
+ // Conduct the cache load test, completes async
+ storage()->LoadCache(1, delegate());
+ }
+
+ void Verify_LoadCache_Far_Hit() {
+ EXPECT_TRUE(delegate()->loaded_cache_.get());
+ 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_.get());
+
+ // Conduct the group load test, also complete asynchronously.
+ PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_LoadGroup_Far_Hit,
+ base::Unretained(this)));
+
+ storage()->LoadOrCreateGroup(kManifestUrl, delegate());
+ }
+
+ void Verify_LoadGroup_Far_Hit() {
+ EXPECT_TRUE(delegate()->loaded_group_.get());
+ 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 asynchronously.
+ PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_StoreNewGroup,
+ base::Unretained(this)));
+
+ // Setup some preconditions. Create a group and newest cache that
+ // appear to be "unstored".
+ group_ = new AppCacheGroup(
+ storage(), kManifestUrl, storage()->NewGroupId());
+ cache_ = new AppCache(storage(), 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 asynchronously for this test.
+ mock_quota_manager_proxy_->mock_manager_->async_ = true;
+
+ // Conduct the store test.
+ storage()->StoreGroupAndNewestCache(group_.get(), cache_.get(), 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 asynchronously.
+ PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_StoreExistingGroup,
+ base::Unretained(this)));
+
+ // 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(storage(), 2);
+ cache2_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::MASTER, 1,
+ kDefaultEntrySize + 100));
+
+ // Conduct the test.
+ storage()->StoreGroupAndNewestCache(
+ group_.get(), cache2_.get(), 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(base::Bind(
+ &AppCacheStorageImplTest::Verify_StoreExistingGroupExistingCache,
+ base::Unretained(this), now));
+
+ // Conduct the test.
+ EXPECT_EQ(cache_, group_->newest_complete_cache());
+ storage()->StoreGroupAndNewestCache(group_.get(), cache_.get(), 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 + kDefaultEntrySize, cache_record.cache_size);
+
+ std::vector<AppCacheDatabase::EntryRecord> entry_records;
+ EXPECT_TRUE(database()->FindEntriesForCache(1, &entry_records));
+ 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 asynchronously.
+ PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_FailStoreGroup,
+ base::Unretained(this)));
+
+ // Setup some preconditions. Create a group and newest cache that
+ // appear to be "unstored" and big enough to exceed the 5M limit.
+ const int64 kTooBig = 10 * 1024 * 1024; // 10M
+ group_ = new AppCacheGroup(
+ storage(), kManifestUrl, storage()->NewGroupId());
+ cache_ = new AppCache(storage(), storage()->NewCacheId());
+ cache_->AddEntry(kManifestUrl,
+ AppCacheEntry(AppCacheEntry::MANIFEST, 1, kTooBig));
+ // 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_.get(), cache_.get(), 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));
+
+ 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 asynchronously.
+ PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_MakeGroupObsolete,
+ base::Unretained(this)));
+
+ // Setup some preconditions. Create a group and newest cache that
+ // appears to be "stored" and "currently in use".
+ MakeCacheAndGroup(kManifestUrl, 1, 1, true);
+ 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::NamespaceRecord fallback_namespace_record;
+ fallback_namespace_record.cache_id = 1;
+ fallback_namespace_record.namespace_.target_url = kEntryUrl;
+ fallback_namespace_record.namespace_.namespace_url = kFallbackNamespace;
+ fallback_namespace_record.origin = kManifestUrl.GetOrigin();
+ EXPECT_TRUE(database()->InsertNamespace(&fallback_namespace_record));
+
+ AppCacheDatabase::OnlineWhiteListRecord online_whitelist_record;
+ online_whitelist_record.cache_id = 1;
+ online_whitelist_record.namespace_url = kOnlineNamespace;
+ EXPECT_TRUE(database()->InsertOnlineWhiteList(&online_whitelist_record));
+
+ // Conduct the test.
+ storage()->MakeGroupObsolete(group_.get(), 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()->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::NamespaceRecord> intercept_records;
+ std::vector<AppCacheDatabase::NamespaceRecord> fallback_records;
+ database()->FindNamespacesForCache(
+ 1, &intercept_records, &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));
+ AppCacheDatabase::EntryRecord entry_record;
+ entry_record.cache_id = 1;
+ entry_record.url = kEntryUrl;
+ entry_record.flags = AppCacheEntry::EXPLICIT;
+ entry_record.response_id = 0;
+ EXPECT_TRUE(database()->InsertEntry(&entry_record));
+ EXPECT_FALSE(cache_->GetEntry(kEntryUrl)->IsForeign());
+
+ // Conduct the test.
+ storage()->MarkEntryAsForeign(kEntryUrl, 1);
+
+ // The entry in the working set should have been updated syncly.
+ EXPECT_TRUE(cache_->GetEntry(kEntryUrl)->IsForeign());
+ EXPECT_TRUE(cache_->GetEntry(kEntryUrl)->IsExplicit());
+
+ // And the entry in storage should also be updated, but that
+ // happens asynchronously on the db thread.
+ FlushDbThreadTasks();
+ AppCacheDatabase::EntryRecord entry_record2;
+ EXPECT_TRUE(database()->FindEntry(1, kEntryUrl, &entry_record2));
+ EXPECT_EQ(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN,
+ entry_record2.flags);
+ TestFinished();
+ }
+
+ // MarkEntryAsForeignWithLoadInProgress -------------------------------
+
+ void MarkEntryAsForeignWithLoadInProgress() {
+ PushNextTask(base::Bind(
+ &AppCacheStorageImplTest::Verify_MarkEntryAsForeignWithLoadInProgress,
+ base::Unretained(this)));
+
+ // Setup some preconditions. Create a cache with an entry
+ // in storage, but not in the working set.
+ MakeCacheAndGroup(kManifestUrl, 1, 1, true);
+ cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT));
+ AppCacheDatabase::EntryRecord entry_record;
+ entry_record.cache_id = 1;
+ entry_record.url = kEntryUrl;
+ entry_record.flags = AppCacheEntry::EXPLICIT;
+ entry_record.response_id = 0;
+ EXPECT_TRUE(database()->InsertEntry(&entry_record));
+ EXPECT_FALSE(cache_->GetEntry(kEntryUrl)->IsForeign());
+ EXPECT_TRUE(cache_->HasOneRef());
+ cache_ = NULL;
+ group_ = NULL;
+
+ // Conduct the test, start a cache load, and prior to completion
+ // of that load, mark the entry as foreign.
+ storage()->LoadCache(1, delegate());
+ storage()->MarkEntryAsForeign(kEntryUrl, 1);
+ }
+
+ void Verify_MarkEntryAsForeignWithLoadInProgress() {
+ EXPECT_EQ(1, delegate()->loaded_cache_id_);
+ EXPECT_TRUE(delegate()->loaded_cache_.get());
+
+ // The entry in the working set should have been updated upon load.
+ EXPECT_TRUE(delegate()->loaded_cache_->GetEntry(kEntryUrl)->IsForeign());
+ EXPECT_TRUE(delegate()->loaded_cache_->GetEntry(kEntryUrl)->IsExplicit());
+
+ // And the entry in storage should also be updated.
+ FlushDbThreadTasks();
+ AppCacheDatabase::EntryRecord entry_record;
+ EXPECT_TRUE(database()->FindEntry(1, kEntryUrl, &entry_record));
+ EXPECT_EQ(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN,
+ entry_record.flags);
+ TestFinished();
+ }
+
+ // FindNoMainResponse -------------------------------
+
+ void FindNoMainResponse() {
+ PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_FindNoMainResponse,
+ base::Unretained(this)));
+
+ // Conduct the test.
+ storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
+ EXPECT_NE(kEntryUrl, delegate()->found_url_);
+ }
+
+ void Verify_FindNoMainResponse() {
+ EXPECT_EQ(kEntryUrl, delegate()->found_url_);
+ EXPECT_TRUE(delegate()->found_manifest_url_.is_empty());
+ EXPECT_EQ(kNoCacheId, delegate()->found_cache_id_);
+ EXPECT_EQ(kNoResponseId, delegate()->found_entry_.response_id());
+ EXPECT_EQ(kNoResponseId, delegate()->found_fallback_entry_.response_id());
+ EXPECT_TRUE(delegate()->found_namespace_entry_url_.is_empty());
+ EXPECT_EQ(0, delegate()->found_entry_.types());
+ EXPECT_EQ(0, delegate()->found_fallback_entry_.types());
+ TestFinished();
+ }
+
+ // BasicFindMainResponse -------------------------------
+
+ void BasicFindMainResponseInDatabase() {
+ BasicFindMainResponse(true);
+ }
+
+ void BasicFindMainResponseInWorkingSet() {
+ BasicFindMainResponse(false);
+ }
+
+ void BasicFindMainResponse(bool drop_from_working_set) {
+ PushNextTask(base::Bind(
+ &AppCacheStorageImplTest::Verify_BasicFindMainResponse,
+ base::Unretained(this)));
+
+ // Setup some preconditions. Create a complete cache with an entry
+ // in storage.
+ MakeCacheAndGroup(kManifestUrl, 2, 1, true);
+ cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, 1));
+ AppCacheDatabase::EntryRecord entry_record;
+ entry_record.cache_id = 1;
+ entry_record.url = kEntryUrl;
+ entry_record.flags = AppCacheEntry::EXPLICIT;
+ entry_record.response_id = 1;
+ EXPECT_TRUE(database()->InsertEntry(&entry_record));
+
+ // Optionally drop the cache/group pair from the working set.
+ if (drop_from_working_set) {
+ EXPECT_TRUE(cache_->HasOneRef());
+ cache_ = NULL;
+ EXPECT_TRUE(group_->HasOneRef());
+ group_ = NULL;
+ }
+
+ // Conduct the test.
+ storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
+ EXPECT_NE(kEntryUrl, delegate()->found_url_);
+ }
+
+ void Verify_BasicFindMainResponse() {
+ EXPECT_EQ(kEntryUrl, delegate()->found_url_);
+ EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
+ EXPECT_EQ(1, delegate()->found_cache_id_);
+ EXPECT_EQ(2, delegate()->found_group_id_);
+ EXPECT_EQ(1, delegate()->found_entry_.response_id());
+ EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
+ EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
+ TestFinished();
+ }
+
+ // BasicFindMainFallbackResponse -------------------------------
+
+ void BasicFindMainFallbackResponseInDatabase() {
+ BasicFindMainFallbackResponse(true);
+ }
+
+ void BasicFindMainFallbackResponseInWorkingSet() {
+ BasicFindMainFallbackResponse(false);
+ }
+
+ void BasicFindMainFallbackResponse(bool drop_from_working_set) {
+ PushNextTask(base::Bind(
+ &AppCacheStorageImplTest::Verify_BasicFindMainFallbackResponse,
+ base::Unretained(this)));
+
+ // Setup some preconditions. Create a complete cache with a
+ // fallback namespace and entry.
+ MakeCacheAndGroup(kManifestUrl, 2, 1, true);
+ cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::FALLBACK, 1));
+ cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::FALLBACK, 2));
+ cache_->fallback_namespaces_.push_back(
+ Namespace(FALLBACK_NAMESPACE, kFallbackNamespace2, kEntryUrl2, false));
+ cache_->fallback_namespaces_.push_back(
+ Namespace(FALLBACK_NAMESPACE, kFallbackNamespace, kEntryUrl, false));
+ AppCacheDatabase::CacheRecord cache_record;
+ std::vector<AppCacheDatabase::EntryRecord> entries;
+ std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
+ std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
+ std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
+ cache_->ToDatabaseRecords(group_.get(),
+ &cache_record,
+ &entries,
+ &intercepts,
+ &fallbacks,
+ &whitelists);
+
+ 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()->InsertNamespaceRecords(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,
+ // but should match the longer of the two.
+ storage()->FindResponseForMainRequest(kFallbackTestUrl, GURL(), delegate());
+ EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
+ }
+
+ void Verify_BasicFindMainFallbackResponse() {
+ EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
+ EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
+ EXPECT_EQ(1, delegate()->found_cache_id_);
+ EXPECT_EQ(2, delegate()->found_group_id_);
+ EXPECT_FALSE(delegate()->found_entry_.has_response_id());
+ EXPECT_EQ(2, delegate()->found_fallback_entry_.response_id());
+ EXPECT_EQ(kEntryUrl2, delegate()->found_namespace_entry_url_);
+ EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
+ TestFinished();
+ }
+
+ // BasicFindMainInterceptResponse -------------------------------
+
+ void BasicFindMainInterceptResponseInDatabase() {
+ BasicFindMainInterceptResponse(true);
+ }
+
+ void BasicFindMainInterceptResponseInWorkingSet() {
+ BasicFindMainInterceptResponse(false);
+ }
+
+ void BasicFindMainInterceptResponse(bool drop_from_working_set) {
+ PushNextTask(base::Bind(
+ &AppCacheStorageImplTest::Verify_BasicFindMainInterceptResponse,
+ base::Unretained(this)));
+
+ // Setup some preconditions. Create a complete cache with an
+ // intercept namespace and entry.
+ MakeCacheAndGroup(kManifestUrl, 2, 1, true);
+ cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::INTERCEPT, 1));
+ cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::INTERCEPT, 2));
+ cache_->intercept_namespaces_.push_back(
+ Namespace(INTERCEPT_NAMESPACE, kInterceptNamespace2,
+ kEntryUrl2, false));
+ cache_->intercept_namespaces_.push_back(
+ Namespace(INTERCEPT_NAMESPACE, kInterceptNamespace,
+ kEntryUrl, false));
+ AppCacheDatabase::CacheRecord cache_record;
+ std::vector<AppCacheDatabase::EntryRecord> entries;
+ std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
+ std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
+ std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
+ cache_->ToDatabaseRecords(group_.get(),
+ &cache_record,
+ &entries,
+ &intercepts,
+ &fallbacks,
+ &whitelists);
+
+ 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()->InsertNamespaceRecords(intercepts));
+ 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 intercept namespaces,
+ // but should match the longer of the two.
+ storage()->FindResponseForMainRequest(
+ kInterceptTestUrl, GURL(), delegate());
+ EXPECT_NE(kInterceptTestUrl, delegate()->found_url_);
+ }
+
+ void Verify_BasicFindMainInterceptResponse() {
+ EXPECT_EQ(kInterceptTestUrl, delegate()->found_url_);
+ EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
+ EXPECT_EQ(1, delegate()->found_cache_id_);
+ EXPECT_EQ(2, delegate()->found_group_id_);
+ EXPECT_EQ(2, delegate()->found_entry_.response_id());
+ EXPECT_TRUE(delegate()->found_entry_.IsIntercept());
+ EXPECT_EQ(kEntryUrl2, delegate()->found_namespace_entry_url_);
+ EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
+ TestFinished();
+ }
+
+ // FindInterceptPatternMatch ----------------------------------------
+
+ void FindInterceptPatternMatchInDatabase() {
+ FindInterceptPatternMatch(true);
+ }
+
+ void FindInterceptPatternMatchInWorkingSet() {
+ FindInterceptPatternMatch(false);
+ }
+
+ void FindInterceptPatternMatch(bool drop_from_working_set) {
+ // Setup some preconditions. Create a complete cache with an
+ // pattern matching intercept namespace and entry.
+ MakeCacheAndGroup(kManifestUrl, 2, 1, true);
+ cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::INTERCEPT, 1));
+ cache_->intercept_namespaces_.push_back(
+ Namespace(INTERCEPT_NAMESPACE, kInterceptPatternNamespace,
+ kEntryUrl, true));
+ AppCacheDatabase::CacheRecord cache_record;
+ std::vector<AppCacheDatabase::EntryRecord> entries;
+ std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
+ std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
+ std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
+ cache_->ToDatabaseRecords(group_.get(),
+ &cache_record,
+ &entries,
+ &intercepts,
+ &fallbacks,
+ &whitelists);
+
+ 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()->InsertNamespaceRecords(intercepts));
+ if (drop_from_working_set) {
+ EXPECT_TRUE(cache_->HasOneRef());
+ cache_ = NULL;
+ EXPECT_TRUE(group_->HasOneRef());
+ group_ = NULL;
+ }
+
+ // First test something that does not match the pattern.
+ PushNextTask(base::Bind(
+ &AppCacheStorageImplTest::Verify_FindInterceptPatternMatchNegative,
+ base::Unretained(this)));
+ storage()->FindResponseForMainRequest(
+ kInterceptPatternTestNegativeUrl, GURL(), delegate());
+ EXPECT_EQ(GURL(), delegate()->found_url_); // Is always async.
+ }
+
+ void Verify_FindInterceptPatternMatchNegative() {
+ EXPECT_EQ(kInterceptPatternTestNegativeUrl, delegate()->found_url_);
+ EXPECT_TRUE(delegate()->found_manifest_url_.is_empty());
+ EXPECT_EQ(kNoCacheId, delegate()->found_cache_id_);
+ EXPECT_EQ(kNoResponseId, delegate()->found_entry_.response_id());
+ EXPECT_EQ(kNoResponseId, delegate()->found_fallback_entry_.response_id());
+ EXPECT_TRUE(delegate()->found_namespace_entry_url_.is_empty());
+ EXPECT_EQ(0, delegate()->found_entry_.types());
+ EXPECT_EQ(0, delegate()->found_fallback_entry_.types());
+
+ // Then test something that matches.
+ PushNextTask(base::Bind(
+ &AppCacheStorageImplTest::Verify_FindInterceptPatternMatchPositive,
+ base::Unretained(this)));
+ storage()->FindResponseForMainRequest(
+ kInterceptPatternTestPositiveUrl, GURL(), delegate());
+ }
+
+ void Verify_FindInterceptPatternMatchPositive() {
+ EXPECT_EQ(kInterceptPatternTestPositiveUrl, delegate()->found_url_);
+ EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
+ EXPECT_EQ(1, delegate()->found_cache_id_);
+ EXPECT_EQ(2, delegate()->found_group_id_);
+ EXPECT_EQ(1, delegate()->found_entry_.response_id());
+ EXPECT_TRUE(delegate()->found_entry_.IsIntercept());
+ EXPECT_EQ(kEntryUrl, delegate()->found_namespace_entry_url_);
+ EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
+ TestFinished();
+ }
+
+ // FindFallbackPatternMatch -------------------------------
+
+ void FindFallbackPatternMatchInDatabase() {
+ FindFallbackPatternMatch(true);
+ }
+
+ void FindFallbackPatternMatchInWorkingSet() {
+ FindFallbackPatternMatch(false);
+ }
+
+ void FindFallbackPatternMatch(bool drop_from_working_set) {
+ // Setup some preconditions. Create a complete cache with a
+ // pattern matching fallback namespace and entry.
+ MakeCacheAndGroup(kManifestUrl, 2, 1, true);
+ cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::FALLBACK, 1));
+ cache_->fallback_namespaces_.push_back(
+ Namespace(FALLBACK_NAMESPACE, kFallbackPatternNamespace,
+ kEntryUrl, true));
+ AppCacheDatabase::CacheRecord cache_record;
+ std::vector<AppCacheDatabase::EntryRecord> entries;
+ std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
+ std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
+ std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
+ cache_->ToDatabaseRecords(group_.get(),
+ &cache_record,
+ &entries,
+ &intercepts,
+ &fallbacks,
+ &whitelists);
+
+ 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()->InsertNamespaceRecords(fallbacks));
+ if (drop_from_working_set) {
+ EXPECT_TRUE(cache_->HasOneRef());
+ cache_ = NULL;
+ EXPECT_TRUE(group_->HasOneRef());
+ group_ = NULL;
+ }
+
+ // First test something that does not match the pattern.
+ PushNextTask(base::Bind(
+ &AppCacheStorageImplTest::Verify_FindFallbackPatternMatchNegative,
+ base::Unretained(this)));
+ storage()->FindResponseForMainRequest(
+ kFallbackPatternTestNegativeUrl, GURL(), delegate());
+ EXPECT_EQ(GURL(), delegate()->found_url_); // Is always async.
+ }
+
+ void Verify_FindFallbackPatternMatchNegative() {
+ EXPECT_EQ(kFallbackPatternTestNegativeUrl, delegate()->found_url_);
+ EXPECT_TRUE(delegate()->found_manifest_url_.is_empty());
+ EXPECT_EQ(kNoCacheId, delegate()->found_cache_id_);
+ EXPECT_EQ(kNoResponseId, delegate()->found_entry_.response_id());
+ EXPECT_EQ(kNoResponseId, delegate()->found_fallback_entry_.response_id());
+ EXPECT_TRUE(delegate()->found_namespace_entry_url_.is_empty());
+ EXPECT_EQ(0, delegate()->found_entry_.types());
+ EXPECT_EQ(0, delegate()->found_fallback_entry_.types());
+
+ // Then test something that matches.
+ PushNextTask(base::Bind(
+ &AppCacheStorageImplTest::Verify_FindFallbackPatternMatchPositive,
+ base::Unretained(this)));
+ storage()->FindResponseForMainRequest(
+ kFallbackPatternTestPositiveUrl, GURL(), delegate());
+ }
+
+ void Verify_FindFallbackPatternMatchPositive() {
+ EXPECT_EQ(kFallbackPatternTestPositiveUrl, delegate()->found_url_);
+ EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
+ EXPECT_EQ(1, delegate()->found_cache_id_);
+ EXPECT_EQ(2, delegate()->found_group_id_);
+ EXPECT_EQ(1, delegate()->found_fallback_entry_.response_id());
+ EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
+ EXPECT_EQ(kEntryUrl, delegate()->found_namespace_entry_url_);
+ EXPECT_FALSE(delegate()->found_entry_.has_response_id());
+ TestFinished();
+ }
+
+ // FindMainResponseWithMultipleHits -------------------------------
+
+ void FindMainResponseWithMultipleHits() {
+ PushNextTask(base::Bind(
+ &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits,
+ base::Unretained(this)));
+
+ // Setup some preconditions, create a few caches with an identical set
+ // of entries and fallback namespaces. Only the last one remains in
+ // the working set to simulate appearing as "in use".
+ MakeMultipleHitCacheAndGroup(kManifestUrl, 1);
+ MakeMultipleHitCacheAndGroup(kManifestUrl2, 2);
+ MakeMultipleHitCacheAndGroup(kManifestUrl3, 3);
+
+ // Conduct the test, we should find the response from the last cache
+ // since it's "in use".
+ storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
+ EXPECT_NE(kEntryUrl, delegate()->found_url_);
+ }
+
+ void MakeMultipleHitCacheAndGroup(const GURL& manifest_url, int id) {
+ MakeCacheAndGroup(manifest_url, id, id, true);
+ AppCacheDatabase::EntryRecord entry_record;
+
+ // Add an entry for kEntryUrl
+ entry_record.cache_id = id;
+ entry_record.url = kEntryUrl;
+ entry_record.flags = AppCacheEntry::EXPLICIT;
+ entry_record.response_id = id;
+ EXPECT_TRUE(database()->InsertEntry(&entry_record));
+ cache_->AddEntry(
+ entry_record.url,
+ AppCacheEntry(entry_record.flags, entry_record.response_id));
+
+ // Add an entry for the manifestUrl
+ entry_record.cache_id = id;
+ entry_record.url = manifest_url;
+ entry_record.flags = AppCacheEntry::MANIFEST;
+ entry_record.response_id = id + kManifestEntryIdOffset;
+ EXPECT_TRUE(database()->InsertEntry(&entry_record));
+ cache_->AddEntry(
+ entry_record.url,
+ AppCacheEntry(entry_record.flags, entry_record.response_id));
+
+ // Add a fallback entry and namespace
+ entry_record.cache_id = id;
+ entry_record.url = kEntryUrl2;
+ entry_record.flags = AppCacheEntry::FALLBACK;
+ entry_record.response_id = id + kFallbackEntryIdOffset;
+ EXPECT_TRUE(database()->InsertEntry(&entry_record));
+ cache_->AddEntry(
+ entry_record.url,
+ AppCacheEntry(entry_record.flags, entry_record.response_id));
+ AppCacheDatabase::NamespaceRecord fallback_namespace_record;
+ fallback_namespace_record.cache_id = id;
+ fallback_namespace_record.namespace_.target_url = entry_record.url;
+ fallback_namespace_record.namespace_.namespace_url = kFallbackNamespace;
+ fallback_namespace_record.origin = manifest_url.GetOrigin();
+ EXPECT_TRUE(database()->InsertNamespace(&fallback_namespace_record));
+ cache_->fallback_namespaces_.push_back(
+ Namespace(FALLBACK_NAMESPACE, kFallbackNamespace, kEntryUrl2, false));
+ }
+
+ void Verify_FindMainResponseWithMultipleHits() {
+ EXPECT_EQ(kEntryUrl, delegate()->found_url_);
+ EXPECT_EQ(kManifestUrl3, delegate()->found_manifest_url_);
+ EXPECT_EQ(3, delegate()->found_cache_id_);
+ EXPECT_EQ(3, delegate()->found_group_id_);
+ EXPECT_EQ(3, delegate()->found_entry_.response_id());
+ EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
+ EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
+
+ // Conduct another test perferring kManifestUrl
+ delegate_.reset(new MockStorageDelegate(this));
+ PushNextTask(base::Bind(
+ &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits2,
+ base::Unretained(this)));
+ storage()->FindResponseForMainRequest(kEntryUrl, kManifestUrl, delegate());
+ EXPECT_NE(kEntryUrl, delegate()->found_url_);
+ }
+
+ void Verify_FindMainResponseWithMultipleHits2() {
+ EXPECT_EQ(kEntryUrl, delegate()->found_url_);
+ EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
+ EXPECT_EQ(1, delegate()->found_cache_id_);
+ EXPECT_EQ(1, delegate()->found_group_id_);
+ EXPECT_EQ(1, delegate()->found_entry_.response_id());
+ EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
+ EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
+
+ // Conduct the another test perferring kManifestUrl2
+ delegate_.reset(new MockStorageDelegate(this));
+ PushNextTask(base::Bind(
+ &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits3,
+ base::Unretained(this)));
+ storage()->FindResponseForMainRequest(kEntryUrl, kManifestUrl2, delegate());
+ EXPECT_NE(kEntryUrl, delegate()->found_url_);
+ }
+
+ void Verify_FindMainResponseWithMultipleHits3() {
+ EXPECT_EQ(kEntryUrl, delegate()->found_url_);
+ EXPECT_EQ(kManifestUrl2, delegate()->found_manifest_url_);
+ EXPECT_EQ(2, delegate()->found_cache_id_);
+ EXPECT_EQ(2, delegate()->found_group_id_);
+ EXPECT_EQ(2, delegate()->found_entry_.response_id());
+ EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
+ EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
+
+ // Conduct another test with no preferred manifest that hits the fallback.
+ delegate_.reset(new MockStorageDelegate(this));
+ PushNextTask(base::Bind(
+ &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits4,
+ base::Unretained(this)));
+ storage()->FindResponseForMainRequest(
+ kFallbackTestUrl, GURL(), delegate());
+ EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
+ }
+
+ void Verify_FindMainResponseWithMultipleHits4() {
+ EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
+ EXPECT_EQ(kManifestUrl3, delegate()->found_manifest_url_);
+ EXPECT_EQ(3, delegate()->found_cache_id_);
+ EXPECT_EQ(3, delegate()->found_group_id_);
+ EXPECT_FALSE(delegate()->found_entry_.has_response_id());
+ EXPECT_EQ(3 + kFallbackEntryIdOffset,
+ delegate()->found_fallback_entry_.response_id());
+ EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
+ EXPECT_EQ(kEntryUrl2, delegate()->found_namespace_entry_url_);
+
+ // Conduct another test preferring kManifestUrl2 that hits the fallback.
+ delegate_.reset(new MockStorageDelegate(this));
+ PushNextTask(base::Bind(
+ &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits5,
+ base::Unretained(this)));
+ storage()->FindResponseForMainRequest(
+ kFallbackTestUrl, kManifestUrl2, delegate());
+ EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
+ }
+
+ void Verify_FindMainResponseWithMultipleHits5() {
+ EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
+ EXPECT_EQ(kManifestUrl2, delegate()->found_manifest_url_);
+ EXPECT_EQ(2, delegate()->found_cache_id_);
+ EXPECT_EQ(2, delegate()->found_group_id_);
+ EXPECT_FALSE(delegate()->found_entry_.has_response_id());
+ EXPECT_EQ(2 + kFallbackEntryIdOffset,
+ delegate()->found_fallback_entry_.response_id());
+ EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
+ EXPECT_EQ(kEntryUrl2, delegate()->found_namespace_entry_url_);
+
+ TestFinished();
+ }
+
+ // FindMainResponseExclusions -------------------------------
+
+ void FindMainResponseExclusionsInDatabase() {
+ FindMainResponseExclusions(true);
+ }
+
+ void FindMainResponseExclusionsInWorkingSet() {
+ FindMainResponseExclusions(false);
+ }
+
+ void FindMainResponseExclusions(bool drop_from_working_set) {
+ // Setup some preconditions. Create a complete cache with a
+ // foreign entry, an online namespace, and a second online
+ // namespace nested within a fallback namespace.
+ MakeCacheAndGroup(kManifestUrl, 1, 1, true);
+ cache_->AddEntry(kEntryUrl,
+ AppCacheEntry(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN, 1));
+ cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::FALLBACK, 2));
+ cache_->fallback_namespaces_.push_back(
+ Namespace(FALLBACK_NAMESPACE, kFallbackNamespace, kEntryUrl2, false));
+ cache_->online_whitelist_namespaces_.push_back(
+ Namespace(NETWORK_NAMESPACE, kOnlineNamespace,
+ GURL(), false));
+ cache_->online_whitelist_namespaces_.push_back(
+ Namespace(NETWORK_NAMESPACE, kOnlineNamespaceWithinFallback,
+ GURL(), false));
+
+ AppCacheDatabase::EntryRecord entry_record;
+ entry_record.cache_id = 1;
+ entry_record.url = kEntryUrl;
+ entry_record.flags = AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN;
+ entry_record.response_id = 1;
+ EXPECT_TRUE(database()->InsertEntry(&entry_record));
+ AppCacheDatabase::OnlineWhiteListRecord whitelist_record;
+ whitelist_record.cache_id = 1;
+ whitelist_record.namespace_url = kOnlineNamespace;
+ EXPECT_TRUE(database()->InsertOnlineWhiteList(&whitelist_record));
+ AppCacheDatabase::NamespaceRecord fallback_namespace_record;
+ fallback_namespace_record.cache_id = 1;
+ fallback_namespace_record.namespace_.target_url = kEntryUrl2;
+ fallback_namespace_record.namespace_.namespace_url = kFallbackNamespace;
+ fallback_namespace_record.origin = kManifestUrl.GetOrigin();
+ EXPECT_TRUE(database()->InsertNamespace(&fallback_namespace_record));
+ whitelist_record.cache_id = 1;
+ whitelist_record.namespace_url = kOnlineNamespaceWithinFallback;
+ EXPECT_TRUE(database()->InsertOnlineWhiteList(&whitelist_record));
+ if (drop_from_working_set) {
+ cache_ = NULL;
+ group_ = NULL;
+ }
+
+ // We should not find anything for the foreign entry.
+ PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_ExclusionNotFound,
+ base::Unretained(this), kEntryUrl, 1));
+ storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
+ }
+
+ void Verify_ExclusionNotFound(GURL expected_url, int phase) {
+ EXPECT_EQ(expected_url, delegate()->found_url_);
+ EXPECT_TRUE(delegate()->found_manifest_url_.is_empty());
+ EXPECT_EQ(kNoCacheId, delegate()->found_cache_id_);
+ EXPECT_EQ(0, delegate()->found_group_id_);
+ EXPECT_EQ(kNoResponseId, delegate()->found_entry_.response_id());
+ EXPECT_EQ(kNoResponseId, delegate()->found_fallback_entry_.response_id());
+ EXPECT_TRUE(delegate()->found_namespace_entry_url_.is_empty());
+ EXPECT_EQ(0, delegate()->found_entry_.types());
+ EXPECT_EQ(0, delegate()->found_fallback_entry_.types());
+
+ if (phase == 1) {
+ // We should not find anything for the online namespace.
+ PushNextTask(
+ base::Bind(&AppCacheStorageImplTest::Verify_ExclusionNotFound,
+ base::Unretained(this), kOnlineNamespace, 2));
+ storage()->FindResponseForMainRequest(
+ kOnlineNamespace, GURL(), delegate());
+ return;
+ }
+ if (phase == 2) {
+ // We should not find anything for the online namespace nested within
+ // the fallback namespace.
+ PushNextTask(base::Bind(
+ &AppCacheStorageImplTest::Verify_ExclusionNotFound,
+ base::Unretained(this), kOnlineNamespaceWithinFallback, 3));
+ storage()->FindResponseForMainRequest(
+ kOnlineNamespaceWithinFallback, GURL(), delegate());
+ return;
+ }
+
+ TestFinished();
+ }
+
+ // Test case helpers --------------------------------------------------
+
+ AppCacheService* service() {
+ return service_.get();
+ }
+
+ AppCacheStorageImpl* storage() {
+ return static_cast<AppCacheStorageImpl*>(service()->storage());
+ }
+
+ AppCacheDatabase* database() {
+ 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(storage(), manifest_url, group_id);
+ cache_ = new AppCache(storage(), cache_id);
+ cache_->AddEntry(kDefaultEntryUrl, default_entry);
+ cache_->set_complete(true);
+ group_->AddCache(cache_.get());
+ 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));
+ 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<base::Closure> task_stack_;
+ 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);
+}
+
+TEST_F(AppCacheStorageImplTest, LoadCache_NearHit) {
+ RunTestOnIOThread(&AppCacheStorageImplTest::LoadCache_NearHit);
+}
+
+TEST_F(AppCacheStorageImplTest, CreateGroupInEmptyOrigin) {
+ RunTestOnIOThread(&AppCacheStorageImplTest::CreateGroupInEmptyOrigin);
+}
+
+TEST_F(AppCacheStorageImplTest, CreateGroupInPopulatedOrigin) {
+ RunTestOnIOThread(&AppCacheStorageImplTest::CreateGroupInPopulatedOrigin);
+}
+
+TEST_F(AppCacheStorageImplTest, LoadGroupAndCache_FarHit) {
+ RunTestOnIOThread(&AppCacheStorageImplTest::LoadGroupAndCache_FarHit);
+}
+
+TEST_F(AppCacheStorageImplTest, StoreNewGroup) {
+ RunTestOnIOThread(&AppCacheStorageImplTest::StoreNewGroup);
+}
+
+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(
+ &AppCacheStorageImplTest::MarkEntryAsForeignWithLoadInProgress);
+}
+
+TEST_F(AppCacheStorageImplTest, FindNoMainResponse) {
+ RunTestOnIOThread(&AppCacheStorageImplTest::FindNoMainResponse);
+}
+
+TEST_F(AppCacheStorageImplTest, BasicFindMainResponseInDatabase) {
+ RunTestOnIOThread(
+ &AppCacheStorageImplTest::BasicFindMainResponseInDatabase);
+}
+
+TEST_F(AppCacheStorageImplTest, BasicFindMainResponseInWorkingSet) {
+ RunTestOnIOThread(
+ &AppCacheStorageImplTest::BasicFindMainResponseInWorkingSet);
+}
+
+TEST_F(AppCacheStorageImplTest, BasicFindMainFallbackResponseInDatabase) {
+ RunTestOnIOThread(
+ &AppCacheStorageImplTest::BasicFindMainFallbackResponseInDatabase);
+}
+
+TEST_F(AppCacheStorageImplTest, BasicFindMainFallbackResponseInWorkingSet) {
+ RunTestOnIOThread(
+ &AppCacheStorageImplTest::BasicFindMainFallbackResponseInWorkingSet);
+}
+
+TEST_F(AppCacheStorageImplTest, BasicFindMainInterceptResponseInDatabase) {
+ RunTestOnIOThread(
+ &AppCacheStorageImplTest::BasicFindMainInterceptResponseInDatabase);
+}
+
+TEST_F(AppCacheStorageImplTest, BasicFindMainInterceptResponseInWorkingSet) {
+ RunTestOnIOThread(
+ &AppCacheStorageImplTest::BasicFindMainInterceptResponseInWorkingSet);
+}
+
+TEST_F(AppCacheStorageImplTest, FindMainResponseWithMultipleHits) {
+ RunTestOnIOThread(
+ &AppCacheStorageImplTest::FindMainResponseWithMultipleHits);
+}
+
+TEST_F(AppCacheStorageImplTest, FindMainResponseExclusionsInDatabase) {
+ RunTestOnIOThread(
+ &AppCacheStorageImplTest::FindMainResponseExclusionsInDatabase);
+}
+
+TEST_F(AppCacheStorageImplTest, FindMainResponseExclusionsInWorkingSet) {
+ RunTestOnIOThread(
+ &AppCacheStorageImplTest::FindMainResponseExclusionsInWorkingSet);
+}
+
+TEST_F(AppCacheStorageImplTest, FindInterceptPatternMatchInWorkingSet) {
+ RunTestOnIOThread(
+ &AppCacheStorageImplTest::FindInterceptPatternMatchInWorkingSet);
+}
+
+TEST_F(AppCacheStorageImplTest, FindInterceptPatternMatchInDatabase) {
+ RunTestOnIOThread(
+ &AppCacheStorageImplTest::FindInterceptPatternMatchInDatabase);
+}
+
+TEST_F(AppCacheStorageImplTest, FindFallbackPatternMatchInWorkingSet) {
+ RunTestOnIOThread(
+ &AppCacheStorageImplTest::FindFallbackPatternMatchInWorkingSet);
+}
+
+TEST_F(AppCacheStorageImplTest, FindFallbackPatternMatchInDatabase) {
+ RunTestOnIOThread(
+ &AppCacheStorageImplTest::FindFallbackPatternMatchInDatabase);
+}
+
+// That's all folks!
+
+} // namespace appcache
generated by cgit v1.1 at 2024-10-31 11:18:31 +0000