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