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

webkit/appcache/appcache_storage_impl_unittest.cc

-// 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.
 
 #include <stack>
 
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_database.h"
 #include "webkit/appcache/appcache_entry.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_policy.h"
 #include "webkit/appcache/appcache_service.h"
 #include "webkit/appcache/appcache_storage_impl.h"
 #include "webkit/tools/test_shell/simple_appcache_system.h"
 
 namespace appcache {
 
 namespace {
 
 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/");
 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 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.
 
 scoped_ptr<base::Thread> io_thread;
 scoped_ptr<base::Thread> db_thread;
 
 class TestThreadProvider : public SimpleAppCacheSystem::ThreadProvider {
  public:
   virtual bool PostTask(
       int id,
@@ skipping 669 matching lines @@
     TestFinished();
   }
 
   // FindNoMainResponse  -------------------------------
 
   void FindNoMainResponse() {
     PushNextTask(NewRunnableMethod(
        this, &AppCacheStorageImplTest::Verify_FindNoMainResponse));
 
     // Conduct the test.
-    storage()->FindResponseForMainRequest(kEntryUrl, delegate());
+    storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
     EXPECT_NE(kEntryUrl, delegate()->found_url_);
   }
 
   void Verify_FindNoMainResponse() {
     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
     // If the request was blocked by a policy, the manifest url is still valid.
     EXPECT_TRUE(delegate()->found_manifest_url_.is_empty() ||
                 delegate()->found_blocked_by_policy_);
     EXPECT_EQ(kNoCacheId, delegate()->found_cache_id_);
     EXPECT_EQ(kNoResponseId, delegate()->found_entry_.response_id());
@@ skipping 39 matching lines @@
 
     // Optionally drop the cache/group pair from the working set.
     if (drop_from_working_set) {
       EXPECT_TRUE(cache_->HasOneRef());
       cache_ = NULL;
       EXPECT_TRUE(group_->HasOneRef());
       group_ = NULL;
     }
 
     // Conduct the test.
-    storage()->FindResponseForMainRequest(kEntryUrl, delegate());
+    storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
     EXPECT_NE(kEntryUrl,  delegate()->found_url_);
   }
 
   void Verify_BasicFindMainResponse() {
     EXPECT_EQ(kManifestUrl, policy_.requested_manifest_url_);
     if (policy_.can_load_return_value_) {
       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_);
@@ skipping 40 matching lines @@
     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, delegate());
+    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_FALSE(delegate()->found_blocked_by_policy_);
     EXPECT_EQ(1, delegate()->found_cache_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();
   }
 
   // FindMainResponseWithMultipleHits  -------------------------------
 
   void FindMainResponseWithMultipleHits() {
     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));
-    AppCacheDatabase::EntryRecord entry_record;
-    entry_record.cache_id = 1;
-    entry_record.url = kEntryUrl;
-    entry_record.flags = AppCacheEntry::EXPLICIT;
-    entry_record.response_id = 1;
-    EXPECT_TRUE(database()->InsertEntry(&entry_record));
-    cache_ = NULL;
-    group_ = NULL;
-
-    // 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;
-    EXPECT_TRUE(database()->InsertEntry(&entry_record));
-
-    // Conduct the test, we should find the response from the second cache
+    // Conduct the test, we should find the response from the last cache
     // since it's "in use".
-    storage()->FindResponseForMainRequest(kEntryUrl, delegate());
+    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;
+
+    // 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 = id;
+    EXPECT_TRUE(database()->InsertEntry(&entry_record));
+    cache_->AddEntry(
+        entry_record.url,
+        AppCacheEntry(entry_record.flags, entry_record.response_id));
+
+    // 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));
+
+    // 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();
   }
 
   // FindMainResponseExclusions  -------------------------------
 
   void FindMainResponseExclusionsInDatabase() {
     FindMainResponseExclusions(true);
   }
 
   void FindMainResponseExclusionsInWorkingSet() {
@@ skipping 37 matching lines @@
     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(NewRunnableMethod(
         this, &AppCacheStorageImplTest::Verify_ExclusionNotFound,
         kEntryUrl, 1));
-    storage()->FindResponseForMainRequest(kEntryUrl, delegate());
+    storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
   }
 
   void Verify_ExclusionNotFound(GURL expected_url, int phase) {
     EXPECT_EQ(expected_url, delegate()->found_url_);
     EXPECT_TRUE(delegate()->found_manifest_url_.is_empty());
     EXPECT_FALSE(delegate()->found_blocked_by_policy_);
     EXPECT_EQ(kNoCacheId, delegate()->found_cache_id_);
     EXPECT_EQ(kNoResponseId, delegate()->found_entry_.response_id());
     EXPECT_EQ(kNoResponseId, delegate()->found_fallback_entry_.response_id());
     EXPECT_TRUE(delegate()->found_fallback_url_.is_empty());
     EXPECT_EQ(0, delegate()->found_entry_.types());
     EXPECT_EQ(0, delegate()->found_fallback_entry_.types());
 
     if (phase == 1) {
       // We should not find anything for the online namespace.
       PushNextTask(NewRunnableMethod(this,
           &AppCacheStorageImplTest::Verify_ExclusionNotFound,
           kOnlineNamespace, 2));
-      storage()->FindResponseForMainRequest(kOnlineNamespace, delegate());
+      storage()->FindResponseForMainRequest(
+          kOnlineNamespace, GURL(), delegate());
       return;
     }
     if (phase == 2) {
       // We should not find anything for the online namespace nested within
       // the fallback namespace.
       PushNextTask(NewRunnableMethod(this,
           &AppCacheStorageImplTest::Verify_ExclusionNotFound,
           kOnlineNamespaceWithinFallback, 3));
       storage()->FindResponseForMainRequest(
-          kOnlineNamespaceWithinFallback, delegate());
+          kOnlineNamespaceWithinFallback, GURL(), delegate());
       return;
     }
 
     TestFinished();
   }
 
   // Test case helpers --------------------------------------------------
 
   AppCacheService* service() {
     return service_.get();
@@ skipping 140 matching lines @@
       &AppCacheStorageImplTest::FindMainResponseExclusionsInWorkingSet);
 }
 
 // That's all folks!
 
 }  // namespace appcache
 
 // AppCacheStorageImplTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheStorageImplTest);