content/browser/appcache/mock_appcache_storage_unittest.cc

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