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 1647
