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 650 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.
@@ skipping 59 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 187 matching lines @@
 }
 
 TEST_F(AppCacheStorageImplTest, FindMainResponseExclusionsInWorkingSet) {
   RunTestOnIOThread(
       &AppCacheStorageImplTest::FindMainResponseExclusionsInWorkingSet);
 }
 
 // That's all folks!
 
 }  // namespace appcache