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 "base/message_loop/message_loop.h" 6 #include "testing/gtest/include/gtest/gtest.h" 7 #include "webkit/browser/appcache/appcache.h" 8 #include "webkit/browser/appcache/appcache_group.h" 9 #include "webkit/browser/appcache/appcache_response.h" 10 #include "webkit/browser/appcache/appcache_storage.h" 11 #include "webkit/browser/appcache/mock_appcache_service.h" 12 13 namespace appcache { 14 15 class MockAppCacheStorageTest : public testing::Test { 16 public: 17 class MockStorageDelegate : public AppCacheStorage::Delegate { 18 public: 19 explicit MockStorageDelegate() 20 : loaded_cache_id_(0), stored_group_success_(false), 21 obsoleted_success_(false), found_cache_id_(kNoCacheId) { 22 } 23 24 virtual void OnCacheLoaded(AppCache* cache, int64 cache_id) OVERRIDE { 25 loaded_cache_ = cache; 26 loaded_cache_id_ = cache_id; 27 } 28 29 virtual void OnGroupLoaded(AppCacheGroup* group, 30 const GURL& manifest_url) OVERRIDE { 31 loaded_group_ = group; 32 loaded_manifest_url_ = manifest_url; 33 } 34 35 virtual void OnGroupAndNewestCacheStored( 36 AppCacheGroup* group, AppCache* newest_cache, bool success, 37 bool would_exceed_quota) OVERRIDE { 38 stored_group_ = group; 39 stored_group_success_ = success; 40 } 41 42 virtual void OnGroupMadeObsolete(AppCacheGroup* group, 43 bool success) OVERRIDE { 44 obsoleted_group_ = group; 45 obsoleted_success_ = success; 46 } 47 48 virtual void OnMainResponseFound(const GURL& url, 49 const AppCacheEntry& entry, 50 const GURL& fallback_url, 51 const AppCacheEntry& fallback_entry, 52 int64 cache_id, 53 int64 group_id, 54 const GURL& manifest_url) OVERRIDE { 55 found_url_ = url; 56 found_entry_ = entry; 57 found_fallback_url_ = fallback_url; 58 found_fallback_entry_ = fallback_entry; 59 found_cache_id_ = cache_id; 60 found_manifest_url_ = manifest_url; 61 } 62 63 scoped_refptr<AppCache> loaded_cache_; 64 int64 loaded_cache_id_; 65 scoped_refptr<AppCacheGroup> loaded_group_; 66 GURL loaded_manifest_url_; 67 scoped_refptr<AppCacheGroup> stored_group_; 68 bool stored_group_success_; 69 scoped_refptr<AppCacheGroup> obsoleted_group_; 70 bool obsoleted_success_; 71 GURL found_url_; 72 AppCacheEntry found_entry_; 73 GURL found_fallback_url_; 74 AppCacheEntry found_fallback_entry_; 75 int64 found_cache_id_; 76 GURL found_manifest_url_; 77 }; 78 79 private: 80 base::MessageLoop message_loop_; 81 }; 82 83 TEST_F(MockAppCacheStorageTest, LoadCache_Miss) { 84 // Attempt to load a cache that doesn't exist. Should 85 // complete asyncly. 86 MockAppCacheService service; 87 MockStorageDelegate delegate; 88 service.storage()->LoadCache(111, &delegate); 89 EXPECT_NE(111, delegate.loaded_cache_id_); 90 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 91 EXPECT_EQ(111, delegate.loaded_cache_id_); 92 EXPECT_FALSE(delegate.loaded_cache_.get()); 93 } 94 95 TEST_F(MockAppCacheStorageTest, LoadCache_NearHit) { 96 // Attempt to load a cache that is currently in use 97 // and does not require loading from disk. This 98 // load should complete syncly. 99 MockAppCacheService service; 100 101 // Setup some preconditions. Make an 'unstored' cache for 102 // us to load. The ctor should put it in the working set. 103 int64 cache_id = service.storage()->NewCacheId(); 104 scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id)); 105 106 // Conduct the test. 107 MockStorageDelegate delegate; 108 service.storage()->LoadCache(cache_id, &delegate); 109 EXPECT_EQ(cache_id, delegate.loaded_cache_id_); 110 EXPECT_EQ(cache.get(), delegate.loaded_cache_.get()); 111 } 112 113 TEST_F(MockAppCacheStorageTest, CreateGroup) { 114 // Attempt to load/create a group that doesn't exist. 115 // Should complete asyncly. 116 MockAppCacheService service; 117 MockAppCacheStorage* storage = 118 reinterpret_cast<MockAppCacheStorage*>(service.storage()); 119 MockStorageDelegate delegate; 120 GURL manifest_url("http://blah/"); 121 service.storage()->LoadOrCreateGroup(manifest_url, &delegate); 122 EXPECT_NE(manifest_url, delegate.loaded_manifest_url_); 123 EXPECT_FALSE(delegate.loaded_group_.get()); 124 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 125 EXPECT_EQ(manifest_url, delegate.loaded_manifest_url_); 126 EXPECT_TRUE(delegate.loaded_group_.get()); 127 EXPECT_TRUE(delegate.loaded_group_->HasOneRef()); 128 EXPECT_FALSE(delegate.loaded_group_->newest_complete_cache()); 129 EXPECT_TRUE(storage->stored_groups_.empty()); 130 } 131 132 TEST_F(MockAppCacheStorageTest, LoadGroup_NearHit) { 133 // Attempt to load a group that is currently in use 134 // and does not require loading from disk. This 135 // load should complete syncly. 136 MockAppCacheService service; 137 MockStorageDelegate delegate; 138 139 // Setup some preconditions. Create a group that appears 140 // to be "unstored" and "currently in use". 141 GURL manifest_url("http://blah/"); 142 service.storage()->LoadOrCreateGroup(manifest_url, &delegate); 143 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 144 EXPECT_EQ(manifest_url, delegate.loaded_manifest_url_); 145 EXPECT_TRUE(delegate.loaded_group_.get()); 146 147 // Reset our delegate, and take a reference to the new group. 148 scoped_refptr<AppCacheGroup> group; 149 group.swap(delegate.loaded_group_); 150 delegate.loaded_manifest_url_ = GURL(); 151 152 // Conduct the test. 153 service.storage()->LoadOrCreateGroup(manifest_url, &delegate); 154 EXPECT_EQ(manifest_url, delegate.loaded_manifest_url_); 155 EXPECT_EQ(group.get(), delegate.loaded_group_.get()); 156 } 157 158 TEST_F(MockAppCacheStorageTest, LoadGroupAndCache_FarHit) { 159 // Attempt to load a cache that is not currently in use 160 // and does require loading from disk. This 161 // load should complete asyncly. 162 MockAppCacheService service; 163 MockAppCacheStorage* storage = 164 reinterpret_cast<MockAppCacheStorage*>(service.storage()); 165 166 // Setup some preconditions. Create a group and newest cache that 167 // appears to be "stored" and "not currently in use". 168 GURL manifest_url("http://blah/"); 169 scoped_refptr<AppCacheGroup> group( 170 new AppCacheGroup(service.storage(), manifest_url, 111)); 171 int64 cache_id = storage->NewCacheId(); 172 scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id)); 173 cache->set_complete(true); 174 group->AddCache(cache.get()); 175 storage->AddStoredGroup(group.get()); 176 storage->AddStoredCache(cache.get()); 177 178 // Drop the references from above so the only refs to these 179 // objects are from within the storage class. This is to make 180 // these objects appear as "not currently in use". 181 AppCache* cache_ptr = cache.get(); 182 AppCacheGroup* group_ptr = group.get(); 183 cache = NULL; 184 group = NULL; 185 186 // Setup a delegate to receive completion callbacks. 187 MockStorageDelegate delegate; 188 189 // Conduct the cache load test. 190 EXPECT_NE(cache_id, delegate.loaded_cache_id_); 191 EXPECT_NE(cache_ptr, delegate.loaded_cache_.get()); 192 storage->LoadCache(cache_id, &delegate); 193 EXPECT_NE(cache_id, delegate.loaded_cache_id_); 194 EXPECT_NE(cache_ptr, delegate.loaded_cache_.get()); 195 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 196 EXPECT_EQ(cache_id, delegate.loaded_cache_id_); 197 EXPECT_EQ(cache_ptr, delegate.loaded_cache_.get()); 198 delegate.loaded_cache_ = NULL; 199 200 // Conduct the group load test. 201 EXPECT_NE(manifest_url, delegate.loaded_manifest_url_); 202 EXPECT_FALSE(delegate.loaded_group_.get()); 203 storage->LoadOrCreateGroup(manifest_url, &delegate); 204 EXPECT_NE(manifest_url, delegate.loaded_manifest_url_); 205 EXPECT_FALSE(delegate.loaded_group_.get()); 206 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 207 EXPECT_EQ(manifest_url, delegate.loaded_manifest_url_); 208 EXPECT_EQ(group_ptr, delegate.loaded_group_.get()); 209 } 210 211 TEST_F(MockAppCacheStorageTest, StoreNewGroup) { 212 // Store a group and its newest cache. Should complete asyncly. 213 MockAppCacheService service; 214 MockAppCacheStorage* storage = 215 reinterpret_cast<MockAppCacheStorage*>(service.storage()); 216 217 // Setup some preconditions. Create a group and newest cache that 218 // appears to be "unstored". 219 GURL manifest_url("http://blah/"); 220 scoped_refptr<AppCacheGroup> group( 221 new AppCacheGroup(service.storage(), manifest_url, 111)); 222 int64 cache_id = storage->NewCacheId(); 223 scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id)); 224 // Hold a ref to the cache simulate the UpdateJob holding that ref, 225 // and hold a ref to the group to simulate the CacheHost holding that ref. 226 227 // Conduct the store test. 228 MockStorageDelegate delegate; 229 EXPECT_TRUE(storage->stored_caches_.empty()); 230 EXPECT_TRUE(storage->stored_groups_.empty()); 231 storage->StoreGroupAndNewestCache(group.get(), cache.get(), &delegate); 232 EXPECT_FALSE(delegate.stored_group_success_); 233 EXPECT_TRUE(storage->stored_caches_.empty()); 234 EXPECT_TRUE(storage->stored_groups_.empty()); 235 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 236 EXPECT_TRUE(delegate.stored_group_success_); 237 EXPECT_FALSE(storage->stored_caches_.empty()); 238 EXPECT_FALSE(storage->stored_groups_.empty()); 239 EXPECT_EQ(cache, group->newest_complete_cache()); 240 EXPECT_TRUE(cache->is_complete()); 241 } 242 243 TEST_F(MockAppCacheStorageTest, StoreExistingGroup) { 244 // Store a group and its newest cache. Should complete asyncly. 245 MockAppCacheService service; 246 MockAppCacheStorage* storage = 247 reinterpret_cast<MockAppCacheStorage*>(service.storage()); 248 249 // Setup some preconditions. Create a group and old complete cache 250 // that appear to be "stored", and a newest unstored complete cache. 251 GURL manifest_url("http://blah/"); 252 scoped_refptr<AppCacheGroup> group( 253 new AppCacheGroup(service.storage(), manifest_url, 111)); 254 int64 old_cache_id = storage->NewCacheId(); 255 scoped_refptr<AppCache> old_cache( 256 new AppCache(service.storage(), old_cache_id)); 257 old_cache->set_complete(true); 258 group->AddCache(old_cache.get()); 259 storage->AddStoredGroup(group.get()); 260 storage->AddStoredCache(old_cache.get()); 261 int64 new_cache_id = storage->NewCacheId(); 262 scoped_refptr<AppCache> new_cache( 263 new AppCache(service.storage(), new_cache_id)); 264 // Hold our refs to simulate the UpdateJob holding these refs. 265 266 // Conduct the test. 267 MockStorageDelegate delegate; 268 EXPECT_EQ(size_t(1), storage->stored_caches_.size()); 269 EXPECT_EQ(size_t(1), storage->stored_groups_.size()); 270 EXPECT_TRUE(storage->IsCacheStored(old_cache.get())); 271 EXPECT_FALSE(storage->IsCacheStored(new_cache.get())); 272 storage->StoreGroupAndNewestCache(group.get(), new_cache.get(), &delegate); 273 EXPECT_FALSE(delegate.stored_group_success_); 274 EXPECT_EQ(size_t(1), storage->stored_caches_.size()); 275 EXPECT_EQ(size_t(1), storage->stored_groups_.size()); 276 EXPECT_TRUE(storage->IsCacheStored(old_cache.get())); 277 EXPECT_FALSE(storage->IsCacheStored(new_cache.get())); 278 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 279 EXPECT_TRUE(delegate.stored_group_success_); 280 EXPECT_EQ(size_t(1), storage->stored_caches_.size()); 281 EXPECT_EQ(size_t(1), storage->stored_groups_.size()); 282 EXPECT_FALSE(storage->IsCacheStored(old_cache.get())); 283 EXPECT_TRUE(storage->IsCacheStored(new_cache.get())); 284 EXPECT_EQ(new_cache.get(), group->newest_complete_cache()); 285 EXPECT_TRUE(new_cache->is_complete()); 286 } 287 288 TEST_F(MockAppCacheStorageTest, StoreExistingGroupExistingCache) { 289 // Store a group with updates to its existing newest complete cache. 290 MockAppCacheService service; 291 MockAppCacheStorage* storage = 292 reinterpret_cast<MockAppCacheStorage*>(service.storage()); 293 294 // Setup some preconditions. Create a group and a complete cache that 295 // appear to be "stored". 296 GURL manifest_url("http://blah"); 297 scoped_refptr<AppCacheGroup> group( 298 new AppCacheGroup(service.storage(), manifest_url, 111)); 299 int64 cache_id = storage->NewCacheId(); 300 scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id)); 301 cache->set_complete(true); 302 group->AddCache(cache.get()); 303 storage->AddStoredGroup(group.get()); 304 storage->AddStoredCache(cache.get()); 305 // Hold our refs to simulate the UpdateJob holding these refs. 306 307 // Change the group's newest cache. 308 EXPECT_EQ(cache, group->newest_complete_cache()); 309 GURL entry_url("http://blah/blah"); 310 cache->AddEntry(entry_url, AppCacheEntry(AppCacheEntry::MASTER)); 311 312 // Conduct the test. 313 MockStorageDelegate delegate; 314 EXPECT_EQ(size_t(1), storage->stored_caches_.size()); 315 EXPECT_EQ(size_t(1), storage->stored_groups_.size()); 316 EXPECT_TRUE(storage->IsCacheStored(cache.get())); 317 storage->StoreGroupAndNewestCache(group.get(), cache.get(), &delegate); 318 EXPECT_FALSE(delegate.stored_group_success_); 319 EXPECT_EQ(size_t(1), storage->stored_caches_.size()); 320 EXPECT_EQ(size_t(1), storage->stored_groups_.size()); 321 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 322 EXPECT_TRUE(delegate.stored_group_success_); 323 EXPECT_EQ(size_t(1), storage->stored_caches_.size()); 324 EXPECT_EQ(size_t(1), storage->stored_groups_.size()); 325 EXPECT_TRUE(storage->IsCacheStored(cache.get())); 326 EXPECT_EQ(cache, group->newest_complete_cache()); 327 EXPECT_TRUE(cache->GetEntry(entry_url)); 328 } 329 330 TEST_F(MockAppCacheStorageTest, MakeGroupObsolete) { 331 // Make a group obsolete, should complete asyncly. 332 MockAppCacheService service; 333 MockAppCacheStorage* storage = 334 reinterpret_cast<MockAppCacheStorage*>(service.storage()); 335 336 // Setup some preconditions. Create a group and newest cache that 337 // appears to be "stored" and "currently in use". 338 GURL manifest_url("http://blah/"); 339 scoped_refptr<AppCacheGroup> group( 340 new AppCacheGroup(service.storage(), manifest_url, 111)); 341 int64 cache_id = storage->NewCacheId(); 342 scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id)); 343 cache->set_complete(true); 344 group->AddCache(cache.get()); 345 storage->AddStoredGroup(group.get()); 346 storage->AddStoredCache(cache.get()); 347 // Hold our refs to simulate the UpdateJob holding these refs. 348 349 // Conduct the test. 350 MockStorageDelegate delegate; 351 EXPECT_FALSE(group->is_obsolete()); 352 EXPECT_EQ(size_t(1), storage->stored_caches_.size()); 353 EXPECT_EQ(size_t(1), storage->stored_groups_.size()); 354 EXPECT_FALSE(cache->HasOneRef()); 355 EXPECT_FALSE(group->HasOneRef()); 356 storage->MakeGroupObsolete(group.get(), &delegate); 357 EXPECT_FALSE(group->is_obsolete()); 358 EXPECT_EQ(size_t(1), storage->stored_caches_.size()); 359 EXPECT_EQ(size_t(1), storage->stored_groups_.size()); 360 EXPECT_FALSE(cache->HasOneRef()); 361 EXPECT_FALSE(group->HasOneRef()); 362 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 363 EXPECT_TRUE(delegate.obsoleted_success_); 364 EXPECT_EQ(group.get(), delegate.obsoleted_group_.get()); 365 EXPECT_TRUE(group->is_obsolete()); 366 EXPECT_TRUE(storage->stored_caches_.empty()); 367 EXPECT_TRUE(storage->stored_groups_.empty()); 368 EXPECT_TRUE(cache->HasOneRef()); 369 EXPECT_FALSE(group->HasOneRef()); 370 delegate.obsoleted_group_ = NULL; 371 cache = NULL; 372 EXPECT_TRUE(group->HasOneRef()); 373 } 374 375 TEST_F(MockAppCacheStorageTest, MarkEntryAsForeign) { 376 // Should complete syncly. 377 MockAppCacheService service; 378 MockAppCacheStorage* storage = 379 reinterpret_cast<MockAppCacheStorage*>(service.storage()); 380 381 // Setup some preconditions. Create a cache with an entry. 382 GURL entry_url("http://blah/entry"); 383 int64 cache_id = storage->NewCacheId(); 384 scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id)); 385 cache->AddEntry(entry_url, AppCacheEntry(AppCacheEntry::EXPLICIT)); 386 387 // Conduct the test. 388 MockStorageDelegate delegate; 389 EXPECT_FALSE(cache->GetEntry(entry_url)->IsForeign()); 390 storage->MarkEntryAsForeign(entry_url, cache_id); 391 EXPECT_TRUE(cache->GetEntry(entry_url)->IsForeign()); 392 EXPECT_TRUE(cache->GetEntry(entry_url)->IsExplicit()); 393 } 394 395 TEST_F(MockAppCacheStorageTest, FindNoMainResponse) { 396 // Should complete asyncly. 397 MockAppCacheService service; 398 MockAppCacheStorage* storage = 399 reinterpret_cast<MockAppCacheStorage*>(service.storage()); 400 401 // Conduct the test. 402 MockStorageDelegate delegate; 403 GURL url("http://blah/some_url"); 404 EXPECT_NE(url, delegate.found_url_); 405 storage->FindResponseForMainRequest(url, GURL(), &delegate); 406 EXPECT_NE(url, delegate.found_url_); 407 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 408 EXPECT_EQ(url, delegate.found_url_); 409 EXPECT_TRUE(delegate.found_manifest_url_.is_empty()); 410 EXPECT_EQ(kNoCacheId, delegate.found_cache_id_); 411 EXPECT_EQ(kNoResponseId, delegate.found_entry_.response_id()); 412 EXPECT_EQ(kNoResponseId, delegate.found_fallback_entry_.response_id()); 413 EXPECT_TRUE(delegate.found_fallback_url_.is_empty()); 414 EXPECT_EQ(0, delegate.found_entry_.types()); 415 EXPECT_EQ(0, delegate.found_fallback_entry_.types()); 416 } 417 418 TEST_F(MockAppCacheStorageTest, BasicFindMainResponse) { 419 // Should complete asyncly. 420 MockAppCacheService service; 421 MockAppCacheStorage* storage = 422 reinterpret_cast<MockAppCacheStorage*>(service.storage()); 423 424 // Setup some preconditions. Create a complete cache with an entry. 425 const int64 kCacheId = storage->NewCacheId(); 426 const GURL kEntryUrl("http://blah/entry"); 427 const GURL kManifestUrl("http://blah/manifest"); 428 const int64 kResponseId = 1; 429 scoped_refptr<AppCache> cache(new AppCache(service.storage(), kCacheId)); 430 cache->AddEntry( 431 kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, kResponseId)); 432 cache->set_complete(true); 433 scoped_refptr<AppCacheGroup> group( 434 new AppCacheGroup(service.storage(), kManifestUrl, 111)); 435 group->AddCache(cache.get()); 436 storage->AddStoredGroup(group.get()); 437 storage->AddStoredCache(cache.get()); 438 439 // Conduct the test. 440 MockStorageDelegate delegate; 441 EXPECT_NE(kEntryUrl, delegate.found_url_); 442 storage->FindResponseForMainRequest(kEntryUrl, GURL(), &delegate); 443 EXPECT_NE(kEntryUrl, delegate.found_url_); 444 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 445 EXPECT_EQ(kEntryUrl, delegate.found_url_); 446 EXPECT_EQ(kManifestUrl, delegate.found_manifest_url_); 447 EXPECT_EQ(kCacheId, delegate.found_cache_id_); 448 EXPECT_EQ(kResponseId, delegate.found_entry_.response_id()); 449 EXPECT_TRUE(delegate.found_entry_.IsExplicit()); 450 EXPECT_FALSE(delegate.found_fallback_entry_.has_response_id()); 451 } 452 453 TEST_F(MockAppCacheStorageTest, BasicFindMainFallbackResponse) { 454 // Should complete asyncly. 455 MockAppCacheService service; 456 MockAppCacheStorage* storage = 457 reinterpret_cast<MockAppCacheStorage*>(service.storage()); 458 459 // Setup some preconditions. Create a complete cache with a 460 // fallback namespace and entry. 461 const int64 kCacheId = storage->NewCacheId(); 462 const GURL kFallbackEntryUrl1("http://blah/fallback_entry1"); 463 const GURL kFallbackNamespaceUrl1("http://blah/fallback_namespace/"); 464 const GURL kFallbackEntryUrl2("http://blah/fallback_entry2"); 465 const GURL kFallbackNamespaceUrl2("http://blah/fallback_namespace/longer"); 466 const GURL kManifestUrl("http://blah/manifest"); 467 const int64 kResponseId1 = 1; 468 const int64 kResponseId2 = 2; 469 470 Manifest manifest; 471 manifest.fallback_namespaces.push_back( 472 Namespace(FALLBACK_NAMESPACE, kFallbackNamespaceUrl1, 473 kFallbackEntryUrl1, false)); 474 manifest.fallback_namespaces.push_back( 475 Namespace(FALLBACK_NAMESPACE, kFallbackNamespaceUrl2, 476 kFallbackEntryUrl2, false)); 477 478 scoped_refptr<AppCache> cache(new AppCache(service.storage(), kCacheId)); 479 cache->InitializeWithManifest(&manifest); 480 cache->AddEntry(kFallbackEntryUrl1, 481 AppCacheEntry(AppCacheEntry::FALLBACK, kResponseId1)); 482 cache->AddEntry(kFallbackEntryUrl2, 483 AppCacheEntry(AppCacheEntry::FALLBACK, kResponseId2)); 484 cache->set_complete(true); 485 486 scoped_refptr<AppCacheGroup> group( 487 new AppCacheGroup(service.storage(), kManifestUrl, 111)); 488 group->AddCache(cache.get()); 489 storage->AddStoredGroup(group.get()); 490 storage->AddStoredCache(cache.get()); 491 492 // The test url is in both fallback namespace urls, but should match 493 // the longer of the two. 494 const GURL kTestUrl("http://blah/fallback_namespace/longer/test"); 495 496 // Conduct the test. 497 MockStorageDelegate delegate; 498 EXPECT_NE(kTestUrl, delegate.found_url_); 499 storage->FindResponseForMainRequest(kTestUrl, GURL(), &delegate); 500 EXPECT_NE(kTestUrl, delegate.found_url_); 501 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 502 EXPECT_EQ(kTestUrl, delegate.found_url_); 503 EXPECT_EQ(kManifestUrl, delegate.found_manifest_url_); 504 EXPECT_EQ(kCacheId, delegate.found_cache_id_); 505 EXPECT_FALSE(delegate.found_entry_.has_response_id()); 506 EXPECT_EQ(kResponseId2, delegate.found_fallback_entry_.response_id()); 507 EXPECT_EQ(kFallbackEntryUrl2, delegate.found_fallback_url_); 508 EXPECT_TRUE(delegate.found_fallback_entry_.IsFallback()); 509 } 510 511 TEST_F(MockAppCacheStorageTest, FindMainResponseWithMultipleCandidates) { 512 // Should complete asyncly. 513 MockAppCacheService service; 514 MockAppCacheStorage* storage = 515 reinterpret_cast<MockAppCacheStorage*>(service.storage()); 516 517 // Setup some preconditions. Create 2 complete caches with an entry 518 // for the same url. 519 520 const GURL kEntryUrl("http://blah/entry"); 521 const int64 kCacheId1 = storage->NewCacheId(); 522 const int64 kCacheId2 = storage->NewCacheId(); 523 const GURL kManifestUrl1("http://blah/manifest1"); 524 const GURL kManifestUrl2("http://blah/manifest2"); 525 const int64 kResponseId1 = 1; 526 const int64 kResponseId2 = 2; 527 528 // The first cache. 529 scoped_refptr<AppCache> cache(new AppCache(service.storage(), kCacheId1)); 530 cache->AddEntry( 531 kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, kResponseId1)); 532 cache->set_complete(true); 533 scoped_refptr<AppCacheGroup> group( 534 new AppCacheGroup(service.storage(), kManifestUrl1, 111)); 535 group->AddCache(cache.get()); 536 storage->AddStoredGroup(group.get()); 537 storage->AddStoredCache(cache.get()); 538 // Drop our references to cache1 so it appears as "not in use". 539 cache = NULL; 540 group = NULL; 541 542 // The second cache. 543 cache = new AppCache(service.storage(), kCacheId2); 544 cache->AddEntry( 545 kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, kResponseId2)); 546 cache->set_complete(true); 547 group = new AppCacheGroup(service.storage(), kManifestUrl2, 222); 548 group->AddCache(cache.get()); 549 storage->AddStoredGroup(group.get()); 550 storage->AddStoredCache(cache.get()); 551 552 // Conduct the test, we should find the response from the second cache 553 // since it's "in use". 554 MockStorageDelegate delegate; 555 EXPECT_NE(kEntryUrl, delegate.found_url_); 556 storage->FindResponseForMainRequest(kEntryUrl, GURL(), &delegate); 557 EXPECT_NE(kEntryUrl, delegate.found_url_); 558 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 559 EXPECT_EQ(kEntryUrl, delegate.found_url_); 560 EXPECT_EQ(kManifestUrl2, delegate.found_manifest_url_); 561 EXPECT_EQ(kCacheId2, delegate.found_cache_id_); 562 EXPECT_EQ(kResponseId2, delegate.found_entry_.response_id()); 563 EXPECT_TRUE(delegate.found_entry_.IsExplicit()); 564 EXPECT_FALSE(delegate.found_fallback_entry_.has_response_id()); 565 } 566 567 TEST_F(MockAppCacheStorageTest, FindMainResponseExclusions) { 568 // Should complete asyncly. 569 MockAppCacheService service; 570 MockAppCacheStorage* storage = 571 reinterpret_cast<MockAppCacheStorage*>(service.storage()); 572 573 // Setup some preconditions. Create a complete cache with a 574 // foreign entry and an online namespace. 575 576 const int64 kCacheId = storage->NewCacheId(); 577 const GURL kEntryUrl("http://blah/entry"); 578 const GURL kManifestUrl("http://blah/manifest"); 579 const GURL kOnlineNamespaceUrl("http://blah/online_namespace"); 580 const int64 kResponseId = 1; 581 582 Manifest manifest; 583 manifest.online_whitelist_namespaces.push_back( 584 Namespace(NETWORK_NAMESPACE, kOnlineNamespaceUrl, 585 GURL(), false)); 586 scoped_refptr<AppCache> cache(new AppCache(service.storage(), kCacheId)); 587 cache->InitializeWithManifest(&manifest); 588 cache->AddEntry( 589 kEntryUrl, 590 AppCacheEntry(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN, 591 kResponseId)); 592 cache->set_complete(true); 593 scoped_refptr<AppCacheGroup> group( 594 new AppCacheGroup(service.storage(), kManifestUrl, 111)); 595 group->AddCache(cache.get()); 596 storage->AddStoredGroup(group.get()); 597 storage->AddStoredCache(cache.get()); 598 599 MockStorageDelegate delegate; 600 601 // We should not find anything for the foreign entry. 602 EXPECT_NE(kEntryUrl, delegate.found_url_); 603 storage->FindResponseForMainRequest(kEntryUrl, GURL(), &delegate); 604 EXPECT_NE(kEntryUrl, delegate.found_url_); 605 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 606 EXPECT_EQ(kEntryUrl, delegate.found_url_); 607 EXPECT_TRUE(delegate.found_manifest_url_.is_empty()); 608 EXPECT_EQ(kNoCacheId, delegate.found_cache_id_); 609 EXPECT_EQ(kNoResponseId, delegate.found_entry_.response_id()); 610 EXPECT_EQ(kNoResponseId, delegate.found_fallback_entry_.response_id()); 611 EXPECT_TRUE(delegate.found_fallback_url_.is_empty()); 612 EXPECT_EQ(0, delegate.found_entry_.types()); 613 EXPECT_EQ(0, delegate.found_fallback_entry_.types()); 614 615 // We should not find anything for the online namespace. 616 EXPECT_NE(kOnlineNamespaceUrl, delegate.found_url_); 617 storage->FindResponseForMainRequest(kOnlineNamespaceUrl, GURL(), &delegate); 618 EXPECT_NE(kOnlineNamespaceUrl, delegate.found_url_); 619 base::MessageLoop::current()->RunUntilIdle(); // Do async task execution. 620 EXPECT_EQ(kOnlineNamespaceUrl, delegate.found_url_); 621 EXPECT_TRUE(delegate.found_manifest_url_.is_empty()); 622 EXPECT_EQ(kNoCacheId, delegate.found_cache_id_); 623 EXPECT_EQ(kNoResponseId, delegate.found_entry_.response_id()); 624 EXPECT_EQ(kNoResponseId, delegate.found_fallback_entry_.response_id()); 625 EXPECT_TRUE(delegate.found_fallback_url_.is_empty()); 626 EXPECT_EQ(0, delegate.found_entry_.types()); 627 EXPECT_EQ(0, delegate.found_fallback_entry_.types()); 628 } 629 630 } // namespace appcache 631
