webkit/browser/appcache/appcache_storage_impl_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <stack>
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/callback.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/synchronization/waitable_event.h"
  12 #include "base/threading/thread.h"
  13 #include "net/base/net_errors.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "webkit/browser/appcache/appcache.h"
  16 #include "webkit/browser/appcache/appcache_database.h"
  17 #include "webkit/browser/appcache/appcache_entry.h"
  18 #include "webkit/browser/appcache/appcache_group.h"
  19 #include "webkit/browser/appcache/appcache_service.h"
  20 #include "webkit/browser/appcache/appcache_storage_impl.h"
  21 #include "webkit/browser/quota/quota_manager.h"
  22
  23 namespace appcache {
  24
  25 namespace {
  26
  27 const base::Time kZeroTime;
  28 const GURL kManifestUrl("http://blah/manifest");
  29 const GURL kManifestUrl2("http://blah/manifest2");
  30 const GURL kManifestUrl3("http://blah/manifest3");
  31 const GURL kEntryUrl("http://blah/entry");
  32 const GURL kEntryUrl2("http://blah/entry2");
  33 const GURL kFallbackNamespace("http://blah/fallback_namespace/");
  34 const GURL kFallbackNamespace2("http://blah/fallback_namespace/longer");
  35 const GURL kFallbackTestUrl("http://blah/fallback_namespace/longer/test");
  36 const GURL kOnlineNamespace("http://blah/online_namespace");
  37 const GURL kOnlineNamespaceWithinFallback(
  38     "http://blah/fallback_namespace/online/");
  39 const GURL kInterceptNamespace("http://blah/intercept_namespace/");
  40 const GURL kInterceptNamespace2("http://blah/intercept_namespace/longer/");
  41 const GURL kInterceptTestUrl("http://blah/intercept_namespace/longer/test");
  42 const GURL kInterceptPatternNamespace("http://blah/intercept_pattern/*/bar");
  43 const GURL kInterceptPatternTestPositiveUrl(
  44     "http://blah/intercept_pattern/foo/bar");
  45 const GURL kInterceptPatternTestNegativeUrl(
  46     "http://blah/intercept_pattern/foo/not_bar");
  47 const GURL kFallbackPatternNamespace("http://blah/fallback_pattern/*/bar");
  48 const GURL kFallbackPatternTestPositiveUrl(
  49     "http://blah/fallback_pattern/foo/bar");
  50 const GURL kFallbackPatternTestNegativeUrl(
  51     "http://blah/fallback_pattern/foo/not_bar");
  52 const GURL kOrigin(kManifestUrl.GetOrigin());
  53
  54 const int kManifestEntryIdOffset = 100;
  55 const int kFallbackEntryIdOffset = 1000;
  56
  57 const GURL kDefaultEntryUrl("http://blah/makecacheandgroup_default_entry");
  58 const int kDefaultEntrySize = 10;
  59 const int kDefaultEntryIdOffset = 12345;
  60
  61 const int kMockQuota = 5000;
  62
  63 scoped_ptr<base::Thread> io_thread;
  64 scoped_ptr<base::Thread> db_thread;
  65
  66 }  // namespace
  67
  68 class AppCacheStorageImplTest : public testing::Test {
  69  public:
  70   class MockStorageDelegate : public AppCacheStorage::Delegate {
  71    public:
  72     explicit MockStorageDelegate(AppCacheStorageImplTest* test)
  73         : loaded_cache_id_(0), stored_group_success_(false),
  74           would_exceed_quota_(false), obsoleted_success_(false),
  75           found_cache_id_(kNoCacheId), test_(test) {
  76     }
  77
  78     virtual void OnCacheLoaded(AppCache* cache, int64 cache_id) OVERRIDE {
  79       loaded_cache_ = cache;
  80       loaded_cache_id_ = cache_id;
  81       test_->ScheduleNextTask();
  82     }
  83
  84     virtual void OnGroupLoaded(AppCacheGroup* group,
  85                                const GURL& manifest_url) OVERRIDE {
  86       loaded_group_ = group;
  87       loaded_manifest_url_ = manifest_url;
  88       loaded_groups_newest_cache_ = group ? group->newest_complete_cache()
  89                                           : NULL;
  90       test_->ScheduleNextTask();
  91     }
  92
  93     virtual void OnGroupAndNewestCacheStored(
  94         AppCacheGroup* group, AppCache* newest_cache, bool success,
  95         bool would_exceed_quota) OVERRIDE {
  96       stored_group_ = group;
  97       stored_group_success_ = success;
  98       would_exceed_quota_ = would_exceed_quota;
  99       test_->ScheduleNextTask();
 100     }
 101
 102     virtual void OnGroupMadeObsolete(AppCacheGroup* group,
 103                                      bool success) OVERRIDE {
 104       obsoleted_group_ = group;
 105       obsoleted_success_ = success;
 106       test_->ScheduleNextTask();
 107     }
 108
 109     virtual void OnMainResponseFound(const GURL& url,
 110                                      const AppCacheEntry& entry,
 111                                      const GURL& namespace_entry_url,
 112                                      const AppCacheEntry& fallback_entry,
 113                                      int64 cache_id,
 114                                      int64 group_id,
 115                                      const GURL& manifest_url) OVERRIDE {
 116       found_url_ = url;
 117       found_entry_ = entry;
 118       found_namespace_entry_url_ = namespace_entry_url;
 119       found_fallback_entry_ = fallback_entry;
 120       found_cache_id_ = cache_id;
 121       found_group_id_ = group_id;
 122       found_manifest_url_ = manifest_url;
 123       test_->ScheduleNextTask();
 124     }
 125
 126     scoped_refptr<AppCache> loaded_cache_;
 127     int64 loaded_cache_id_;
 128     scoped_refptr<AppCacheGroup> loaded_group_;
 129     GURL loaded_manifest_url_;
 130     scoped_refptr<AppCache> loaded_groups_newest_cache_;
 131     scoped_refptr<AppCacheGroup> stored_group_;
 132     bool stored_group_success_;
 133     bool would_exceed_quota_;
 134     scoped_refptr<AppCacheGroup> obsoleted_group_;
 135     bool obsoleted_success_;
 136     GURL found_url_;
 137     AppCacheEntry found_entry_;
 138     GURL found_namespace_entry_url_;
 139     AppCacheEntry found_fallback_entry_;
 140     int64 found_cache_id_;
 141     int64 found_group_id_;
 142     GURL found_manifest_url_;
 143     AppCacheStorageImplTest* test_;
 144   };
 145
 146   class MockQuotaManager : public quota::QuotaManager {
 147    public:
 148     MockQuotaManager()
 149         : QuotaManager(true /* is_incognito */,
 150                        base::FilePath(),
 151                        io_thread->message_loop_proxy().get(),
 152                        db_thread->message_loop_proxy().get(),
 153                        NULL),
 154           async_(false) {}
 155
 156     virtual void GetUsageAndQuota(
 157         const GURL& origin,
 158         quota::StorageType type,
 159         const GetUsageAndQuotaCallback& callback) OVERRIDE {
 160       EXPECT_EQ(kOrigin, origin);
 161       EXPECT_EQ(quota::kStorageTypeTemporary, type);
 162       if (async_) {
 163         base::MessageLoop::current()->PostTask(
 164             FROM_HERE,
 165             base::Bind(&MockQuotaManager::CallCallback,
 166                        base::Unretained(this),
 167                        callback));
 168         return;
 169       }
 170       CallCallback(callback);
 171     }
 172
 173     void CallCallback(const GetUsageAndQuotaCallback& callback) {
 174       callback.Run(quota::kQuotaStatusOk, 0, kMockQuota);
 175     }
 176
 177     bool async_;
 178
 179    protected:
 180     virtual ~MockQuotaManager() {}
 181   };
 182
 183   class MockQuotaManagerProxy : public quota::QuotaManagerProxy {
 184    public:
 185     MockQuotaManagerProxy()
 186         : QuotaManagerProxy(NULL, NULL),
 187           notify_storage_accessed_count_(0),
 188           notify_storage_modified_count_(0),
 189           last_delta_(0),
 190           mock_manager_(new MockQuotaManager) {
 191       manager_ = mock_manager_.get();
 192     }
 193
 194     virtual void NotifyStorageAccessed(quota::QuotaClient::ID client_id,
 195                                        const GURL& origin,
 196                                        quota::StorageType type) OVERRIDE {
 197       EXPECT_EQ(quota::QuotaClient::kAppcache, client_id);
 198       EXPECT_EQ(quota::kStorageTypeTemporary, type);
 199       ++notify_storage_accessed_count_;
 200       last_origin_ = origin;
 201     }
 202
 203     virtual void NotifyStorageModified(quota::QuotaClient::ID client_id,
 204                                        const GURL& origin,
 205                                        quota::StorageType type,
 206                                        int64 delta) OVERRIDE {
 207       EXPECT_EQ(quota::QuotaClient::kAppcache, client_id);
 208       EXPECT_EQ(quota::kStorageTypeTemporary, type);
 209       ++notify_storage_modified_count_;
 210       last_origin_ = origin;
 211       last_delta_ = delta;
 212     }
 213
 214     // Not needed for our tests.
 215     virtual void RegisterClient(quota::QuotaClient* client) OVERRIDE {}
 216     virtual void NotifyOriginInUse(const GURL& origin) OVERRIDE {}
 217     virtual void NotifyOriginNoLongerInUse(const GURL& origin) OVERRIDE {}
 218
 219     int notify_storage_accessed_count_;
 220     int notify_storage_modified_count_;
 221     GURL last_origin_;
 222     int last_delta_;
 223     scoped_refptr<MockQuotaManager> mock_manager_;
 224
 225    protected:
 226     virtual ~MockQuotaManagerProxy() {}
 227   };
 228
 229   template <class Method>
 230   void RunMethod(Method method) {
 231     (this->*method)();
 232   }
 233
 234   // Helper callback to run a test on our io_thread. The io_thread is spun up
 235   // once and reused for all tests.
 236   template <class Method>
 237   void MethodWrapper(Method method) {
 238     SetUpTest();
 239
 240     // Ensure InitTask execution prior to conducting a test.
 241     FlushDbThreadTasks();
 242
 243     // We also have to wait for InitTask completion call to be performed
 244     // on the IO thread prior to running the test. Its guaranteed to be
 245     // queued by this time.
 246     base::MessageLoop::current()->PostTask(
 247         FROM_HERE,
 248         base::Bind(&AppCacheStorageImplTest::RunMethod<Method>,
 249                    base::Unretained(this),
 250                    method));
 251   }
 252
 253   static void SetUpTestCase() {
 254     io_thread.reset(new base::Thread("AppCacheTest.IOThread"));
 255     base::Thread::Options options(base::MessageLoop::TYPE_IO, 0);
 256     ASSERT_TRUE(io_thread->StartWithOptions(options));
 257
 258     db_thread.reset(new base::Thread("AppCacheTest::DBThread"));
 259     ASSERT_TRUE(db_thread->Start());
 260   }
 261
 262   static void TearDownTestCase() {
 263     io_thread.reset(NULL);
 264     db_thread.reset(NULL);
 265   }
 266
 267   // Test harness --------------------------------------------------
 268
 269   AppCacheStorageImplTest() {
 270   }
 271
 272   template <class Method>
 273   void RunTestOnIOThread(Method method) {
 274     test_finished_event_ .reset(new base::WaitableEvent(false, false));
 275     io_thread->message_loop()->PostTask(
 276         FROM_HERE, base::Bind(&AppCacheStorageImplTest::MethodWrapper<Method>,
 277                               base::Unretained(this), method));
 278     test_finished_event_->Wait();
 279   }
 280
 281   void SetUpTest() {
 282     DCHECK(base::MessageLoop::current() == io_thread->message_loop());
 283     service_.reset(new AppCacheService(NULL));
 284     service_->Initialize(
 285         base::FilePath(), db_thread->message_loop_proxy().get(), NULL);
 286     mock_quota_manager_proxy_ = new MockQuotaManagerProxy();
 287     service_->quota_manager_proxy_ = mock_quota_manager_proxy_;
 288     delegate_.reset(new MockStorageDelegate(this));
 289   }
 290
 291   void TearDownTest() {
 292     DCHECK(base::MessageLoop::current() == io_thread->message_loop());
 293     storage()->CancelDelegateCallbacks(delegate());
 294     group_ = NULL;
 295     cache_ = NULL;
 296     cache2_ = NULL;
 297     mock_quota_manager_proxy_ = NULL;
 298     delegate_.reset();
 299     service_.reset();
 300     FlushDbThreadTasks();
 301   }
 302
 303   void TestFinished() {
 304     // We unwind the stack prior to finishing up to let stack
 305     // based objects get deleted.
 306     DCHECK(base::MessageLoop::current() == io_thread->message_loop());
 307     base::MessageLoop::current()->PostTask(
 308         FROM_HERE,
 309         base::Bind(&AppCacheStorageImplTest::TestFinishedUnwound,
 310                    base::Unretained(this)));
 311   }
 312
 313   void TestFinishedUnwound() {
 314     TearDownTest();
 315     test_finished_event_->Signal();
 316   }
 317
 318   void PushNextTask(const base::Closure& task) {
 319     task_stack_.push(task);
 320   }
 321
 322   void ScheduleNextTask() {
 323     DCHECK(base::MessageLoop::current() == io_thread->message_loop());
 324     if (task_stack_.empty()) {
 325       return;
 326     }
 327     base::MessageLoop::current()->PostTask(FROM_HERE, task_stack_.top());
 328     task_stack_.pop();
 329   }
 330
 331   static void SignalEvent(base::WaitableEvent* event) {
 332     event->Signal();
 333   }
 334
 335   void FlushDbThreadTasks() {
 336     // We pump a task thru the db thread to ensure any tasks previously
 337     // scheduled on that thread have been performed prior to return.
 338     base::WaitableEvent event(false, false);
 339     db_thread->message_loop()->PostTask(
 340         FROM_HERE, base::Bind(&AppCacheStorageImplTest::SignalEvent, &event));
 341     event.Wait();
 342   }
 343
 344   // LoadCache_Miss ----------------------------------------------------
 345
 346   void LoadCache_Miss() {
 347     // Attempt to load a cache that doesn't exist. Should
 348     // complete asynchronously.
 349     PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_LoadCache_Miss,
 350                             base::Unretained(this)));
 351
 352     storage()->LoadCache(111, delegate());
 353     EXPECT_NE(111, delegate()->loaded_cache_id_);
 354   }
 355
 356   void Verify_LoadCache_Miss() {
 357     EXPECT_EQ(111, delegate()->loaded_cache_id_);
 358     EXPECT_FALSE(delegate()->loaded_cache_.get());
 359     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_accessed_count_);
 360     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
 361     TestFinished();
 362   }
 363
 364   // LoadCache_NearHit -------------------------------------------------
 365
 366   void LoadCache_NearHit() {
 367     // Attempt to load a cache that is currently in use
 368     // and does not require loading from storage. This
 369     // load should complete syncly.
 370
 371     // Setup some preconditions. Make an 'unstored' cache for
 372     // us to load. The ctor should put it in the working set.
 373     int64 cache_id = storage()->NewCacheId();
 374     scoped_refptr<AppCache> cache(new AppCache(storage(), cache_id));
 375
 376     // Conduct the test.
 377     storage()->LoadCache(cache_id, delegate());
 378     EXPECT_EQ(cache_id, delegate()->loaded_cache_id_);
 379     EXPECT_EQ(cache.get(), delegate()->loaded_cache_.get());
 380     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_accessed_count_);
 381     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
 382     TestFinished();
 383   }
 384
 385   // CreateGroup  --------------------------------------------
 386
 387   void CreateGroupInEmptyOrigin() {
 388     // Attempt to load a group that doesn't exist, one should
 389     // be created for us, but not stored.
 390
 391     // Since the origin has no groups, the storage class will respond
 392     // syncly.
 393     storage()->LoadOrCreateGroup(kManifestUrl, delegate());
 394     Verify_CreateGroup();
 395   }
 396
 397   void CreateGroupInPopulatedOrigin() {
 398     // Attempt to load a group that doesn't exist, one should
 399     // be created for us, but not stored.
 400     PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_CreateGroup,
 401                             base::Unretained(this)));
 402
 403     // Since the origin has groups, storage class will have to
 404     // consult the database and completion will be async.
 405     storage()->usage_map_[kOrigin] = kDefaultEntrySize;
 406
 407     storage()->LoadOrCreateGroup(kManifestUrl, delegate());
 408     EXPECT_FALSE(delegate()->loaded_group_.get());
 409   }
 410
 411   void Verify_CreateGroup() {
 412     EXPECT_EQ(kManifestUrl, delegate()->loaded_manifest_url_);
 413     EXPECT_TRUE(delegate()->loaded_group_.get());
 414     EXPECT_TRUE(delegate()->loaded_group_->HasOneRef());
 415     EXPECT_FALSE(delegate()->loaded_group_->newest_complete_cache());
 416
 417     // Should not have been stored in the database.
 418     AppCacheDatabase::GroupRecord record;
 419     EXPECT_FALSE(database()->FindGroup(
 420         delegate()->loaded_group_->group_id(), &record));
 421
 422     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_accessed_count_);
 423     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
 424
 425     TestFinished();
 426   }
 427
 428   // LoadGroupAndCache_FarHit  --------------------------------------
 429
 430   void LoadGroupAndCache_FarHit() {
 431     // Attempt to load a cache that is not currently in use
 432     // and does require loading from disk. This
 433     // load should complete asynchronously.
 434     PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_LoadCache_Far_Hit,
 435                             base::Unretained(this)));
 436
 437     // Setup some preconditions. Create a group and newest cache that
 438     // appear to be "stored" and "not currently in use".
 439     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
 440     group_ = NULL;
 441     cache_ = NULL;
 442
 443     // Conduct the cache load test, completes async
 444     storage()->LoadCache(1, delegate());
 445   }
 446
 447   void Verify_LoadCache_Far_Hit() {
 448     EXPECT_TRUE(delegate()->loaded_cache_.get());
 449     EXPECT_TRUE(delegate()->loaded_cache_->HasOneRef());
 450     EXPECT_EQ(1, delegate()->loaded_cache_id_);
 451
 452     // The group should also have been loaded.
 453     EXPECT_TRUE(delegate()->loaded_cache_->owning_group());
 454     EXPECT_TRUE(delegate()->loaded_cache_->owning_group()->HasOneRef());
 455     EXPECT_EQ(1, delegate()->loaded_cache_->owning_group()->group_id());
 456
 457     EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_accessed_count_);
 458     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
 459
 460     // Drop things from the working set.
 461     delegate()->loaded_cache_ = NULL;
 462     EXPECT_FALSE(delegate()->loaded_group_.get());
 463
 464     // Conduct the group load test, also complete asynchronously.
 465     PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_LoadGroup_Far_Hit,
 466                             base::Unretained(this)));
 467
 468     storage()->LoadOrCreateGroup(kManifestUrl, delegate());
 469   }
 470
 471   void Verify_LoadGroup_Far_Hit() {
 472     EXPECT_TRUE(delegate()->loaded_group_.get());
 473     EXPECT_EQ(kManifestUrl, delegate()->loaded_manifest_url_);
 474     EXPECT_TRUE(delegate()->loaded_group_->newest_complete_cache());
 475     delegate()->loaded_groups_newest_cache_ = NULL;
 476     EXPECT_TRUE(delegate()->loaded_group_->HasOneRef());
 477     EXPECT_EQ(2, mock_quota_manager_proxy_->notify_storage_accessed_count_);
 478     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
 479     TestFinished();
 480   }
 481
 482   // StoreNewGroup  --------------------------------------
 483
 484   void StoreNewGroup() {
 485     // Store a group and its newest cache. Should complete asynchronously.
 486     PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_StoreNewGroup,
 487                             base::Unretained(this)));
 488
 489     // Setup some preconditions. Create a group and newest cache that
 490     // appear to be "unstored".
 491     group_ = new AppCacheGroup(
 492         storage(), kManifestUrl, storage()->NewGroupId());
 493     cache_ = new AppCache(storage(), storage()->NewCacheId());
 494     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, 1,
 495                                               kDefaultEntrySize));
 496     // Hold a ref to the cache simulate the UpdateJob holding that ref,
 497     // and hold a ref to the group to simulate the CacheHost holding that ref.
 498
 499     // Have the quota manager retrun asynchronously for this test.
 500     mock_quota_manager_proxy_->mock_manager_->async_ = true;
 501
 502     // Conduct the store test.
 503     storage()->StoreGroupAndNewestCache(group_.get(), cache_.get(), delegate());
 504     EXPECT_FALSE(delegate()->stored_group_success_);
 505   }
 506
 507   void Verify_StoreNewGroup() {
 508     EXPECT_TRUE(delegate()->stored_group_success_);
 509     EXPECT_EQ(group_.get(), delegate()->stored_group_.get());
 510     EXPECT_EQ(cache_.get(), group_->newest_complete_cache());
 511     EXPECT_TRUE(cache_->is_complete());
 512
 513     // Should have been stored in the database.
 514     AppCacheDatabase::GroupRecord group_record;
 515     AppCacheDatabase::CacheRecord cache_record;
 516     EXPECT_TRUE(database()->FindGroup(group_->group_id(), &group_record));
 517     EXPECT_TRUE(database()->FindCache(cache_->cache_id(), &cache_record));
 518
 519     // Verify quota bookkeeping
 520     EXPECT_EQ(kDefaultEntrySize, storage()->usage_map_[kOrigin]);
 521     EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_modified_count_);
 522     EXPECT_EQ(kOrigin, mock_quota_manager_proxy_->last_origin_);
 523     EXPECT_EQ(kDefaultEntrySize, mock_quota_manager_proxy_->last_delta_);
 524
 525     TestFinished();
 526   }
 527
 528   // StoreExistingGroup  --------------------------------------
 529
 530   void StoreExistingGroup() {
 531     // Store a group and its newest cache. Should complete asynchronously.
 532     PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_StoreExistingGroup,
 533                             base::Unretained(this)));
 534
 535     // Setup some preconditions. Create a group and old complete cache
 536     // that appear to be "stored"
 537     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
 538     EXPECT_EQ(kDefaultEntrySize, storage()->usage_map_[kOrigin]);
 539
 540     // And a newest unstored complete cache.
 541     cache2_ = new AppCache(storage(), 2);
 542     cache2_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::MASTER, 1,
 543                                                kDefaultEntrySize + 100));
 544
 545     // Conduct the test.
 546     storage()->StoreGroupAndNewestCache(
 547         group_.get(), cache2_.get(), delegate());
 548     EXPECT_FALSE(delegate()->stored_group_success_);
 549   }
 550
 551   void Verify_StoreExistingGroup() {
 552     EXPECT_TRUE(delegate()->stored_group_success_);
 553     EXPECT_EQ(group_.get(), delegate()->stored_group_.get());
 554     EXPECT_EQ(cache2_.get(), group_->newest_complete_cache());
 555     EXPECT_TRUE(cache2_->is_complete());
 556
 557     // The new cache should have been stored in the database.
 558     AppCacheDatabase::GroupRecord group_record;
 559     AppCacheDatabase::CacheRecord cache_record;
 560     EXPECT_TRUE(database()->FindGroup(1, &group_record));
 561     EXPECT_TRUE(database()->FindCache(2, &cache_record));
 562
 563     // The old cache should have been deleted
 564     EXPECT_FALSE(database()->FindCache(1, &cache_record));
 565
 566     // Verify quota bookkeeping
 567     EXPECT_EQ(kDefaultEntrySize + 100, storage()->usage_map_[kOrigin]);
 568     EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_modified_count_);
 569     EXPECT_EQ(kOrigin, mock_quota_manager_proxy_->last_origin_);
 570     EXPECT_EQ(100, mock_quota_manager_proxy_->last_delta_);
 571
 572     TestFinished();
 573   }
 574
 575   // StoreExistingGroupExistingCache  -------------------------------
 576
 577   void StoreExistingGroupExistingCache() {
 578     // Store a group with updates to its existing newest complete cache.
 579     // Setup some preconditions. Create a group and a complete cache that
 580     // appear to be "stored".
 581
 582     // Setup some preconditions. Create a group and old complete cache
 583     // that appear to be "stored"
 584     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
 585     EXPECT_EQ(kDefaultEntrySize, storage()->usage_map_[kOrigin]);
 586
 587     // Change the cache.
 588     base::Time now = base::Time::Now();
 589     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::MASTER, 1, 100));
 590     cache_->set_update_time(now);
 591
 592     PushNextTask(base::Bind(
 593         &AppCacheStorageImplTest::Verify_StoreExistingGroupExistingCache,
 594         base::Unretained(this), now));
 595
 596     // Conduct the test.
 597     EXPECT_EQ(cache_, group_->newest_complete_cache());
 598     storage()->StoreGroupAndNewestCache(group_.get(), cache_.get(), delegate());
 599     EXPECT_FALSE(delegate()->stored_group_success_);
 600   }
 601
 602   void Verify_StoreExistingGroupExistingCache(
 603       base::Time expected_update_time) {
 604     EXPECT_TRUE(delegate()->stored_group_success_);
 605     EXPECT_EQ(cache_, group_->newest_complete_cache());
 606
 607     AppCacheDatabase::CacheRecord cache_record;
 608     EXPECT_TRUE(database()->FindCache(1, &cache_record));
 609     EXPECT_EQ(1, cache_record.cache_id);
 610     EXPECT_EQ(1, cache_record.group_id);
 611     EXPECT_FALSE(cache_record.online_wildcard);
 612     EXPECT_TRUE(expected_update_time == cache_record.update_time);
 613     EXPECT_EQ(100 + kDefaultEntrySize, cache_record.cache_size);
 614
 615     std::vector<AppCacheDatabase::EntryRecord> entry_records;
 616     EXPECT_TRUE(database()->FindEntriesForCache(1, &entry_records));
 617     EXPECT_EQ(2U, entry_records.size());
 618     if (entry_records[0].url == kDefaultEntryUrl)
 619       entry_records.erase(entry_records.begin());
 620     EXPECT_EQ(1 , entry_records[0].cache_id);
 621     EXPECT_EQ(kEntryUrl, entry_records[0].url);
 622     EXPECT_EQ(AppCacheEntry::MASTER, entry_records[0].flags);
 623     EXPECT_EQ(1, entry_records[0].response_id);
 624     EXPECT_EQ(100, entry_records[0].response_size);
 625
 626     // Verify quota bookkeeping
 627     EXPECT_EQ(100 + kDefaultEntrySize, storage()->usage_map_[kOrigin]);
 628     EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_modified_count_);
 629     EXPECT_EQ(kOrigin, mock_quota_manager_proxy_->last_origin_);
 630     EXPECT_EQ(100, mock_quota_manager_proxy_->last_delta_);
 631
 632     TestFinished();
 633   }
 634
 635   // FailStoreGroup  --------------------------------------
 636
 637   void FailStoreGroup() {
 638     // Store a group and its newest cache. Should complete asynchronously.
 639     PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_FailStoreGroup,
 640                             base::Unretained(this)));
 641
 642     // Setup some preconditions. Create a group and newest cache that
 643     // appear to be "unstored" and big enough to exceed the 5M limit.
 644     const int64 kTooBig = 10 * 1024 * 1024;  // 10M
 645     group_ = new AppCacheGroup(
 646         storage(), kManifestUrl, storage()->NewGroupId());
 647     cache_ = new AppCache(storage(), storage()->NewCacheId());
 648     cache_->AddEntry(kManifestUrl,
 649                      AppCacheEntry(AppCacheEntry::MANIFEST, 1, kTooBig));
 650     // Hold a ref to the cache simulate the UpdateJob holding that ref,
 651     // and hold a ref to the group to simulate the CacheHost holding that ref.
 652
 653     // Conduct the store test.
 654     storage()->StoreGroupAndNewestCache(group_.get(), cache_.get(), delegate());
 655     EXPECT_FALSE(delegate()->stored_group_success_);  // Expected to be async.
 656   }
 657
 658   void Verify_FailStoreGroup() {
 659     EXPECT_FALSE(delegate()->stored_group_success_);
 660     EXPECT_TRUE(delegate()->would_exceed_quota_);
 661
 662     // Should not have been stored in the database.
 663     AppCacheDatabase::GroupRecord group_record;
 664     AppCacheDatabase::CacheRecord cache_record;
 665     EXPECT_FALSE(database()->FindGroup(group_->group_id(), &group_record));
 666     EXPECT_FALSE(database()->FindCache(cache_->cache_id(), &cache_record));
 667
 668     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_accessed_count_);
 669     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
 670
 671     TestFinished();
 672   }
 673
 674   // MakeGroupObsolete  -------------------------------
 675
 676   void MakeGroupObsolete() {
 677     // Make a group obsolete, should complete asynchronously.
 678     PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_MakeGroupObsolete,
 679                             base::Unretained(this)));
 680
 681     // Setup some preconditions. Create a group and newest cache that
 682     // appears to be "stored" and "currently in use".
 683     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
 684     EXPECT_EQ(kDefaultEntrySize, storage()->usage_map_[kOrigin]);
 685
 686     // Also insert some related records.
 687     AppCacheDatabase::EntryRecord entry_record;
 688     entry_record.cache_id = 1;
 689     entry_record.flags = AppCacheEntry::FALLBACK;
 690     entry_record.response_id = 1;
 691     entry_record.url = kEntryUrl;
 692     EXPECT_TRUE(database()->InsertEntry(&entry_record));
 693
 694     AppCacheDatabase::NamespaceRecord fallback_namespace_record;
 695     fallback_namespace_record.cache_id = 1;
 696     fallback_namespace_record.namespace_.target_url = kEntryUrl;
 697     fallback_namespace_record.namespace_.namespace_url = kFallbackNamespace;
 698     fallback_namespace_record.origin = kManifestUrl.GetOrigin();
 699     EXPECT_TRUE(database()->InsertNamespace(&fallback_namespace_record));
 700
 701     AppCacheDatabase::OnlineWhiteListRecord online_whitelist_record;
 702     online_whitelist_record.cache_id = 1;
 703     online_whitelist_record.namespace_url = kOnlineNamespace;
 704     EXPECT_TRUE(database()->InsertOnlineWhiteList(&online_whitelist_record));
 705
 706     // Conduct the test.
 707     storage()->MakeGroupObsolete(group_.get(), delegate());
 708     EXPECT_FALSE(group_->is_obsolete());
 709   }
 710
 711   void Verify_MakeGroupObsolete() {
 712     EXPECT_TRUE(delegate()->obsoleted_success_);
 713     EXPECT_EQ(group_.get(), delegate()->obsoleted_group_.get());
 714     EXPECT_TRUE(group_->is_obsolete());
 715     EXPECT_TRUE(storage()->usage_map_.empty());
 716
 717     // The cache and group have been deleted from the database.
 718     AppCacheDatabase::GroupRecord group_record;
 719     AppCacheDatabase::CacheRecord cache_record;
 720     EXPECT_FALSE(database()->FindGroup(1, &group_record));
 721     EXPECT_FALSE(database()->FindCache(1, &cache_record));
 722
 723     // The related records should have been deleted too.
 724     std::vector<AppCacheDatabase::EntryRecord> entry_records;
 725     database()->FindEntriesForCache(1, &entry_records);
 726     EXPECT_TRUE(entry_records.empty());
 727     std::vector<AppCacheDatabase::NamespaceRecord> intercept_records;
 728     std::vector<AppCacheDatabase::NamespaceRecord> fallback_records;
 729     database()->FindNamespacesForCache(
 730         1, &intercept_records, &fallback_records);
 731     EXPECT_TRUE(fallback_records.empty());
 732     std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelist_records;
 733     database()->FindOnlineWhiteListForCache(1, &whitelist_records);
 734     EXPECT_TRUE(whitelist_records.empty());
 735
 736     // Verify quota bookkeeping
 737     EXPECT_TRUE(storage()->usage_map_.empty());
 738     EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_modified_count_);
 739     EXPECT_EQ(kOrigin, mock_quota_manager_proxy_->last_origin_);
 740     EXPECT_EQ(-kDefaultEntrySize, mock_quota_manager_proxy_->last_delta_);
 741
 742     TestFinished();
 743   }
 744
 745   // MarkEntryAsForeign  -------------------------------
 746
 747   void MarkEntryAsForeign() {
 748     // Setup some preconditions. Create a cache with an entry
 749     // in storage and in the working set.
 750     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
 751     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT));
 752     AppCacheDatabase::EntryRecord entry_record;
 753     entry_record.cache_id = 1;
 754     entry_record.url = kEntryUrl;
 755     entry_record.flags = AppCacheEntry::EXPLICIT;
 756     entry_record.response_id = 0;
 757     EXPECT_TRUE(database()->InsertEntry(&entry_record));
 758     EXPECT_FALSE(cache_->GetEntry(kEntryUrl)->IsForeign());
 759
 760     // Conduct the test.
 761     storage()->MarkEntryAsForeign(kEntryUrl, 1);
 762
 763     // The entry in the working set should have been updated syncly.
 764     EXPECT_TRUE(cache_->GetEntry(kEntryUrl)->IsForeign());
 765     EXPECT_TRUE(cache_->GetEntry(kEntryUrl)->IsExplicit());
 766
 767     // And the entry in storage should also be updated, but that
 768     // happens asynchronously on the db thread.
 769     FlushDbThreadTasks();
 770     AppCacheDatabase::EntryRecord entry_record2;
 771     EXPECT_TRUE(database()->FindEntry(1, kEntryUrl, &entry_record2));
 772     EXPECT_EQ(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN,
 773               entry_record2.flags);
 774     TestFinished();
 775   }
 776
 777   // MarkEntryAsForeignWithLoadInProgress  -------------------------------
 778
 779   void MarkEntryAsForeignWithLoadInProgress() {
 780     PushNextTask(base::Bind(
 781        &AppCacheStorageImplTest::Verify_MarkEntryAsForeignWithLoadInProgress,
 782        base::Unretained(this)));
 783
 784     // Setup some preconditions. Create a cache with an entry
 785     // in storage, but not in the working set.
 786     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
 787     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT));
 788     AppCacheDatabase::EntryRecord entry_record;
 789     entry_record.cache_id = 1;
 790     entry_record.url = kEntryUrl;
 791     entry_record.flags = AppCacheEntry::EXPLICIT;
 792     entry_record.response_id = 0;
 793     EXPECT_TRUE(database()->InsertEntry(&entry_record));
 794     EXPECT_FALSE(cache_->GetEntry(kEntryUrl)->IsForeign());
 795     EXPECT_TRUE(cache_->HasOneRef());
 796     cache_ = NULL;
 797     group_ = NULL;
 798
 799     // Conduct the test, start a cache load, and prior to completion
 800     // of that load, mark the entry as foreign.
 801     storage()->LoadCache(1, delegate());
 802     storage()->MarkEntryAsForeign(kEntryUrl, 1);
 803   }
 804
 805   void Verify_MarkEntryAsForeignWithLoadInProgress() {
 806     EXPECT_EQ(1, delegate()->loaded_cache_id_);
 807     EXPECT_TRUE(delegate()->loaded_cache_.get());
 808
 809     // The entry in the working set should have been updated upon load.
 810     EXPECT_TRUE(delegate()->loaded_cache_->GetEntry(kEntryUrl)->IsForeign());
 811     EXPECT_TRUE(delegate()->loaded_cache_->GetEntry(kEntryUrl)->IsExplicit());
 812
 813     // And the entry in storage should also be updated.
 814     FlushDbThreadTasks();
 815     AppCacheDatabase::EntryRecord entry_record;
 816     EXPECT_TRUE(database()->FindEntry(1, kEntryUrl, &entry_record));
 817     EXPECT_EQ(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN,
 818               entry_record.flags);
 819     TestFinished();
 820   }
 821
 822   // FindNoMainResponse  -------------------------------
 823
 824   void FindNoMainResponse() {
 825     PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_FindNoMainResponse,
 826                             base::Unretained(this)));
 827
 828     // Conduct the test.
 829     storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
 830     EXPECT_NE(kEntryUrl, delegate()->found_url_);
 831   }
 832
 833   void Verify_FindNoMainResponse() {
 834     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
 835     EXPECT_TRUE(delegate()->found_manifest_url_.is_empty());
 836     EXPECT_EQ(kNoCacheId, delegate()->found_cache_id_);
 837     EXPECT_EQ(kNoResponseId, delegate()->found_entry_.response_id());
 838     EXPECT_EQ(kNoResponseId, delegate()->found_fallback_entry_.response_id());
 839     EXPECT_TRUE(delegate()->found_namespace_entry_url_.is_empty());
 840     EXPECT_EQ(0, delegate()->found_entry_.types());
 841     EXPECT_EQ(0, delegate()->found_fallback_entry_.types());
 842     TestFinished();
 843   }
 844
 845   // BasicFindMainResponse  -------------------------------
 846
 847   void BasicFindMainResponseInDatabase() {
 848     BasicFindMainResponse(true);
 849   }
 850
 851   void BasicFindMainResponseInWorkingSet() {
 852     BasicFindMainResponse(false);
 853   }
 854
 855   void BasicFindMainResponse(bool drop_from_working_set) {
 856     PushNextTask(base::Bind(
 857         &AppCacheStorageImplTest::Verify_BasicFindMainResponse,
 858         base::Unretained(this)));
 859
 860     // Setup some preconditions. Create a complete cache with an entry
 861     // in storage.
 862     MakeCacheAndGroup(kManifestUrl, 2, 1, true);
 863     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, 1));
 864     AppCacheDatabase::EntryRecord entry_record;
 865     entry_record.cache_id = 1;
 866     entry_record.url = kEntryUrl;
 867     entry_record.flags = AppCacheEntry::EXPLICIT;
 868     entry_record.response_id = 1;
 869     EXPECT_TRUE(database()->InsertEntry(&entry_record));
 870
 871     // Optionally drop the cache/group pair from the working set.
 872     if (drop_from_working_set) {
 873       EXPECT_TRUE(cache_->HasOneRef());
 874       cache_ = NULL;
 875       EXPECT_TRUE(group_->HasOneRef());
 876       group_ = NULL;
 877     }
 878
 879     // Conduct the test.
 880     storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
 881     EXPECT_NE(kEntryUrl,  delegate()->found_url_);
 882   }
 883
 884   void Verify_BasicFindMainResponse() {
 885     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
 886     EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
 887     EXPECT_EQ(1, delegate()->found_cache_id_);
 888     EXPECT_EQ(2, delegate()->found_group_id_);
 889     EXPECT_EQ(1, delegate()->found_entry_.response_id());
 890     EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
 891     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
 892     TestFinished();
 893   }
 894
 895   // BasicFindMainFallbackResponse  -------------------------------
 896
 897   void BasicFindMainFallbackResponseInDatabase() {
 898     BasicFindMainFallbackResponse(true);
 899   }
 900
 901   void BasicFindMainFallbackResponseInWorkingSet() {
 902     BasicFindMainFallbackResponse(false);
 903   }
 904
 905   void BasicFindMainFallbackResponse(bool drop_from_working_set) {
 906     PushNextTask(base::Bind(
 907         &AppCacheStorageImplTest::Verify_BasicFindMainFallbackResponse,
 908         base::Unretained(this)));
 909
 910     // Setup some preconditions. Create a complete cache with a
 911     // fallback namespace and entry.
 912     MakeCacheAndGroup(kManifestUrl, 2, 1, true);
 913     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::FALLBACK, 1));
 914     cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::FALLBACK, 2));
 915     cache_->fallback_namespaces_.push_back(
 916         Namespace(FALLBACK_NAMESPACE, kFallbackNamespace2, kEntryUrl2, false));
 917     cache_->fallback_namespaces_.push_back(
 918         Namespace(FALLBACK_NAMESPACE, kFallbackNamespace, kEntryUrl, false));
 919     AppCacheDatabase::CacheRecord cache_record;
 920     std::vector<AppCacheDatabase::EntryRecord> entries;
 921     std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
 922     std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
 923     std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
 924     cache_->ToDatabaseRecords(group_.get(),
 925                               &cache_record,
 926                               &entries,
 927                               &intercepts,
 928                               &fallbacks,
 929                               &whitelists);
 930
 931     std::vector<AppCacheDatabase::EntryRecord>::const_iterator iter =
 932         entries.begin();
 933     while (iter != entries.end()) {
 934       // MakeCacheAndGroup has inserted the default entry record already.
 935       if (iter->url != kDefaultEntryUrl)
 936         EXPECT_TRUE(database()->InsertEntry(&(*iter)));
 937       ++iter;
 938     }
 939
 940     EXPECT_TRUE(database()->InsertNamespaceRecords(fallbacks));
 941     EXPECT_TRUE(database()->InsertOnlineWhiteListRecords(whitelists));
 942     if (drop_from_working_set) {
 943       EXPECT_TRUE(cache_->HasOneRef());
 944       cache_ = NULL;
 945       EXPECT_TRUE(group_->HasOneRef());
 946       group_ = NULL;
 947     }
 948
 949     // Conduct the test. The test url is in both fallback namespace urls,
 950     // but should match the longer of the two.
 951     storage()->FindResponseForMainRequest(kFallbackTestUrl, GURL(), delegate());
 952     EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
 953   }
 954
 955   void Verify_BasicFindMainFallbackResponse() {
 956     EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
 957     EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
 958     EXPECT_EQ(1, delegate()->found_cache_id_);
 959     EXPECT_EQ(2, delegate()->found_group_id_);
 960     EXPECT_FALSE(delegate()->found_entry_.has_response_id());
 961     EXPECT_EQ(2, delegate()->found_fallback_entry_.response_id());
 962     EXPECT_EQ(kEntryUrl2, delegate()->found_namespace_entry_url_);
 963     EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
 964     TestFinished();
 965   }
 966
 967   // BasicFindMainInterceptResponse  -------------------------------
 968
 969   void BasicFindMainInterceptResponseInDatabase() {
 970     BasicFindMainInterceptResponse(true);
 971   }
 972
 973   void BasicFindMainInterceptResponseInWorkingSet() {
 974     BasicFindMainInterceptResponse(false);
 975   }
 976
 977   void BasicFindMainInterceptResponse(bool drop_from_working_set) {
 978     PushNextTask(base::Bind(
 979         &AppCacheStorageImplTest::Verify_BasicFindMainInterceptResponse,
 980         base::Unretained(this)));
 981
 982     // Setup some preconditions. Create a complete cache with an
 983     // intercept namespace and entry.
 984     MakeCacheAndGroup(kManifestUrl, 2, 1, true);
 985     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::INTERCEPT, 1));
 986     cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::INTERCEPT, 2));
 987     cache_->intercept_namespaces_.push_back(
 988         Namespace(INTERCEPT_NAMESPACE, kInterceptNamespace2,
 989                   kEntryUrl2, false));
 990     cache_->intercept_namespaces_.push_back(
 991         Namespace(INTERCEPT_NAMESPACE, kInterceptNamespace,
 992                   kEntryUrl, false));
 993     AppCacheDatabase::CacheRecord cache_record;
 994     std::vector<AppCacheDatabase::EntryRecord> entries;
 995     std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
 996     std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
 997     std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
 998     cache_->ToDatabaseRecords(group_.get(),
 999                               &cache_record,
1000                               &entries,
1001                               &intercepts,
1002                               &fallbacks,
1003                               &whitelists);
1004
1005     std::vector<AppCacheDatabase::EntryRecord>::const_iterator iter =
1006         entries.begin();
1007     while (iter != entries.end()) {
1008       // MakeCacheAndGroup has inserted  the default entry record already
1009       if (iter->url != kDefaultEntryUrl)
1010         EXPECT_TRUE(database()->InsertEntry(&(*iter)));
1011       ++iter;
1012     }
1013
1014     EXPECT_TRUE(database()->InsertNamespaceRecords(intercepts));
1015     EXPECT_TRUE(database()->InsertOnlineWhiteListRecords(whitelists));
1016     if (drop_from_working_set) {
1017       EXPECT_TRUE(cache_->HasOneRef());
1018       cache_ = NULL;
1019       EXPECT_TRUE(group_->HasOneRef());
1020       group_ = NULL;
1021     }
1022
1023     // Conduct the test. The test url is in both intercept namespaces,
1024     // but should match the longer of the two.
1025     storage()->FindResponseForMainRequest(
1026         kInterceptTestUrl, GURL(), delegate());
1027     EXPECT_NE(kInterceptTestUrl, delegate()->found_url_);
1028   }
1029
1030   void Verify_BasicFindMainInterceptResponse() {
1031     EXPECT_EQ(kInterceptTestUrl, delegate()->found_url_);
1032     EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
1033     EXPECT_EQ(1, delegate()->found_cache_id_);
1034     EXPECT_EQ(2, delegate()->found_group_id_);
1035     EXPECT_EQ(2, delegate()->found_entry_.response_id());
1036     EXPECT_TRUE(delegate()->found_entry_.IsIntercept());
1037     EXPECT_EQ(kEntryUrl2, delegate()->found_namespace_entry_url_);
1038     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
1039     TestFinished();
1040   }
1041
1042   // FindInterceptPatternMatch ----------------------------------------
1043
1044   void FindInterceptPatternMatchInDatabase() {
1045     FindInterceptPatternMatch(true);
1046   }
1047
1048   void FindInterceptPatternMatchInWorkingSet() {
1049     FindInterceptPatternMatch(false);
1050   }
1051
1052   void FindInterceptPatternMatch(bool drop_from_working_set) {
1053     // Setup some preconditions. Create a complete cache with an
1054     // pattern matching intercept namespace and entry.
1055     MakeCacheAndGroup(kManifestUrl, 2, 1, true);
1056     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::INTERCEPT, 1));
1057     cache_->intercept_namespaces_.push_back(
1058         Namespace(INTERCEPT_NAMESPACE, kInterceptPatternNamespace,
1059                   kEntryUrl, true));
1060     AppCacheDatabase::CacheRecord cache_record;
1061     std::vector<AppCacheDatabase::EntryRecord> entries;
1062     std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
1063     std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
1064     std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
1065     cache_->ToDatabaseRecords(group_.get(),
1066                               &cache_record,
1067                               &entries,
1068                               &intercepts,
1069                               &fallbacks,
1070                               &whitelists);
1071
1072     std::vector<AppCacheDatabase::EntryRecord>::const_iterator iter =
1073         entries.begin();
1074     while (iter != entries.end()) {
1075       // MakeCacheAndGroup has inserted  the default entry record already
1076       if (iter->url != kDefaultEntryUrl)
1077         EXPECT_TRUE(database()->InsertEntry(&(*iter)));
1078       ++iter;
1079     }
1080
1081     EXPECT_TRUE(database()->InsertNamespaceRecords(intercepts));
1082     if (drop_from_working_set) {
1083       EXPECT_TRUE(cache_->HasOneRef());
1084       cache_ = NULL;
1085       EXPECT_TRUE(group_->HasOneRef());
1086       group_ = NULL;
1087     }
1088
1089     // First test something that does not match the pattern.
1090     PushNextTask(base::Bind(
1091         &AppCacheStorageImplTest::Verify_FindInterceptPatternMatchNegative,
1092         base::Unretained(this)));
1093     storage()->FindResponseForMainRequest(
1094         kInterceptPatternTestNegativeUrl, GURL(), delegate());
1095     EXPECT_EQ(GURL(), delegate()->found_url_);  // Is always async.
1096   }
1097
1098   void Verify_FindInterceptPatternMatchNegative() {
1099     EXPECT_EQ(kInterceptPatternTestNegativeUrl, delegate()->found_url_);
1100     EXPECT_TRUE(delegate()->found_manifest_url_.is_empty());
1101     EXPECT_EQ(kNoCacheId, delegate()->found_cache_id_);
1102     EXPECT_EQ(kNoResponseId, delegate()->found_entry_.response_id());
1103     EXPECT_EQ(kNoResponseId, delegate()->found_fallback_entry_.response_id());
1104     EXPECT_TRUE(delegate()->found_namespace_entry_url_.is_empty());
1105     EXPECT_EQ(0, delegate()->found_entry_.types());
1106     EXPECT_EQ(0, delegate()->found_fallback_entry_.types());
1107
1108     // Then test something that matches.
1109     PushNextTask(base::Bind(
1110         &AppCacheStorageImplTest::Verify_FindInterceptPatternMatchPositive,
1111         base::Unretained(this)));
1112     storage()->FindResponseForMainRequest(
1113         kInterceptPatternTestPositiveUrl, GURL(), delegate());
1114   }
1115
1116   void Verify_FindInterceptPatternMatchPositive() {
1117     EXPECT_EQ(kInterceptPatternTestPositiveUrl, delegate()->found_url_);
1118     EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
1119     EXPECT_EQ(1, delegate()->found_cache_id_);
1120     EXPECT_EQ(2, delegate()->found_group_id_);
1121     EXPECT_EQ(1, delegate()->found_entry_.response_id());
1122     EXPECT_TRUE(delegate()->found_entry_.IsIntercept());
1123     EXPECT_EQ(kEntryUrl, delegate()->found_namespace_entry_url_);
1124     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
1125     TestFinished();
1126   }
1127
1128   // FindFallbackPatternMatch  -------------------------------
1129
1130   void FindFallbackPatternMatchInDatabase() {
1131     FindFallbackPatternMatch(true);
1132   }
1133
1134   void FindFallbackPatternMatchInWorkingSet() {
1135     FindFallbackPatternMatch(false);
1136   }
1137
1138   void FindFallbackPatternMatch(bool drop_from_working_set) {
1139     // Setup some preconditions. Create a complete cache with a
1140     // pattern matching fallback namespace and entry.
1141     MakeCacheAndGroup(kManifestUrl, 2, 1, true);
1142     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::FALLBACK, 1));
1143     cache_->fallback_namespaces_.push_back(
1144         Namespace(FALLBACK_NAMESPACE, kFallbackPatternNamespace,
1145                   kEntryUrl, true));
1146     AppCacheDatabase::CacheRecord cache_record;
1147     std::vector<AppCacheDatabase::EntryRecord> entries;
1148     std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
1149     std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
1150     std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
1151     cache_->ToDatabaseRecords(group_.get(),
1152                               &cache_record,
1153                               &entries,
1154                               &intercepts,
1155                               &fallbacks,
1156                               &whitelists);
1157
1158     std::vector<AppCacheDatabase::EntryRecord>::const_iterator iter =
1159         entries.begin();
1160     while (iter != entries.end()) {
1161       // MakeCacheAndGroup has inserted the default entry record already.
1162       if (iter->url != kDefaultEntryUrl)
1163         EXPECT_TRUE(database()->InsertEntry(&(*iter)));
1164       ++iter;
1165     }
1166
1167     EXPECT_TRUE(database()->InsertNamespaceRecords(fallbacks));
1168     if (drop_from_working_set) {
1169       EXPECT_TRUE(cache_->HasOneRef());
1170       cache_ = NULL;
1171       EXPECT_TRUE(group_->HasOneRef());
1172       group_ = NULL;
1173     }
1174
1175     // First test something that does not match the pattern.
1176     PushNextTask(base::Bind(
1177         &AppCacheStorageImplTest::Verify_FindFallbackPatternMatchNegative,
1178         base::Unretained(this)));
1179     storage()->FindResponseForMainRequest(
1180         kFallbackPatternTestNegativeUrl, GURL(), delegate());
1181     EXPECT_EQ(GURL(), delegate()->found_url_);  // Is always async.
1182   }
1183
1184   void Verify_FindFallbackPatternMatchNegative() {
1185     EXPECT_EQ(kFallbackPatternTestNegativeUrl, delegate()->found_url_);
1186       EXPECT_TRUE(delegate()->found_manifest_url_.is_empty());
1187       EXPECT_EQ(kNoCacheId, delegate()->found_cache_id_);
1188       EXPECT_EQ(kNoResponseId, delegate()->found_entry_.response_id());
1189       EXPECT_EQ(kNoResponseId, delegate()->found_fallback_entry_.response_id());
1190       EXPECT_TRUE(delegate()->found_namespace_entry_url_.is_empty());
1191       EXPECT_EQ(0, delegate()->found_entry_.types());
1192       EXPECT_EQ(0, delegate()->found_fallback_entry_.types());
1193
1194       // Then test something that matches.
1195       PushNextTask(base::Bind(
1196           &AppCacheStorageImplTest::Verify_FindFallbackPatternMatchPositive,
1197           base::Unretained(this)));
1198       storage()->FindResponseForMainRequest(
1199           kFallbackPatternTestPositiveUrl, GURL(), delegate());
1200   }
1201
1202   void Verify_FindFallbackPatternMatchPositive() {
1203     EXPECT_EQ(kFallbackPatternTestPositiveUrl, delegate()->found_url_);
1204     EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
1205     EXPECT_EQ(1, delegate()->found_cache_id_);
1206     EXPECT_EQ(2, delegate()->found_group_id_);
1207     EXPECT_EQ(1, delegate()->found_fallback_entry_.response_id());
1208     EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
1209     EXPECT_EQ(kEntryUrl, delegate()->found_namespace_entry_url_);
1210     EXPECT_FALSE(delegate()->found_entry_.has_response_id());
1211     TestFinished();
1212   }
1213
1214   // FindMainResponseWithMultipleHits  -------------------------------
1215
1216   void FindMainResponseWithMultipleHits() {
1217     PushNextTask(base::Bind(
1218         &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits,
1219         base::Unretained(this)));
1220
1221     // Setup some preconditions, create a few caches with an identical set
1222     // of entries and fallback namespaces. Only the last one remains in
1223     // the working set to simulate appearing as "in use".
1224     MakeMultipleHitCacheAndGroup(kManifestUrl, 1);
1225     MakeMultipleHitCacheAndGroup(kManifestUrl2, 2);
1226     MakeMultipleHitCacheAndGroup(kManifestUrl3, 3);
1227
1228     // Conduct the test, we should find the response from the last cache
1229     // since it's "in use".
1230     storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
1231     EXPECT_NE(kEntryUrl, delegate()->found_url_);
1232   }
1233
1234   void MakeMultipleHitCacheAndGroup(const GURL& manifest_url, int id) {
1235     MakeCacheAndGroup(manifest_url, id, id, true);
1236     AppCacheDatabase::EntryRecord entry_record;
1237
1238     // Add an entry for kEntryUrl
1239     entry_record.cache_id = id;
1240     entry_record.url = kEntryUrl;
1241     entry_record.flags = AppCacheEntry::EXPLICIT;
1242     entry_record.response_id = id;
1243     EXPECT_TRUE(database()->InsertEntry(&entry_record));
1244     cache_->AddEntry(
1245         entry_record.url,
1246         AppCacheEntry(entry_record.flags, entry_record.response_id));
1247
1248     // Add an entry for the manifestUrl
1249     entry_record.cache_id = id;
1250     entry_record.url = manifest_url;
1251     entry_record.flags = AppCacheEntry::MANIFEST;
1252     entry_record.response_id = id + kManifestEntryIdOffset;
1253     EXPECT_TRUE(database()->InsertEntry(&entry_record));
1254     cache_->AddEntry(
1255         entry_record.url,
1256         AppCacheEntry(entry_record.flags, entry_record.response_id));
1257
1258     // Add a fallback entry and namespace
1259     entry_record.cache_id = id;
1260     entry_record.url = kEntryUrl2;
1261     entry_record.flags = AppCacheEntry::FALLBACK;
1262     entry_record.response_id = id + kFallbackEntryIdOffset;
1263     EXPECT_TRUE(database()->InsertEntry(&entry_record));
1264     cache_->AddEntry(
1265         entry_record.url,
1266         AppCacheEntry(entry_record.flags, entry_record.response_id));
1267     AppCacheDatabase::NamespaceRecord fallback_namespace_record;
1268     fallback_namespace_record.cache_id = id;
1269     fallback_namespace_record.namespace_.target_url = entry_record.url;
1270     fallback_namespace_record.namespace_.namespace_url = kFallbackNamespace;
1271     fallback_namespace_record.origin = manifest_url.GetOrigin();
1272     EXPECT_TRUE(database()->InsertNamespace(&fallback_namespace_record));
1273     cache_->fallback_namespaces_.push_back(
1274         Namespace(FALLBACK_NAMESPACE, kFallbackNamespace, kEntryUrl2, false));
1275   }
1276
1277   void Verify_FindMainResponseWithMultipleHits() {
1278     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
1279     EXPECT_EQ(kManifestUrl3, delegate()->found_manifest_url_);
1280     EXPECT_EQ(3, delegate()->found_cache_id_);
1281     EXPECT_EQ(3, delegate()->found_group_id_);
1282     EXPECT_EQ(3, delegate()->found_entry_.response_id());
1283     EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
1284     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
1285
1286     // Conduct another test perferring kManifestUrl
1287     delegate_.reset(new MockStorageDelegate(this));
1288     PushNextTask(base::Bind(
1289         &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits2,
1290         base::Unretained(this)));
1291     storage()->FindResponseForMainRequest(kEntryUrl, kManifestUrl, delegate());
1292     EXPECT_NE(kEntryUrl, delegate()->found_url_);
1293   }
1294
1295   void Verify_FindMainResponseWithMultipleHits2() {
1296     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
1297     EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
1298     EXPECT_EQ(1, delegate()->found_cache_id_);
1299     EXPECT_EQ(1, delegate()->found_group_id_);
1300     EXPECT_EQ(1, delegate()->found_entry_.response_id());
1301     EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
1302     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
1303
1304     // Conduct the another test perferring kManifestUrl2
1305     delegate_.reset(new MockStorageDelegate(this));
1306     PushNextTask(base::Bind(
1307         &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits3,
1308         base::Unretained(this)));
1309     storage()->FindResponseForMainRequest(kEntryUrl, kManifestUrl2, delegate());
1310     EXPECT_NE(kEntryUrl, delegate()->found_url_);
1311   }
1312
1313   void Verify_FindMainResponseWithMultipleHits3() {
1314     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
1315     EXPECT_EQ(kManifestUrl2, delegate()->found_manifest_url_);
1316     EXPECT_EQ(2, delegate()->found_cache_id_);
1317     EXPECT_EQ(2, delegate()->found_group_id_);
1318     EXPECT_EQ(2, delegate()->found_entry_.response_id());
1319     EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
1320     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
1321
1322     // Conduct another test with no preferred manifest that hits the fallback.
1323     delegate_.reset(new MockStorageDelegate(this));
1324     PushNextTask(base::Bind(
1325         &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits4,
1326         base::Unretained(this)));
1327     storage()->FindResponseForMainRequest(
1328         kFallbackTestUrl, GURL(), delegate());
1329     EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
1330   }
1331
1332   void Verify_FindMainResponseWithMultipleHits4() {
1333     EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
1334     EXPECT_EQ(kManifestUrl3, delegate()->found_manifest_url_);
1335     EXPECT_EQ(3, delegate()->found_cache_id_);
1336     EXPECT_EQ(3, delegate()->found_group_id_);
1337     EXPECT_FALSE(delegate()->found_entry_.has_response_id());
1338     EXPECT_EQ(3 + kFallbackEntryIdOffset,
1339               delegate()->found_fallback_entry_.response_id());
1340     EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
1341     EXPECT_EQ(kEntryUrl2, delegate()->found_namespace_entry_url_);
1342
1343     // Conduct another test preferring kManifestUrl2 that hits the fallback.
1344     delegate_.reset(new MockStorageDelegate(this));
1345     PushNextTask(base::Bind(
1346         &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits5,
1347         base::Unretained(this)));
1348     storage()->FindResponseForMainRequest(
1349         kFallbackTestUrl, kManifestUrl2, delegate());
1350     EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
1351   }
1352
1353   void Verify_FindMainResponseWithMultipleHits5() {
1354     EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
1355     EXPECT_EQ(kManifestUrl2, delegate()->found_manifest_url_);
1356     EXPECT_EQ(2, delegate()->found_cache_id_);
1357     EXPECT_EQ(2, delegate()->found_group_id_);
1358     EXPECT_FALSE(delegate()->found_entry_.has_response_id());
1359     EXPECT_EQ(2 + kFallbackEntryIdOffset,
1360               delegate()->found_fallback_entry_.response_id());
1361     EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
1362     EXPECT_EQ(kEntryUrl2, delegate()->found_namespace_entry_url_);
1363
1364     TestFinished();
1365   }
1366
1367   // FindMainResponseExclusions  -------------------------------
1368
1369   void FindMainResponseExclusionsInDatabase() {
1370     FindMainResponseExclusions(true);
1371   }
1372
1373   void FindMainResponseExclusionsInWorkingSet() {
1374     FindMainResponseExclusions(false);
1375   }
1376
1377   void FindMainResponseExclusions(bool drop_from_working_set) {
1378     // Setup some preconditions. Create a complete cache with a
1379     // foreign entry, an online namespace, and a second online
1380     // namespace nested within a fallback namespace.
1381     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
1382     cache_->AddEntry(kEntryUrl,
1383         AppCacheEntry(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN, 1));
1384     cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::FALLBACK, 2));
1385     cache_->fallback_namespaces_.push_back(
1386         Namespace(FALLBACK_NAMESPACE, kFallbackNamespace, kEntryUrl2, false));
1387     cache_->online_whitelist_namespaces_.push_back(
1388         Namespace(NETWORK_NAMESPACE, kOnlineNamespace,
1389                   GURL(), false));
1390     cache_->online_whitelist_namespaces_.push_back(
1391         Namespace(NETWORK_NAMESPACE, kOnlineNamespaceWithinFallback,
1392                   GURL(), false));
1393
1394     AppCacheDatabase::EntryRecord entry_record;
1395     entry_record.cache_id = 1;
1396     entry_record.url = kEntryUrl;
1397     entry_record.flags = AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN;
1398     entry_record.response_id = 1;
1399     EXPECT_TRUE(database()->InsertEntry(&entry_record));
1400     AppCacheDatabase::OnlineWhiteListRecord whitelist_record;
1401     whitelist_record.cache_id = 1;
1402     whitelist_record.namespace_url = kOnlineNamespace;
1403     EXPECT_TRUE(database()->InsertOnlineWhiteList(&whitelist_record));
1404     AppCacheDatabase::NamespaceRecord fallback_namespace_record;
1405     fallback_namespace_record.cache_id = 1;
1406     fallback_namespace_record.namespace_.target_url = kEntryUrl2;
1407     fallback_namespace_record.namespace_.namespace_url = kFallbackNamespace;
1408     fallback_namespace_record.origin = kManifestUrl.GetOrigin();
1409     EXPECT_TRUE(database()->InsertNamespace(&fallback_namespace_record));
1410     whitelist_record.cache_id = 1;
1411     whitelist_record.namespace_url = kOnlineNamespaceWithinFallback;
1412     EXPECT_TRUE(database()->InsertOnlineWhiteList(&whitelist_record));
1413     if (drop_from_working_set) {
1414       cache_ = NULL;
1415       group_ = NULL;
1416     }
1417
1418     // We should not find anything for the foreign entry.
1419     PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_ExclusionNotFound,
1420                             base::Unretained(this), kEntryUrl, 1));
1421     storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
1422   }
1423
1424   void Verify_ExclusionNotFound(GURL expected_url, int phase) {
1425     EXPECT_EQ(expected_url, delegate()->found_url_);
1426     EXPECT_TRUE(delegate()->found_manifest_url_.is_empty());
1427     EXPECT_EQ(kNoCacheId, delegate()->found_cache_id_);
1428     EXPECT_EQ(0, delegate()->found_group_id_);
1429     EXPECT_EQ(kNoResponseId, delegate()->found_entry_.response_id());
1430     EXPECT_EQ(kNoResponseId, delegate()->found_fallback_entry_.response_id());
1431     EXPECT_TRUE(delegate()->found_namespace_entry_url_.is_empty());
1432     EXPECT_EQ(0, delegate()->found_entry_.types());
1433     EXPECT_EQ(0, delegate()->found_fallback_entry_.types());
1434
1435     if (phase == 1) {
1436       // We should not find anything for the online namespace.
1437       PushNextTask(
1438           base::Bind(&AppCacheStorageImplTest::Verify_ExclusionNotFound,
1439                      base::Unretained(this), kOnlineNamespace, 2));
1440       storage()->FindResponseForMainRequest(
1441           kOnlineNamespace, GURL(), delegate());
1442       return;
1443     }
1444     if (phase == 2) {
1445       // We should not find anything for the online namespace nested within
1446       // the fallback namespace.
1447       PushNextTask(base::Bind(
1448           &AppCacheStorageImplTest::Verify_ExclusionNotFound,
1449           base::Unretained(this), kOnlineNamespaceWithinFallback, 3));
1450       storage()->FindResponseForMainRequest(
1451           kOnlineNamespaceWithinFallback, GURL(), delegate());
1452       return;
1453     }
1454
1455     TestFinished();
1456   }
1457
1458   // Test case helpers --------------------------------------------------
1459
1460   AppCacheService* service() {
1461     return service_.get();
1462   }
1463
1464   AppCacheStorageImpl* storage() {
1465     return static_cast<AppCacheStorageImpl*>(service()->storage());
1466   }
1467
1468   AppCacheDatabase* database() {
1469     return storage()->database_;
1470   }
1471
1472   MockStorageDelegate* delegate() {
1473     return delegate_.get();
1474   }
1475
1476   void MakeCacheAndGroup(
1477       const GURL& manifest_url, int64 group_id, int64 cache_id,
1478       bool add_to_database) {
1479     AppCacheEntry default_entry(
1480         AppCacheEntry::EXPLICIT, cache_id + kDefaultEntryIdOffset,
1481         kDefaultEntrySize);
1482     group_ = new AppCacheGroup(storage(), manifest_url, group_id);
1483     cache_ = new AppCache(storage(), cache_id);
1484     cache_->AddEntry(kDefaultEntryUrl, default_entry);
1485     cache_->set_complete(true);
1486     group_->AddCache(cache_.get());
1487     if (add_to_database) {
1488       AppCacheDatabase::GroupRecord group_record;
1489       group_record.group_id = group_id;
1490       group_record.manifest_url = manifest_url;
1491       group_record.origin = manifest_url.GetOrigin();
1492       EXPECT_TRUE(database()->InsertGroup(&group_record));
1493       AppCacheDatabase::CacheRecord cache_record;
1494       cache_record.cache_id = cache_id;
1495       cache_record.group_id = group_id;
1496       cache_record.online_wildcard = false;
1497       cache_record.update_time = kZeroTime;
1498       cache_record.cache_size = kDefaultEntrySize;
1499       EXPECT_TRUE(database()->InsertCache(&cache_record));
1500       AppCacheDatabase::EntryRecord entry_record;
1501       entry_record.cache_id = cache_id;
1502       entry_record.url = kDefaultEntryUrl;
1503       entry_record.flags = default_entry.types();
1504       entry_record.response_id = default_entry.response_id();
1505       entry_record.response_size = default_entry.response_size();
1506       EXPECT_TRUE(database()->InsertEntry(&entry_record));
1507
1508       storage()->usage_map_[manifest_url.GetOrigin()] =
1509           default_entry.response_size();
1510     }
1511   }
1512
1513   // Data members --------------------------------------------------
1514
1515   scoped_ptr<base::WaitableEvent> test_finished_event_;
1516   std::stack<base::Closure> task_stack_;
1517   scoped_ptr<AppCacheService> service_;
1518   scoped_ptr<MockStorageDelegate> delegate_;
1519   scoped_refptr<MockQuotaManagerProxy> mock_quota_manager_proxy_;
1520   scoped_refptr<AppCacheGroup> group_;
1521   scoped_refptr<AppCache> cache_;
1522   scoped_refptr<AppCache> cache2_;
1523 };
1524
1525
1526 TEST_F(AppCacheStorageImplTest, LoadCache_Miss) {
1527   RunTestOnIOThread(&AppCacheStorageImplTest::LoadCache_Miss);
1528 }
1529
1530 TEST_F(AppCacheStorageImplTest, LoadCache_NearHit) {
1531   RunTestOnIOThread(&AppCacheStorageImplTest::LoadCache_NearHit);
1532 }
1533
1534 TEST_F(AppCacheStorageImplTest, CreateGroupInEmptyOrigin) {
1535   RunTestOnIOThread(&AppCacheStorageImplTest::CreateGroupInEmptyOrigin);
1536 }
1537
1538 TEST_F(AppCacheStorageImplTest, CreateGroupInPopulatedOrigin) {
1539   RunTestOnIOThread(&AppCacheStorageImplTest::CreateGroupInPopulatedOrigin);
1540 }
1541
1542 TEST_F(AppCacheStorageImplTest, LoadGroupAndCache_FarHit) {
1543   RunTestOnIOThread(&AppCacheStorageImplTest::LoadGroupAndCache_FarHit);
1544 }
1545
1546 TEST_F(AppCacheStorageImplTest, StoreNewGroup) {
1547   RunTestOnIOThread(&AppCacheStorageImplTest::StoreNewGroup);
1548 }
1549
1550 TEST_F(AppCacheStorageImplTest, StoreExistingGroup) {
1551   RunTestOnIOThread(&AppCacheStorageImplTest::StoreExistingGroup);
1552 }
1553
1554 TEST_F(AppCacheStorageImplTest, StoreExistingGroupExistingCache) {
1555   RunTestOnIOThread(&AppCacheStorageImplTest::StoreExistingGroupExistingCache);
1556 }
1557
1558 TEST_F(AppCacheStorageImplTest, FailStoreGroup) {
1559   RunTestOnIOThread(&AppCacheStorageImplTest::FailStoreGroup);
1560 }
1561
1562 TEST_F(AppCacheStorageImplTest, MakeGroupObsolete) {
1563   RunTestOnIOThread(&AppCacheStorageImplTest::MakeGroupObsolete);
1564 }
1565
1566 TEST_F(AppCacheStorageImplTest, MarkEntryAsForeign) {
1567   RunTestOnIOThread(&AppCacheStorageImplTest::MarkEntryAsForeign);
1568 }
1569
1570 TEST_F(AppCacheStorageImplTest, MarkEntryAsForeignWithLoadInProgress) {
1571   RunTestOnIOThread(
1572       &AppCacheStorageImplTest::MarkEntryAsForeignWithLoadInProgress);
1573 }
1574
1575 TEST_F(AppCacheStorageImplTest, FindNoMainResponse) {
1576   RunTestOnIOThread(&AppCacheStorageImplTest::FindNoMainResponse);
1577 }
1578
1579 TEST_F(AppCacheStorageImplTest, BasicFindMainResponseInDatabase) {
1580   RunTestOnIOThread(
1581       &AppCacheStorageImplTest::BasicFindMainResponseInDatabase);
1582 }
1583
1584 TEST_F(AppCacheStorageImplTest, BasicFindMainResponseInWorkingSet) {
1585   RunTestOnIOThread(
1586       &AppCacheStorageImplTest::BasicFindMainResponseInWorkingSet);
1587 }
1588
1589 TEST_F(AppCacheStorageImplTest, BasicFindMainFallbackResponseInDatabase) {
1590   RunTestOnIOThread(
1591       &AppCacheStorageImplTest::BasicFindMainFallbackResponseInDatabase);
1592 }
1593
1594 TEST_F(AppCacheStorageImplTest, BasicFindMainFallbackResponseInWorkingSet) {
1595   RunTestOnIOThread(
1596       &AppCacheStorageImplTest::BasicFindMainFallbackResponseInWorkingSet);
1597 }
1598
1599 TEST_F(AppCacheStorageImplTest, BasicFindMainInterceptResponseInDatabase) {
1600   RunTestOnIOThread(
1601       &AppCacheStorageImplTest::BasicFindMainInterceptResponseInDatabase);
1602 }
1603
1604 TEST_F(AppCacheStorageImplTest, BasicFindMainInterceptResponseInWorkingSet) {
1605   RunTestOnIOThread(
1606       &AppCacheStorageImplTest::BasicFindMainInterceptResponseInWorkingSet);
1607 }
1608
1609 TEST_F(AppCacheStorageImplTest, FindMainResponseWithMultipleHits) {
1610   RunTestOnIOThread(
1611       &AppCacheStorageImplTest::FindMainResponseWithMultipleHits);
1612 }
1613
1614 TEST_F(AppCacheStorageImplTest, FindMainResponseExclusionsInDatabase) {
1615   RunTestOnIOThread(
1616       &AppCacheStorageImplTest::FindMainResponseExclusionsInDatabase);
1617 }
1618
1619 TEST_F(AppCacheStorageImplTest, FindMainResponseExclusionsInWorkingSet) {
1620   RunTestOnIOThread(
1621       &AppCacheStorageImplTest::FindMainResponseExclusionsInWorkingSet);
1622 }
1623
1624 TEST_F(AppCacheStorageImplTest, FindInterceptPatternMatchInWorkingSet) {
1625   RunTestOnIOThread(
1626       &AppCacheStorageImplTest::FindInterceptPatternMatchInWorkingSet);
1627 }
1628
1629 TEST_F(AppCacheStorageImplTest, FindInterceptPatternMatchInDatabase) {
1630   RunTestOnIOThread(
1631       &AppCacheStorageImplTest::FindInterceptPatternMatchInDatabase);
1632 }
1633
1634 TEST_F(AppCacheStorageImplTest, FindFallbackPatternMatchInWorkingSet) {
1635   RunTestOnIOThread(
1636       &AppCacheStorageImplTest::FindFallbackPatternMatchInWorkingSet);
1637 }
1638
1639 TEST_F(AppCacheStorageImplTest, FindFallbackPatternMatchInDatabase) {
1640   RunTestOnIOThread(
1641       &AppCacheStorageImplTest::FindFallbackPatternMatchInDatabase);
1642 }
1643
1644 // That's all folks!
1645
1646 }  // namespace appcache