Select a more appropiate appcache based on the opener or the parent of the new document.

webkit/appcache/appcache_storage_impl_unittest.cc

Index: webkit/appcache/appcache_storage_impl_unittest.cc
===================================================================
--- webkit/appcache/appcache_storage_impl_unittest.cc	(revision 80669)
+++ webkit/appcache/appcache_storage_impl_unittest.cc	(working copy)
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -25,6 +25,7 @@
 const base::Time kZeroTime;
 const GURL kManifestUrl("http://blah/manifest");
 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/");
@@ -34,6 +35,9 @@
 const GURL kOnlineNamespaceWithinFallback(
     "http://blah/fallback_namespace/online/");
 
+const int kManifestEntryIdOffset = 100;
+const int kFallbackEntryIdOffset = 1000;
+
 // For the duration of this test case, we hijack the AppCacheThread API
 // calls and implement them in terms of the io and db threads created here.
 
@@ -723,7 +727,7 @@
        this, &AppCacheStorageImplTest::Verify_FindNoMainResponse));
 
     // Conduct the test.
-    storage()->FindResponseForMainRequest(kEntryUrl, delegate());
+    storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
     EXPECT_NE(kEntryUrl, delegate()->found_url_);
   }
 
@@ -783,7 +787,7 @@
     }
 
     // Conduct the test.
-    storage()->FindResponseForMainRequest(kEntryUrl, delegate());
+    storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
     EXPECT_NE(kEntryUrl,  delegate()->found_url_);
   }
 
@@ -844,7 +848,7 @@
 
     // Conduct the test. The test url is in both fallback namespace urls,
     // but should match the longer of the two.
-    storage()->FindResponseForMainRequest(kFallbackTestUrl, delegate());
+    storage()->FindResponseForMainRequest(kFallbackTestUrl, GURL(), delegate());
     EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
   }
 
@@ -866,44 +870,146 @@
     PushNextTask(NewRunnableMethod(this,
         &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits));
 
-    // Setup some preconditions. Create 2 complete caches with an entry
-    // for the same url.
+    // 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 similulate appearing as "in use".

[jennb, 2011/04/12 00:07:56]

simulate

[michaeln, 2011/04/14 23:41:23]

Done.

+    MakeMultipleHitCacheAndGroup(kManifestUrl, 1);
+    MakeMultipleHitCacheAndGroup(kManifestUrl2, 2);
+    MakeMultipleHitCacheAndGroup(kManifestUrl3, 3);

[jennb, 2011/04/12 00:07:56]

What logic ensures that only this one remains in the working set?

[michaeln, 2011/04/14 23:41:23]

The helper methods stores a ref to the cache_ and group_ in a data member. Only
the last created has that ref applied since each successive call to the method
overwrites the previous methods results in those data members, So the only one
left in memory (ala in the working set) is the last one.

 
-    // The first cache, in the database but not in the working set.
-    MakeCacheAndGroup(kManifestUrl, 1, 1, true);
-    cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, 1));
+    // Conduct the test, we should find the response from the last cache
+    // since it's "in use".
+    storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
+    EXPECT_NE(kEntryUrl, delegate()->found_url_);
+  }
+
+  void MakeMultipleHitCacheAndGroup(const GURL& manifest_url, int id) {
+    MakeCacheAndGroup(manifest_url, id, id, true);
     AppCacheDatabase::EntryRecord entry_record;
-    entry_record.cache_id = 1;
+
+    // Add and entry for kEntryUrl

[jennb, 2011/04/12 00:07:56]

Add an entry

[michaeln, 2011/04/14 23:41:23]

Done.

+    entry_record.cache_id = id;
     entry_record.url = kEntryUrl;
     entry_record.flags = AppCacheEntry::EXPLICIT;
-    entry_record.response_id = 1;
+    entry_record.response_id = id;
     EXPECT_TRUE(database()->InsertEntry(&entry_record));
-    cache_ = NULL;
-    group_ = NULL;
+    cache_->AddEntry(
+        entry_record.url,
+        AppCacheEntry(entry_record.flags, entry_record.response_id));
 
-    // The second cache, in the database and working set.
-    MakeCacheAndGroup(kManifestUrl2, 2, 2, true);
-    cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, 2));
-    entry_record.cache_id = 2;
-    entry_record.url = kEntryUrl;
-    entry_record.flags = AppCacheEntry::EXPLICIT;
-    entry_record.response_id = 2;
+    // Add and entry for the manifestUrl

[jennb, 2011/04/12 00:07:56]

Add an entry

[michaeln, 2011/04/14 23:41:23]

Done.

+    entry_record.cache_id = id;
+    entry_record.url = manifest_url;
+    entry_record.flags = AppCacheEntry::MANIFEST;
+    entry_record.response_id = id + kManifestEntryIdOffset;
     EXPECT_TRUE(database()->InsertEntry(&entry_record));
+    cache_->AddEntry(
+        entry_record.url,
+        AppCacheEntry(entry_record.flags, entry_record.response_id));
 
-    // Conduct the test, we should find the response from the second cache
-    // since it's "in use".
-    storage()->FindResponseForMainRequest(kEntryUrl, delegate());
-    EXPECT_NE(kEntryUrl, delegate()->found_url_);
+    // 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;
+    fallback_namespace_record.cache_id = id;
+    fallback_namespace_record.fallback_entry_url = entry_record.url;
+    fallback_namespace_record.namespace_url = kFallbackNamespace;
+    fallback_namespace_record.origin = manifest_url.GetOrigin();
+    EXPECT_TRUE(
+        database()->InsertFallbackNameSpace(&fallback_namespace_record));
+    cache_->fallback_namespaces_.push_back(
+        FallbackNamespace(kFallbackNamespace, kEntryUrl2));
   }
 
   void Verify_FindMainResponseWithMultipleHits() {
     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
+    EXPECT_EQ(kManifestUrl3, delegate()->found_manifest_url_);
+    EXPECT_FALSE(delegate()->found_blocked_by_policy_);
+    EXPECT_EQ(3, delegate()->found_cache_id_);
+    EXPECT_EQ(3, delegate()->found_entry_.response_id());
+    EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
+    EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
+
+    // Conduct the another test perferring kManifestUrl

[jennb, 2011/04/12 00:07:56]

Conduct another test

[michaeln, 2011/04/14 23:41:23]

Done.

+    delegate_.reset(new MockStorageDelegate(this));
+    PushNextTask(NewRunnableMethod(this,
+        &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits2));
+    storage()->FindResponseForMainRequest(kEntryUrl, kManifestUrl, delegate());
+    EXPECT_NE(kEntryUrl, delegate()->found_url_);
+  }
+
+  void Verify_FindMainResponseWithMultipleHits2() {
+    EXPECT_EQ(kEntryUrl, delegate()->found_url_);
+    EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
+    EXPECT_FALSE(delegate()->found_blocked_by_policy_);
+    EXPECT_EQ(1, delegate()->found_cache_id_);
+    EXPECT_EQ(1, delegate()->found_entry_.response_id());
+    EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
+    EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
+
+    // Conduct the another test perferring kManifestUrl2
+    delegate_.reset(new MockStorageDelegate(this));
+    PushNextTask(NewRunnableMethod(this,
+        &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits3));
+    storage()->FindResponseForMainRequest(kEntryUrl, kManifestUrl2, delegate());
+    EXPECT_NE(kEntryUrl, delegate()->found_url_);
+  }
+
+  void Verify_FindMainResponseWithMultipleHits3() {
+    EXPECT_EQ(kEntryUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl2, delegate()->found_manifest_url_);
     EXPECT_FALSE(delegate()->found_blocked_by_policy_);
     EXPECT_EQ(2, delegate()->found_cache_id_);
     EXPECT_EQ(2, delegate()->found_entry_.response_id());
     EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
+
+    // Conduct another test with no preferred manifest that hits the fallback.
+    delegate_.reset(new MockStorageDelegate(this));
+    PushNextTask(NewRunnableMethod(this,
+        &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits4));
+    storage()->FindResponseForMainRequest(
+        kFallbackTestUrl, GURL(), delegate());
+    EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
+  }
+
+  void Verify_FindMainResponseWithMultipleHits4() {
+    EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
+    EXPECT_EQ(kManifestUrl3, delegate()->found_manifest_url_);
+    EXPECT_FALSE(delegate()->found_blocked_by_policy_);
+    EXPECT_EQ(3, delegate()->found_cache_id_);
+    EXPECT_FALSE(delegate()->found_entry_.has_response_id());
+    EXPECT_EQ(3 + kFallbackEntryIdOffset,
+              delegate()->found_fallback_entry_.response_id());
+    EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
+    EXPECT_EQ(kEntryUrl2, delegate()->found_fallback_url_);
+
+    // Conduct another test preferring kManifestUrl2 that hits the fallback.
+    delegate_.reset(new MockStorageDelegate(this));
+    PushNextTask(NewRunnableMethod(this,
+        &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits5));
+    storage()->FindResponseForMainRequest(
+        kFallbackTestUrl, kManifestUrl2, delegate());
+    EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
+  }
+
+  void Verify_FindMainResponseWithMultipleHits5() {

[jennb, 2011/04/12 00:07:56]

Do we have test coverage for these cases:  1) multiple in-use explicit entries
and 2) multiple in-use fallback namespaces?

[michaeln, 2011/04/14 23:41:23]

No, i've just got one entry per bucket. Do you think the additional coverage is
needed?

+    EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
+    EXPECT_EQ(kManifestUrl2, delegate()->found_manifest_url_);
+    EXPECT_FALSE(delegate()->found_blocked_by_policy_);
+    EXPECT_EQ(2, delegate()->found_cache_id_);
+    EXPECT_FALSE(delegate()->found_entry_.has_response_id());
+    EXPECT_EQ(2 + kFallbackEntryIdOffset,
+              delegate()->found_fallback_entry_.response_id());
+    EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
+    EXPECT_EQ(kEntryUrl2, delegate()->found_fallback_url_);
+
     TestFinished();
   }
 
@@ -961,7 +1067,7 @@
     PushNextTask(NewRunnableMethod(
         this, &AppCacheStorageImplTest::Verify_ExclusionNotFound,
         kEntryUrl, 1));
-    storage()->FindResponseForMainRequest(kEntryUrl, delegate());
+    storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
   }
 
   void Verify_ExclusionNotFound(GURL expected_url, int phase) {
@@ -980,7 +1086,8 @@
       PushNextTask(NewRunnableMethod(this,
           &AppCacheStorageImplTest::Verify_ExclusionNotFound,
           kOnlineNamespace, 2));
-      storage()->FindResponseForMainRequest(kOnlineNamespace, delegate());
+      storage()->FindResponseForMainRequest(
+          kOnlineNamespace, GURL(), delegate());
       return;
     }
     if (phase == 2) {
@@ -990,7 +1097,7 @@
           &AppCacheStorageImplTest::Verify_ExclusionNotFound,
           kOnlineNamespaceWithinFallback, 3));
       storage()->FindResponseForMainRequest(
-          kOnlineNamespaceWithinFallback, delegate());
+          kOnlineNamespaceWithinFallback, GURL(), delegate());
       return;
     }