AppCache INTERCEPT namespace.

webkit/appcache/appcache_storage_impl_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stack>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/message_loop.h"
@@ skipping 18 matching lines @@
 const GURL kManifestUrl2("http://blah/manifest2");
 const GURL kManifestUrl3("http://blah/manifest3");
 const GURL kEntryUrl("http://blah/entry");
 const GURL kEntryUrl2("http://blah/entry2");
 const GURL kFallbackNamespace("http://blah/fallback_namespace/");
 const GURL kFallbackNamespace2("http://blah/fallback_namespace/longer");
 const GURL kFallbackTestUrl("http://blah/fallback_namespace/longer/test");
 const GURL kOnlineNamespace("http://blah/online_namespace");
 const GURL kOnlineNamespaceWithinFallback(
     "http://blah/fallback_namespace/online/");
+const GURL kInterceptNamespace("http://blah/intercept_namespace/");
+const GURL kInterceptNamespace2("http://blah/intercept_namespace/longer/");
+const GURL kInterceptTestUrl("http://blah/intercept_namespace/longer/test");
 const GURL kOrigin(kManifestUrl.GetOrigin());
 
 const int kManifestEntryIdOffset = 100;
 const int kFallbackEntryIdOffset = 1000;
 
 const GURL kDefaultEntryUrl("http://blah/makecacheandgroup_default_entry");
 const int kDefaultEntrySize = 10;
 const int kDefaultEntryIdOffset = 12345;
 
 const int kMockQuota = 5000;
@@ skipping 612 matching lines @@
     EXPECT_EQ(kDefaultEntrySize, storage()->usage_map_[kOrigin]);
 
     // Also insert some related records.
     AppCacheDatabase::EntryRecord entry_record;
     entry_record.cache_id = 1;
     entry_record.flags = AppCacheEntry::FALLBACK;
     entry_record.response_id = 1;
     entry_record.url = kEntryUrl;
     EXPECT_TRUE(database()->InsertEntry(&entry_record));
 
-    AppCacheDatabase::FallbackNameSpaceRecord fallback_namespace_record;
+    AppCacheDatabase::NamespaceRecord fallback_namespace_record;
     fallback_namespace_record.cache_id = 1;
-    fallback_namespace_record.fallback_entry_url = kEntryUrl;
+    fallback_namespace_record.target_url = kEntryUrl;
     fallback_namespace_record.namespace_url = kFallbackNamespace;
     fallback_namespace_record.origin = kManifestUrl.GetOrigin();
-    EXPECT_TRUE(
-        database()->InsertFallbackNameSpace(&fallback_namespace_record));
+    EXPECT_TRUE(database()->InsertNamespace(&fallback_namespace_record));
 
     AppCacheDatabase::OnlineWhiteListRecord online_whitelist_record;
     online_whitelist_record.cache_id = 1;
     online_whitelist_record.namespace_url = kOnlineNamespace;
     EXPECT_TRUE(database()->InsertOnlineWhiteList(&online_whitelist_record));
 
     // Conduct the test.
     storage()->MakeGroupObsolete(group_, delegate());
     EXPECT_FALSE(group_->is_obsolete());
   }
 
   void Verify_MakeGroupObsolete() {
     EXPECT_TRUE(delegate()->obsoleted_success_);
     EXPECT_EQ(group_.get(), delegate()->obsoleted_group_.get());
     EXPECT_TRUE(group_->is_obsolete());
     EXPECT_TRUE(storage()->usage_map_.empty());
 
     // The cache and group have been deleted from the database.
     AppCacheDatabase::GroupRecord group_record;
     AppCacheDatabase::CacheRecord cache_record;
     EXPECT_FALSE(database()->FindGroup(1, &group_record));
     EXPECT_FALSE(database()->FindCache(1, &cache_record));
 
     // The related records should have been deleted too.
     std::vector<AppCacheDatabase::EntryRecord> entry_records;
     database()->FindEntriesForCache(1, &entry_records);
     EXPECT_TRUE(entry_records.empty());
-    std::vector<AppCacheDatabase::FallbackNameSpaceRecord> fallback_records;
-    database()->FindFallbackNameSpacesForCache(1, &fallback_records);
+    std::vector<AppCacheDatabase::NamespaceRecord> intercept_records;
+    std::vector<AppCacheDatabase::NamespaceRecord> fallback_records;
+    database()->FindNamespacesForCache(
+        1, &intercept_records, &fallback_records);
     EXPECT_TRUE(fallback_records.empty());
     std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelist_records;
     database()->FindOnlineWhiteListForCache(1, &whitelist_records);
     EXPECT_TRUE(whitelist_records.empty());
 
     // Verify quota bookkeeping
     EXPECT_TRUE(storage()->usage_map_.empty());
     EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_modified_count_);
     EXPECT_EQ(kOrigin, mock_quota_manager_proxy_->last_origin_);
     EXPECT_EQ(-kDefaultEntrySize, mock_quota_manager_proxy_->last_delta_);
@@ skipping 165 matching lines @@
     PushNextTask(base::Bind(
         &AppCacheStorageImplTest::Verify_BasicFindMainFallbackResponse,
         base::Unretained(this)));
 
     // Setup some preconditions. Create a complete cache with a
     // fallback namespace and entry.
     MakeCacheAndGroup(kManifestUrl, 2, 1, true);
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::FALLBACK, 1));
     cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::FALLBACK, 2));
     cache_->fallback_namespaces_.push_back(
-        FallbackNamespace(kFallbackNamespace2, kEntryUrl2));
+        Namespace(FALLBACK_NAMESPACE, kFallbackNamespace2, kEntryUrl2));
     cache_->fallback_namespaces_.push_back(
-        FallbackNamespace(kFallbackNamespace, kEntryUrl));
+        Namespace(FALLBACK_NAMESPACE, kFallbackNamespace, kEntryUrl));
     AppCacheDatabase::CacheRecord cache_record;
     std::vector<AppCacheDatabase::EntryRecord> entries;
-    std::vector<AppCacheDatabase::FallbackNameSpaceRecord> fallbacks;
+    std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
+    std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
     std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
     cache_->ToDatabaseRecords(group_,
-        &cache_record, &entries, &fallbacks, &whitelists);
+        &cache_record, &entries, &intercepts, &fallbacks, &whitelists);
 
     std::vector<AppCacheDatabase::EntryRecord>::const_iterator iter =
         entries.begin();
     while (iter != entries.end()) {
       // MakeCacheAndGroup has inserted  the default entry record already
       if (iter->url != kDefaultEntryUrl)
         EXPECT_TRUE(database()->InsertEntry(&(*iter)));
       ++iter;
     }
 
-    EXPECT_TRUE(database()->InsertFallbackNameSpaceRecords(fallbacks));
+    EXPECT_TRUE(database()->InsertNamespaceRecords(fallbacks));
     EXPECT_TRUE(database()->InsertOnlineWhiteListRecords(whitelists));
     if (drop_from_working_set) {
       EXPECT_TRUE(cache_->HasOneRef());
       cache_ = NULL;
       EXPECT_TRUE(group_->HasOneRef());
       group_ = NULL;
     }
 
     // Conduct the test. The test url is in both fallback namespace urls,
     // but should match the longer of the two.
     storage()->FindResponseForMainRequest(kFallbackTestUrl, GURL(), delegate());
     EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
   }
 
   void Verify_BasicFindMainFallbackResponse() {
     EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
     EXPECT_EQ(1, delegate()->found_cache_id_);
     EXPECT_EQ(2, delegate()->found_group_id_);
     EXPECT_FALSE(delegate()->found_entry_.has_response_id());
     EXPECT_EQ(2, delegate()->found_fallback_entry_.response_id());
     EXPECT_EQ(kEntryUrl2, delegate()->found_fallback_url_);
     EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
     TestFinished();
   }
 
+  // BasicFindMainInterceptResponse  -------------------------------
+
+  void BasicFindMainInterceptResponseInDatabase() {
+    BasicFindMainInterceptResponse(true);
+  }
+
+  void BasicFindMainInterceptResponseInWorkingSet() {
+    BasicFindMainInterceptResponse(false);
+  }
+
+  void BasicFindMainInterceptResponse(bool drop_from_working_set) {
+    PushNextTask(base::Bind(
+        &AppCacheStorageImplTest::Verify_BasicFindMainInterceptResponse,
+        base::Unretained(this)));
+
+    // Setup some preconditions. Create a complete cache with an
+    // intercept namespace and entry.
+    MakeCacheAndGroup(kManifestUrl, 2, 1, true);
+    cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::INTERCEPT, 1));
+    cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::INTERCEPT, 2));
+    cache_->intercept_namespaces_.push_back(
+        Namespace(INTERCEPT_NAMESPACE, kInterceptNamespace2, kEntryUrl2));
+    cache_->intercept_namespaces_.push_back(
+        Namespace(INTERCEPT_NAMESPACE, kInterceptNamespace, kEntryUrl));
+    AppCacheDatabase::CacheRecord cache_record;
+    std::vector<AppCacheDatabase::EntryRecord> entries;
+    std::vector<AppCacheDatabase::NamespaceRecord> intercepts;
+    std::vector<AppCacheDatabase::NamespaceRecord> fallbacks;
+    std::vector<AppCacheDatabase::OnlineWhiteListRecord> whitelists;
+    cache_->ToDatabaseRecords(group_,
+        &cache_record, &entries, &intercepts, &fallbacks, &whitelists);
+
+    std::vector<AppCacheDatabase::EntryRecord>::const_iterator iter =
+        entries.begin();
+    while (iter != entries.end()) {
+      // MakeCacheAndGroup has inserted  the default entry record already

[jennb, 2011/12/13 00:33:09]

extra space in sentence

+      if (iter->url != kDefaultEntryUrl)
+        EXPECT_TRUE(database()->InsertEntry(&(*iter)));
+      ++iter;
+    }
+
+    EXPECT_TRUE(database()->InsertNamespaceRecords(intercepts));
+    EXPECT_TRUE(database()->InsertOnlineWhiteListRecords(whitelists));
+    if (drop_from_working_set) {
+      EXPECT_TRUE(cache_->HasOneRef());
+      cache_ = NULL;
+      EXPECT_TRUE(group_->HasOneRef());
+      group_ = NULL;
+    }
+
+    // Conduct the test. The test url is in both intercept namespaces,
+    // but should match the longer of the two.
+    storage()->FindResponseForMainRequest(
+        kInterceptTestUrl, GURL(), delegate());
+    EXPECT_NE(kInterceptTestUrl, delegate()->found_url_);
+  }
+
+  void Verify_BasicFindMainInterceptResponse() {
+    EXPECT_EQ(kInterceptTestUrl, delegate()->found_url_);
+    EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
+    EXPECT_EQ(1, delegate()->found_cache_id_);
+    EXPECT_EQ(2, delegate()->found_group_id_);
+    EXPECT_EQ(2, delegate()->found_entry_.response_id());
+    EXPECT_TRUE(delegate()->found_entry_.IsIntercept());
+    EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
+    TestFinished();
+  }
   // FindMainResponseWithMultipleHits  -------------------------------
 
   void FindMainResponseWithMultipleHits() {
     PushNextTask(base::Bind(
         &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits,
         base::Unretained(this)));
 
     // Setup some preconditions, create a few caches with an identical set
     // of entries and fallback namespaces. Only the last one remains in
     // the working set to simulate appearing as "in use".
@@ skipping 33 matching lines @@
 
     // Add a fallback entry and namespace
     entry_record.cache_id = id;
     entry_record.url = kEntryUrl2;
     entry_record.flags = AppCacheEntry::FALLBACK;
     entry_record.response_id = id + kFallbackEntryIdOffset;
     EXPECT_TRUE(database()->InsertEntry(&entry_record));
     cache_->AddEntry(
         entry_record.url,
         AppCacheEntry(entry_record.flags, entry_record.response_id));
-    AppCacheDatabase::FallbackNameSpaceRecord fallback_namespace_record;
+    AppCacheDatabase::NamespaceRecord fallback_namespace_record;
     fallback_namespace_record.cache_id = id;
-    fallback_namespace_record.fallback_entry_url = entry_record.url;
+    fallback_namespace_record.target_url = entry_record.url;
     fallback_namespace_record.namespace_url = kFallbackNamespace;
     fallback_namespace_record.origin = manifest_url.GetOrigin();
-    EXPECT_TRUE(
-        database()->InsertFallbackNameSpace(&fallback_namespace_record));
+    EXPECT_TRUE(database()->InsertNamespace(&fallback_namespace_record));
     cache_->fallback_namespaces_.push_back(
-        FallbackNamespace(kFallbackNamespace, kEntryUrl2));
+        Namespace(FALLBACK_NAMESPACE, kFallbackNamespace, kEntryUrl2));
   }
 
   void Verify_FindMainResponseWithMultipleHits() {
     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl3, delegate()->found_manifest_url_);
     EXPECT_EQ(3, delegate()->found_cache_id_);
     EXPECT_EQ(3, delegate()->found_group_id_);
     EXPECT_EQ(3, delegate()->found_entry_.response_id());
     EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
@@ skipping 92 matching lines @@
   void FindMainResponseExclusions(bool drop_from_working_set) {
     // Setup some preconditions. Create a complete cache with a
     // foreign entry, an online namespace, and a second online
     // namespace nested within a fallback namespace.
     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
     cache_->AddEntry(kEntryUrl,
         AppCacheEntry(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN, 1));
     cache_->online_whitelist_namespaces_.push_back(kOnlineNamespace);
     cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::FALLBACK, 2));
     cache_->fallback_namespaces_.push_back(
-        FallbackNamespace(kFallbackNamespace, kEntryUrl2));
+        Namespace(FALLBACK_NAMESPACE, kFallbackNamespace, kEntryUrl2));
     cache_->online_whitelist_namespaces_.push_back(kOnlineNamespace);
     cache_->online_whitelist_namespaces_.push_back(
         kOnlineNamespaceWithinFallback);
 
     AppCacheDatabase::EntryRecord entry_record;
     entry_record.cache_id = 1;
     entry_record.url = kEntryUrl;
     entry_record.flags = AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN;
     entry_record.response_id = 1;
     EXPECT_TRUE(database()->InsertEntry(&entry_record));
     AppCacheDatabase::OnlineWhiteListRecord whitelist_record;
     whitelist_record.cache_id = 1;
     whitelist_record.namespace_url = kOnlineNamespace;
     EXPECT_TRUE(database()->InsertOnlineWhiteList(&whitelist_record));
-    AppCacheDatabase::FallbackNameSpaceRecord fallback_namespace_record;
+    AppCacheDatabase::NamespaceRecord fallback_namespace_record;
     fallback_namespace_record.cache_id = 1;
-    fallback_namespace_record.fallback_entry_url = kEntryUrl2;
+    fallback_namespace_record.target_url = kEntryUrl2;
     fallback_namespace_record.namespace_url = kFallbackNamespace;
     fallback_namespace_record.origin = kManifestUrl.GetOrigin();
-    EXPECT_TRUE(
-        database()->InsertFallbackNameSpace(&fallback_namespace_record));
+    EXPECT_TRUE(database()->InsertNamespace(&fallback_namespace_record));
     whitelist_record.cache_id = 1;
     whitelist_record.namespace_url = kOnlineNamespaceWithinFallback;
     EXPECT_TRUE(database()->InsertOnlineWhiteList(&whitelist_record));
     if (drop_from_working_set) {
       cache_ = NULL;
       group_ = NULL;
     }
 
     // We should not find anything for the foreign entry.
     PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_ExclusionNotFound,
@@ skipping 169 matching lines @@
 TEST_F(AppCacheStorageImplTest, BasicFindMainFallbackResponseInDatabase) {
   RunTestOnIOThread(
       &AppCacheStorageImplTest::BasicFindMainFallbackResponseInDatabase);
 }
 
 TEST_F(AppCacheStorageImplTest, BasicFindMainFallbackResponseInWorkingSet) {
   RunTestOnIOThread(
       &AppCacheStorageImplTest::BasicFindMainFallbackResponseInWorkingSet);
 }
 
+TEST_F(AppCacheStorageImplTest, BasicFindMainInterceptResponseInDatabase) {
+  RunTestOnIOThread(
+      &AppCacheStorageImplTest::BasicFindMainInterceptResponseInDatabase);
+}
+
+TEST_F(AppCacheStorageImplTest, BasicFindMainInterceptResponseInWorkingSet) {
+  RunTestOnIOThread(
+      &AppCacheStorageImplTest::BasicFindMainInterceptResponseInWorkingSet);
+}
+
 TEST_F(AppCacheStorageImplTest, FindMainResponseWithMultipleHits) {
   RunTestOnIOThread(
       &AppCacheStorageImplTest::FindMainResponseWithMultipleHits);
 }
 
 TEST_F(AppCacheStorageImplTest, FindMainResponseExclusionsInDatabase) {
   RunTestOnIOThread(
       &AppCacheStorageImplTest::FindMainResponseExclusionsInDatabase);
 }
 
 TEST_F(AppCacheStorageImplTest, FindMainResponseExclusionsInWorkingSet) {
   RunTestOnIOThread(
       &AppCacheStorageImplTest::FindMainResponseExclusionsInWorkingSet);
 }
 
 // That's all folks!
 
 }  // namespace appcache