Home | History | Annotate | Download | only in appcache 
      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 "content/browser/appcache/appcache.h"
      6 #include "content/browser/appcache/appcache_host.h"
      7 #include "content/browser/appcache/mock_appcache_service.h"
      8 #include "testing/gtest/include/gtest/gtest.h"
      9 
     10 namespace content {
     11 
     12 namespace {
     13 
     14 class MockAppCacheFrontend : public AppCacheFrontend {
     15  public:
     16   virtual void OnCacheSelected(int host_id, const AppCacheInfo& info) OVERRIDE {
     17   }
     18   virtual void OnStatusChanged(const std::vector<int>& host_ids,
     19                                AppCacheStatus status) OVERRIDE {}
     20   virtual void OnEventRaised(const std::vector<int>& host_ids,
     21                              AppCacheEventID event_id) OVERRIDE {}
     22   virtual void OnProgressEventRaised(
     23       const std::vector<int>& host_ids,
     24       const GURL& url,
     25       int num_total, int num_complete) OVERRIDE {}
     26   virtual void OnErrorEventRaised(
     27       const std::vector<int>& host_ids,
     28       const AppCacheErrorDetails& details) OVERRIDE {}
     29   virtual void OnLogMessage(int host_id, AppCacheLogLevel log_level,
     30                             const std::string& message) OVERRIDE {}
     31   virtual void OnContentBlocked(
     32       int host_id, const GURL& manifest_url) OVERRIDE {}
     33 };
     34 
     35 }  // namespace
     36 
     37 class AppCacheTest : public testing::Test {
     38 };
     39 
     40 TEST(AppCacheTest, CleanupUnusedCache) {
     41   MockAppCacheService service;
     42   MockAppCacheFrontend frontend;
     43   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 111));
     44   cache->set_complete(true);
     45   scoped_refptr<AppCacheGroup> group(
     46       new AppCacheGroup(service.storage(), GURL("http://blah/manifest"), 111));
     47   group->AddCache(cache.get());
     48 
     49   AppCacheHost host1(1, &frontend, &service);
     50   AppCacheHost host2(2, &frontend, &service);
     51 
     52   host1.AssociateCompleteCache(cache.get());
     53   host2.AssociateCompleteCache(cache.get());
     54 
     55   host1.AssociateNoCache(GURL());
     56   host2.AssociateNoCache(GURL());
     57 }
     58 
     59 TEST(AppCacheTest, AddModifyRemoveEntry) {
     60   MockAppCacheService service;
     61   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 111));
     62 
     63   EXPECT_TRUE(cache->entries().empty());
     64   EXPECT_EQ(0L, cache->cache_size());
     65 
     66   const GURL kFooUrl("http://foo.com");
     67   const int64 kFooResponseId = 1;
     68   const int64 kFooSize = 100;
     69   AppCacheEntry entry1(AppCacheEntry::MASTER, kFooResponseId, kFooSize);
     70   cache->AddEntry(kFooUrl, entry1);
     71   EXPECT_EQ(entry1.types(), cache->GetEntry(kFooUrl)->types());
     72   EXPECT_EQ(1UL, cache->entries().size());
     73   EXPECT_EQ(kFooSize, cache->cache_size());
     74 
     75   const GURL kBarUrl("http://bar.com");
     76   const int64 kBarResponseId = 2;
     77   const int64 kBarSize = 200;
     78   AppCacheEntry entry2(AppCacheEntry::FALLBACK, kBarResponseId, kBarSize);
     79   EXPECT_TRUE(cache->AddOrModifyEntry(kBarUrl, entry2));
     80   EXPECT_EQ(entry2.types(), cache->GetEntry(kBarUrl)->types());
     81   EXPECT_EQ(2UL, cache->entries().size());
     82   EXPECT_EQ(kFooSize + kBarSize, cache->cache_size());
     83 
     84   // Expected to return false when an existing entry is modified.
     85   AppCacheEntry entry3(AppCacheEntry::EXPLICIT);
     86   EXPECT_FALSE(cache->AddOrModifyEntry(kFooUrl, entry3));
     87   EXPECT_EQ((AppCacheEntry::MASTER | AppCacheEntry::EXPLICIT),
     88             cache->GetEntry(kFooUrl)->types());
     89   // Only the type should be modified.
     90   EXPECT_EQ(kFooResponseId, cache->GetEntry(kFooUrl)->response_id());
     91   EXPECT_EQ(kFooSize, cache->GetEntry(kFooUrl)->response_size());
     92   EXPECT_EQ(kFooSize + kBarSize, cache->cache_size());
     93 
     94   EXPECT_EQ(entry2.types(), cache->GetEntry(kBarUrl)->types());  // unchanged
     95 
     96   cache->RemoveEntry(kBarUrl);
     97   EXPECT_EQ(kFooSize, cache->cache_size());
     98   cache->RemoveEntry(kFooUrl);
     99   EXPECT_EQ(0L, cache->cache_size());
    100   EXPECT_TRUE(cache->entries().empty());
    101 }
    102 
    103 TEST(AppCacheTest, InitializeWithManifest) {
    104   MockAppCacheService service;
    105 
    106   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 1234));
    107   EXPECT_TRUE(cache->fallback_namespaces_.empty());
    108   EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
    109   EXPECT_FALSE(cache->online_whitelist_all_);
    110 
    111   AppCacheManifest manifest;
    112   manifest.explicit_urls.insert("http://one.com");
    113   manifest.explicit_urls.insert("http://two.com");
    114   manifest.fallback_namespaces.push_back(
    115       AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, GURL("http://fb1.com"),
    116                 GURL("http://fbone.com"), true));
    117   manifest.online_whitelist_namespaces.push_back(
    118       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, GURL("http://w1.com"),
    119           GURL(), false));
    120   manifest.online_whitelist_namespaces.push_back(
    121       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, GURL("http://w2.com"),
    122           GURL(), false));
    123   manifest.online_whitelist_all = true;
    124 
    125   cache->InitializeWithManifest(&manifest);
    126   const std::vector<AppCacheNamespace>& fallbacks =
    127       cache->fallback_namespaces_;
    128   size_t expected = 1;
    129   EXPECT_EQ(expected, fallbacks.size());
    130   EXPECT_EQ(GURL("http://fb1.com"), fallbacks[0].namespace_url);
    131   EXPECT_EQ(GURL("http://fbone.com"), fallbacks[0].target_url);
    132   EXPECT_TRUE(fallbacks[0].is_pattern);
    133   const AppCacheNamespaceVector& whitelist =
    134       cache->online_whitelist_namespaces_;
    135   expected = 2;
    136   EXPECT_EQ(expected, whitelist.size());
    137   EXPECT_EQ(GURL("http://w1.com"), whitelist[0].namespace_url);
    138   EXPECT_EQ(GURL("http://w2.com"), whitelist[1].namespace_url);
    139   EXPECT_TRUE(cache->online_whitelist_all_);
    140 
    141   // Ensure collections in manifest were taken over by the cache rather than
    142   // copied.
    143   EXPECT_TRUE(manifest.fallback_namespaces.empty());
    144   EXPECT_TRUE(manifest.online_whitelist_namespaces.empty());
    145 }
    146 
    147 TEST(AppCacheTest, FindResponseForRequest) {
    148   MockAppCacheService service;
    149 
    150   const GURL kOnlineNamespaceUrl("http://blah/online_namespace");
    151   const GURL kFallbackEntryUrl1("http://blah/fallback_entry1");
    152   const GURL kFallbackNamespaceUrl1("http://blah/fallback_namespace/");
    153   const GURL kFallbackEntryUrl2("http://blah/fallback_entry2");
    154   const GURL kFallbackNamespaceUrl2("http://blah/fallback_namespace/longer");
    155   const GURL kManifestUrl("http://blah/manifest");
    156   const GURL kForeignExplicitEntryUrl("http://blah/foreign");
    157   const GURL kInOnlineNamespaceUrl(
    158       "http://blah/online_namespace/network");
    159   const GURL kExplicitInOnlineNamespaceUrl(
    160       "http://blah/online_namespace/explicit");
    161   const GURL kFallbackTestUrl1("http://blah/fallback_namespace/1");
    162   const GURL kFallbackTestUrl2("http://blah/fallback_namespace/longer2");
    163   const GURL kInterceptNamespace("http://blah/intercept_namespace/");
    164   const GURL kInterceptNamespaceWithinFallback(
    165       "http://blah/fallback_namespace/intercept_namespace/");
    166   const GURL kInterceptNamespaceEntry("http://blah/intercept_entry");
    167   const GURL kOnlineNamespaceWithinOtherNamespaces(
    168       "http://blah/fallback_namespace/intercept_namespace/1/online");
    169 
    170   const int64 kFallbackResponseId1 = 1;
    171   const int64 kFallbackResponseId2 = 2;
    172   const int64 kManifestResponseId = 3;
    173   const int64 kForeignExplicitResponseId = 4;
    174   const int64 kExplicitInOnlineNamespaceResponseId = 5;
    175   const int64 kInterceptResponseId = 6;
    176 
    177   AppCacheManifest manifest;
    178   manifest.online_whitelist_namespaces.push_back(
    179       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, kOnlineNamespaceUrl,
    180           GURL(), false));
    181   manifest.online_whitelist_namespaces.push_back(
    182       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE,
    183           kOnlineNamespaceWithinOtherNamespaces, GURL(), false));
    184   manifest.fallback_namespaces.push_back(
    185       AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespaceUrl1,
    186           kFallbackEntryUrl1, false));
    187   manifest.fallback_namespaces.push_back(
    188       AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespaceUrl2,
    189           kFallbackEntryUrl2, false));
    190   manifest.intercept_namespaces.push_back(
    191       AppCacheNamespace(APPCACHE_INTERCEPT_NAMESPACE, kInterceptNamespace,
    192           kInterceptNamespaceEntry, false));
    193   manifest.intercept_namespaces.push_back(
    194       AppCacheNamespace(APPCACHE_INTERCEPT_NAMESPACE,
    195           kInterceptNamespaceWithinFallback, kInterceptNamespaceEntry, false));
    196 
    197   // Create a cache with some namespaces and entries.
    198   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 1234));
    199   cache->InitializeWithManifest(&manifest);
    200   cache->AddEntry(
    201       kFallbackEntryUrl1,
    202       AppCacheEntry(AppCacheEntry::FALLBACK, kFallbackResponseId1));
    203   cache->AddEntry(
    204       kFallbackEntryUrl2,
    205       AppCacheEntry(AppCacheEntry::FALLBACK, kFallbackResponseId2));
    206   cache->AddEntry(
    207       kManifestUrl,
    208       AppCacheEntry(AppCacheEntry::MANIFEST, kManifestResponseId));
    209   cache->AddEntry(
    210       kForeignExplicitEntryUrl,
    211       AppCacheEntry(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN,
    212                     kForeignExplicitResponseId));
    213   cache->AddEntry(
    214       kExplicitInOnlineNamespaceUrl,
    215       AppCacheEntry(AppCacheEntry::EXPLICIT,
    216                     kExplicitInOnlineNamespaceResponseId));
    217   cache->AddEntry(
    218       kInterceptNamespaceEntry,
    219       AppCacheEntry(AppCacheEntry::INTERCEPT, kInterceptResponseId));
    220   cache->set_complete(true);
    221 
    222   // See that we get expected results from FindResponseForRequest
    223 
    224   bool found = false;
    225   AppCacheEntry entry;
    226   AppCacheEntry fallback_entry;
    227   GURL intercept_namespace;
    228   GURL fallback_namespace;
    229   bool network_namespace = false;
    230 
    231   found = cache->FindResponseForRequest(GURL("http://blah/miss"),
    232       &entry, &intercept_namespace,
    233       &fallback_entry, &fallback_namespace,
    234       &network_namespace);
    235   EXPECT_FALSE(found);
    236 
    237   found = cache->FindResponseForRequest(kForeignExplicitEntryUrl,
    238       &entry, &intercept_namespace,
    239       &fallback_entry, &fallback_namespace,
    240       &network_namespace);
    241   EXPECT_TRUE(found);
    242   EXPECT_EQ(kForeignExplicitResponseId, entry.response_id());
    243   EXPECT_FALSE(fallback_entry.has_response_id());
    244   EXPECT_FALSE(network_namespace);
    245 
    246   entry = AppCacheEntry();  // reset
    247 
    248   found = cache->FindResponseForRequest(kManifestUrl,
    249       &entry, &intercept_namespace,
    250       &fallback_entry, &fallback_namespace,
    251       &network_namespace);
    252   EXPECT_TRUE(found);
    253   EXPECT_EQ(kManifestResponseId, entry.response_id());
    254   EXPECT_FALSE(fallback_entry.has_response_id());
    255   EXPECT_FALSE(network_namespace);
    256 
    257   entry = AppCacheEntry();  // reset
    258 
    259   found = cache->FindResponseForRequest(kInOnlineNamespaceUrl,
    260       &entry, &intercept_namespace,
    261       &fallback_entry, &fallback_namespace,
    262       &network_namespace);
    263   EXPECT_TRUE(found);
    264   EXPECT_FALSE(entry.has_response_id());
    265   EXPECT_FALSE(fallback_entry.has_response_id());
    266   EXPECT_TRUE(network_namespace);
    267 
    268   network_namespace = false;  // reset
    269 
    270   found = cache->FindResponseForRequest(kExplicitInOnlineNamespaceUrl,
    271       &entry, &intercept_namespace,
    272       &fallback_entry, &fallback_namespace,
    273       &network_namespace);
    274   EXPECT_TRUE(found);
    275   EXPECT_EQ(kExplicitInOnlineNamespaceResponseId, entry.response_id());
    276   EXPECT_FALSE(fallback_entry.has_response_id());
    277   EXPECT_FALSE(network_namespace);
    278 
    279   entry = AppCacheEntry();  // reset
    280 
    281   found = cache->FindResponseForRequest(kFallbackTestUrl1,
    282       &entry, &intercept_namespace,
    283       &fallback_entry, &fallback_namespace,
    284       &network_namespace);
    285   EXPECT_TRUE(found);
    286   EXPECT_FALSE(entry.has_response_id());
    287   EXPECT_EQ(kFallbackResponseId1, fallback_entry.response_id());
    288   EXPECT_EQ(kFallbackEntryUrl1,
    289             cache->GetFallbackEntryUrl(fallback_namespace));
    290   EXPECT_FALSE(network_namespace);
    291 
    292   fallback_entry = AppCacheEntry();  // reset
    293 
    294   found = cache->FindResponseForRequest(kFallbackTestUrl2,
    295       &entry, &intercept_namespace,
    296       &fallback_entry, &fallback_namespace,
    297       &network_namespace);
    298   EXPECT_TRUE(found);
    299   EXPECT_FALSE(entry.has_response_id());
    300   EXPECT_EQ(kFallbackResponseId2, fallback_entry.response_id());
    301   EXPECT_EQ(kFallbackEntryUrl2,
    302             cache->GetFallbackEntryUrl(fallback_namespace));
    303   EXPECT_FALSE(network_namespace);
    304 
    305   fallback_entry = AppCacheEntry();  // reset
    306 
    307   found = cache->FindResponseForRequest(kOnlineNamespaceWithinOtherNamespaces,
    308       &entry, &intercept_namespace,
    309       &fallback_entry, &fallback_namespace,
    310       &network_namespace);
    311   EXPECT_TRUE(found);
    312   EXPECT_FALSE(entry.has_response_id());
    313   EXPECT_FALSE(fallback_entry.has_response_id());
    314   EXPECT_TRUE(network_namespace);
    315 
    316   fallback_entry = AppCacheEntry();  // reset
    317 
    318   found = cache->FindResponseForRequest(
    319       kOnlineNamespaceWithinOtherNamespaces.Resolve("online_resource"),
    320       &entry, &intercept_namespace,
    321       &fallback_entry, &fallback_namespace,
    322       &network_namespace);
    323   EXPECT_TRUE(found);
    324   EXPECT_FALSE(entry.has_response_id());
    325   EXPECT_FALSE(fallback_entry.has_response_id());
    326   EXPECT_TRUE(network_namespace);
    327 
    328   fallback_namespace = GURL();
    329 
    330   found = cache->FindResponseForRequest(
    331       kInterceptNamespace.Resolve("intercept_me"),
    332       &entry, &intercept_namespace,
    333       &fallback_entry, &fallback_namespace,
    334       &network_namespace);
    335   EXPECT_TRUE(found);
    336   EXPECT_EQ(kInterceptResponseId, entry.response_id());
    337   EXPECT_EQ(kInterceptNamespaceEntry,
    338             cache->GetInterceptEntryUrl(intercept_namespace));
    339   EXPECT_FALSE(fallback_entry.has_response_id());
    340   EXPECT_TRUE(fallback_namespace.is_empty());
    341   EXPECT_FALSE(network_namespace);
    342 
    343   entry = AppCacheEntry();  // reset
    344 
    345   found = cache->FindResponseForRequest(
    346       kInterceptNamespaceWithinFallback.Resolve("intercept_me"),
    347       &entry, &intercept_namespace,
    348       &fallback_entry, &fallback_namespace,
    349       &network_namespace);
    350   EXPECT_TRUE(found);
    351   EXPECT_EQ(kInterceptResponseId, entry.response_id());
    352   EXPECT_EQ(kInterceptNamespaceEntry,
    353             cache->GetInterceptEntryUrl(intercept_namespace));
    354   EXPECT_FALSE(fallback_entry.has_response_id());
    355   EXPECT_TRUE(fallback_namespace.is_empty());
    356   EXPECT_FALSE(network_namespace);
    357 }
    358 
    359 TEST(AppCacheTest, FindInterceptPatternResponseForRequest) {
    360   MockAppCacheService service;
    361 
    362   // Setup an appcache with an intercept namespace that uses pattern matching.
    363   const GURL kInterceptNamespaceBase("http://blah/intercept_namespace/");
    364   const GURL kInterceptPatternNamespace(
    365       kInterceptNamespaceBase.Resolve("*.hit*"));
    366   const GURL kInterceptNamespaceEntry("http://blah/intercept_resource");
    367   const int64 kInterceptResponseId = 1;
    368   AppCacheManifest manifest;
    369   manifest.intercept_namespaces.push_back(
    370       AppCacheNamespace(APPCACHE_INTERCEPT_NAMESPACE,
    371           kInterceptPatternNamespace, kInterceptNamespaceEntry, true));
    372   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 1234));
    373   cache->InitializeWithManifest(&manifest);
    374   cache->AddEntry(
    375       kInterceptNamespaceEntry,
    376       AppCacheEntry(AppCacheEntry::INTERCEPT, kInterceptResponseId));
    377   cache->set_complete(true);
    378 
    379   // See that the pattern match works.
    380   bool found = false;
    381   AppCacheEntry entry;
    382   AppCacheEntry fallback_entry;
    383   GURL intercept_namespace;
    384   GURL fallback_namespace;
    385   bool network_namespace = false;
    386 
    387   found = cache->FindResponseForRequest(
    388       GURL("http://blah/miss"),
    389       &entry, &intercept_namespace,
    390       &fallback_entry, &fallback_namespace,
    391       &network_namespace);
    392   EXPECT_FALSE(found);
    393 
    394   found = cache->FindResponseForRequest(
    395       GURL("http://blah/intercept_namespace/another_miss"),
    396       &entry, &intercept_namespace,
    397       &fallback_entry, &fallback_namespace,
    398       &network_namespace);
    399   EXPECT_FALSE(found);
    400 
    401   found = cache->FindResponseForRequest(
    402       GURL("http://blah/intercept_namespace/path.hit"),
    403       &entry, &intercept_namespace,
    404       &fallback_entry, &fallback_namespace,
    405       &network_namespace);
    406   EXPECT_TRUE(found);
    407   EXPECT_EQ(kInterceptResponseId, entry.response_id());
    408   EXPECT_EQ(kInterceptNamespaceEntry,
    409             cache->GetInterceptEntryUrl(intercept_namespace));
    410   EXPECT_FALSE(fallback_entry.has_response_id());
    411   EXPECT_TRUE(fallback_namespace.is_empty());
    412   EXPECT_FALSE(network_namespace);
    413 
    414   entry = AppCacheEntry();  // reset
    415 
    416   found = cache->FindResponseForRequest(
    417       GURL("http://blah/intercept_namespace/longer/path.hit?arg=ok"),
    418       &entry, &intercept_namespace,
    419       &fallback_entry, &fallback_namespace,
    420       &network_namespace);
    421   EXPECT_TRUE(found);
    422   EXPECT_EQ(kInterceptResponseId, entry.response_id());
    423   EXPECT_EQ(kInterceptNamespaceEntry,
    424             cache->GetInterceptEntryUrl(intercept_namespace));
    425   EXPECT_FALSE(fallback_entry.has_response_id());
    426   EXPECT_TRUE(fallback_namespace.is_empty());
    427   EXPECT_FALSE(network_namespace);
    428 }
    429 
    430 TEST(AppCacheTest, FindFallbackPatternResponseForRequest) {
    431   MockAppCacheService service;
    432 
    433   // Setup an appcache with a fallback namespace that uses pattern matching.
    434   const GURL kFallbackNamespaceBase("http://blah/fallback_namespace/");
    435   const GURL kFallbackPatternNamespace(
    436       kFallbackNamespaceBase.Resolve("*.hit*"));
    437   const GURL kFallbackNamespaceEntry("http://blah/fallback_resource");
    438   const int64 kFallbackResponseId = 1;
    439   AppCacheManifest manifest;
    440   manifest.fallback_namespaces.push_back(
    441       AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, kFallbackPatternNamespace,
    442                 kFallbackNamespaceEntry, true));
    443   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 1234));
    444   cache->InitializeWithManifest(&manifest);
    445   cache->AddEntry(
    446       kFallbackNamespaceEntry,
    447       AppCacheEntry(AppCacheEntry::FALLBACK, kFallbackResponseId));
    448   cache->set_complete(true);
    449 
    450   // See that the pattern match works.
    451   bool found = false;
    452   AppCacheEntry entry;
    453   AppCacheEntry fallback_entry;
    454   GURL intercept_namespace;
    455   GURL fallback_namespace;
    456   bool network_namespace = false;
    457 
    458   found = cache->FindResponseForRequest(
    459       GURL("http://blah/miss"),
    460       &entry, &intercept_namespace,
    461       &fallback_entry, &fallback_namespace,
    462       &network_namespace);
    463   EXPECT_FALSE(found);
    464 
    465   found = cache->FindResponseForRequest(
    466       GURL("http://blah/fallback_namespace/another_miss"),
    467       &entry, &intercept_namespace,
    468       &fallback_entry, &fallback_namespace,
    469       &network_namespace);
    470   EXPECT_FALSE(found);
    471 
    472   found = cache->FindResponseForRequest(
    473       GURL("http://blah/fallback_namespace/path.hit"),
    474       &entry, &intercept_namespace,
    475       &fallback_entry, &fallback_namespace,
    476       &network_namespace);
    477   EXPECT_TRUE(found);
    478   EXPECT_FALSE(entry.has_response_id());
    479   EXPECT_EQ(kFallbackResponseId, fallback_entry.response_id());
    480   EXPECT_EQ(kFallbackNamespaceEntry,
    481             cache->GetFallbackEntryUrl(fallback_namespace));
    482   EXPECT_FALSE(network_namespace);
    483 
    484   fallback_entry = AppCacheEntry();
    485   fallback_namespace = GURL();
    486 
    487   found = cache->FindResponseForRequest(
    488       GURL("http://blah/fallback_namespace/longer/path.hit?arg=ok"),
    489       &entry, &intercept_namespace,
    490       &fallback_entry, &fallback_namespace,
    491       &network_namespace);
    492   EXPECT_TRUE(found);
    493   EXPECT_FALSE(entry.has_response_id());
    494   EXPECT_EQ(kFallbackResponseId, fallback_entry.response_id());
    495   EXPECT_EQ(kFallbackNamespaceEntry,
    496             cache->GetFallbackEntryUrl(fallback_namespace));
    497   EXPECT_TRUE(intercept_namespace.is_empty());
    498   EXPECT_FALSE(network_namespace);
    499 }
    500 
    501 
    502 TEST(AppCacheTest, FindNetworkNamespacePatternResponseForRequest) {
    503   MockAppCacheService service;
    504 
    505   // Setup an appcache with a network namespace that uses pattern matching.
    506   const GURL kNetworkNamespaceBase("http://blah/network_namespace/");
    507   const GURL kNetworkPatternNamespace(
    508       kNetworkNamespaceBase.Resolve("*.hit*"));
    509   AppCacheManifest manifest;
    510   manifest.online_whitelist_namespaces.push_back(
    511       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, kNetworkPatternNamespace,
    512                 GURL(), true));
    513   manifest.online_whitelist_all = false;
    514   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 1234));
    515   cache->InitializeWithManifest(&manifest);
    516   cache->set_complete(true);
    517 
    518   // See that the pattern match works.
    519   bool found = false;
    520   AppCacheEntry entry;
    521   AppCacheEntry fallback_entry;
    522   GURL intercept_namespace;
    523   GURL fallback_namespace;
    524   bool network_namespace = false;
    525 
    526   found = cache->FindResponseForRequest(
    527       GURL("http://blah/miss"),
    528       &entry, &intercept_namespace,
    529       &fallback_entry, &fallback_namespace,
    530       &network_namespace);
    531   EXPECT_FALSE(found);
    532 
    533   found = cache->FindResponseForRequest(
    534       GURL("http://blah/network_namespace/path.hit"),
    535       &entry, &intercept_namespace,
    536       &fallback_entry, &fallback_namespace,
    537       &network_namespace);
    538   EXPECT_TRUE(found);
    539   EXPECT_TRUE(network_namespace);
    540   EXPECT_FALSE(entry.has_response_id());
    541   EXPECT_FALSE(fallback_entry.has_response_id());
    542 }
    543 
    544 TEST(AppCacheTest, ToFromDatabaseRecords) {
    545   // Setup a cache with some entries.
    546   const int64 kCacheId = 1234;
    547   const int64 kGroupId = 4321;
    548   const GURL kManifestUrl("http://foo.com/manifest");
    549   const GURL kInterceptUrl("http://foo.com/intercept.html");
    550   const GURL kFallbackUrl("http://foo.com/fallback.html");
    551   const GURL kWhitelistUrl("http://foo.com/whitelist*");
    552   const std::string kData(
    553     "CACHE MANIFEST\r"
    554     "CHROMIUM-INTERCEPT:\r"
    555     "/intercept return /intercept.html\r"
    556     "FALLBACK:\r"
    557     "/ /fallback.html\r"
    558     "NETWORK:\r"
    559     "/whitelist* isPattern\r"
    560     "*\r");
    561   MockAppCacheService service;
    562   scoped_refptr<AppCacheGroup> group =
    563       new AppCacheGroup(service.storage(), kManifestUrl, kGroupId);
    564   scoped_refptr<AppCache> cache(new AppCache(service.storage(), kCacheId));
    565   AppCacheManifest manifest;
    566   EXPECT_TRUE(ParseManifest(kManifestUrl, kData.c_str(), kData.length(),
    567                             PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest));
    568   cache->InitializeWithManifest(&manifest);
    569   EXPECT_EQ(APPCACHE_NETWORK_NAMESPACE,
    570             cache->online_whitelist_namespaces_[0].type);
    571   EXPECT_TRUE(cache->online_whitelist_namespaces_[0].is_pattern);
    572   EXPECT_EQ(kWhitelistUrl,
    573             cache->online_whitelist_namespaces_[0].namespace_url);
    574   cache->AddEntry(
    575       kManifestUrl,
    576       AppCacheEntry(AppCacheEntry::MANIFEST, 1, 1));
    577   cache->AddEntry(
    578       kInterceptUrl,
    579       AppCacheEntry(AppCacheEntry::INTERCEPT, 3, 3));
    580   cache->AddEntry(
    581       kFallbackUrl,
    582       AppCacheEntry(AppCacheEntry::FALLBACK, 2, 2));
    583 
    584   // Get it to produce database records and verify them.
    585   AppCacheDatabase::CacheRecord cache_record;
    586   std::vector<AppCacheDatabase::EntryRecord> entries;
    587   std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
    588   std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
    589   std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
    590   cache->ToDatabaseRecords(group.get(),
    591                            &cache_record,
    592                            &entries,
    593                            &intercepts,
    594                            &fallbacks,
    595                            &whitelists);
    596   EXPECT_EQ(kCacheId, cache_record.cache_id);
    597   EXPECT_EQ(kGroupId, cache_record.group_id);
    598   EXPECT_TRUE(cache_record.online_wildcard);
    599   EXPECT_EQ(1 + 2 + 3, cache_record.cache_size);
    600   EXPECT_EQ(3u, entries.size());
    601   EXPECT_EQ(1u, intercepts.size());
    602   EXPECT_EQ(1u, fallbacks.size());
    603   EXPECT_EQ(1u, whitelists.size());
    604   cache = NULL;
    605 
    606   // Create a new AppCache and populate it with those records and verify.
    607   cache = new AppCache(service.storage(), kCacheId);
    608   cache->InitializeWithDatabaseRecords(
    609       cache_record, entries, intercepts,
    610       fallbacks, whitelists);
    611   EXPECT_TRUE(cache->online_whitelist_all_);
    612   EXPECT_EQ(3u, cache->entries().size());
    613   EXPECT_TRUE(cache->GetEntry(kManifestUrl));
    614   EXPECT_TRUE(cache->GetEntry(kInterceptUrl));
    615   EXPECT_TRUE(cache->GetEntry(kFallbackUrl));
    616   EXPECT_EQ(kInterceptUrl,
    617             cache->GetInterceptEntryUrl(GURL("http://foo.com/intercept")));
    618   EXPECT_EQ(kFallbackUrl,
    619             cache->GetFallbackEntryUrl(GURL("http://foo.com/")));
    620   EXPECT_EQ(1 + 2 + 3, cache->cache_size());
    621   EXPECT_EQ(APPCACHE_NETWORK_NAMESPACE,
    622             cache->online_whitelist_namespaces_[0].type);
    623   EXPECT_TRUE(cache->online_whitelist_namespaces_[0].is_pattern);
    624   EXPECT_EQ(kWhitelistUrl,
    625             cache->online_whitelist_namespaces_[0].namespace_url);
    626 }
    627 
    628 TEST(AppCacheTest, IsNamespaceMatch) {
    629   AppCacheNamespace prefix;
    630   prefix.namespace_url = GURL("http://foo.com/prefix");
    631   prefix.is_pattern = false;
    632   EXPECT_TRUE(prefix.IsMatch(
    633       GURL("http://foo.com/prefix_and_anothing_goes")));
    634   EXPECT_FALSE(prefix.IsMatch(
    635       GURL("http://foo.com/nope")));
    636 
    637   AppCacheNamespace bar_no_star;
    638   bar_no_star.namespace_url = GURL("http://foo.com/bar");
    639   bar_no_star.is_pattern = true;
    640   EXPECT_TRUE(bar_no_star.IsMatch(
    641       GURL("http://foo.com/bar")));
    642   EXPECT_FALSE(bar_no_star.IsMatch(
    643       GURL("http://foo.com/bar/nope")));
    644 
    645   AppCacheNamespace bar_star;
    646   bar_star.namespace_url = GURL("http://foo.com/bar/*");
    647   bar_star.is_pattern = true;
    648   EXPECT_TRUE(bar_star.IsMatch(
    649       GURL("http://foo.com/bar/")));
    650   EXPECT_TRUE(bar_star.IsMatch(
    651       GURL("http://foo.com/bar/should_match")));
    652   EXPECT_FALSE(bar_star.IsMatch(
    653       GURL("http://foo.com/not_bar/should_not_match")));
    654 
    655   AppCacheNamespace star_bar_star;
    656   star_bar_star.namespace_url = GURL("http://foo.com/*/bar/*");
    657   star_bar_star.is_pattern = true;
    658   EXPECT_TRUE(star_bar_star.IsMatch(
    659       GURL("http://foo.com/any/bar/should_match")));
    660   EXPECT_TRUE(star_bar_star.IsMatch(
    661       GURL("http://foo.com/any/bar/")));
    662   EXPECT_FALSE(star_bar_star.IsMatch(
    663       GURL("http://foo.com/any/not_bar/no_match")));
    664 
    665   AppCacheNamespace query_star_edit;
    666   query_star_edit.namespace_url = GURL("http://foo.com/query?id=*&verb=edit*");
    667   query_star_edit.is_pattern = true;
    668   EXPECT_TRUE(query_star_edit.IsMatch(
    669       GURL("http://foo.com/query?id=1234&verb=edit&option=blue")));
    670   EXPECT_TRUE(query_star_edit.IsMatch(
    671       GURL("http://foo.com/query?id=12345&option=blue&verb=edit")));
    672   EXPECT_FALSE(query_star_edit.IsMatch(
    673       GURL("http://foo.com/query?id=12345&option=blue&verb=print")));
    674   EXPECT_TRUE(query_star_edit.IsMatch(
    675       GURL("http://foo.com/query?id=123&verb=print&verb=edit")));
    676 
    677   AppCacheNamespace star_greediness;
    678   star_greediness.namespace_url = GURL("http://foo.com/*/b");
    679   star_greediness.is_pattern = true;
    680   EXPECT_TRUE(star_greediness.IsMatch(
    681       GURL("http://foo.com/a/b")));
    682   EXPECT_TRUE(star_greediness.IsMatch(
    683       GURL("http://foo.com/a/wxy/z/b")));
    684   EXPECT_TRUE(star_greediness.IsMatch(
    685       GURL("http://foo.com/a/b/b")));
    686   EXPECT_TRUE(star_greediness.IsMatch(
    687       GURL("http://foo.com/b/b")));
    688   EXPECT_TRUE(star_greediness.IsMatch(
    689       GURL("http://foo.com/a/b/b/b/b/b")));
    690   EXPECT_TRUE(star_greediness.IsMatch(
    691       GURL("http://foo.com/a/b/b/b/a/b")));
    692   EXPECT_TRUE(star_greediness.IsMatch(
    693       GURL("http://foo.com/a/b/01234567890abcdef/b")));
    694   EXPECT_TRUE(star_greediness.IsMatch(
    695       GURL("http://foo.com/a/b/01234567890abcdef/b01234567890abcdef/b")));
    696   EXPECT_TRUE(star_greediness.IsMatch(
    697       GURL("http://foo.com/a/b/01234567890abcdef_eat_some_more_characters_"
    698            "/and_even_more_for_the_heck_of_it/01234567890abcdef/b")));
    699 }
    700 
    701 }  // namespace content
    702