Fix some loose ends around recently introduced AppCache INTERCEPT namespaces

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 77 matching lines @@
       test_->ScheduleNextTask();
     }
 
     void OnGroupMadeObsolete(AppCacheGroup* group, bool success) {
       obsoleted_group_ = group;
       obsoleted_success_ = success;
       test_->ScheduleNextTask();
     }
 
     void OnMainResponseFound(const GURL& url, const AppCacheEntry& entry,
-                             const GURL& fallback_url,
+                             const GURL& namespace_entry_url,
                              const AppCacheEntry& fallback_entry,
                              int64 cache_id, int64 group_id,
                              const GURL& manifest_url) {
       found_url_ = url;
       found_entry_ = entry;
-      found_fallback_url_ = fallback_url;
+      found_namespace_entry_url_ = namespace_entry_url;
       found_fallback_entry_ = fallback_entry;
       found_cache_id_ = cache_id;
       found_group_id_ = group_id;
       found_manifest_url_ = manifest_url;
       test_->ScheduleNextTask();
     }
 
     scoped_refptr<AppCache> loaded_cache_;
     int64 loaded_cache_id_;
     scoped_refptr<AppCacheGroup> loaded_group_;
     GURL loaded_manifest_url_;
     scoped_refptr<AppCache> loaded_groups_newest_cache_;
     scoped_refptr<AppCacheGroup> stored_group_;
     bool stored_group_success_;
     bool would_exceed_quota_;
     scoped_refptr<AppCacheGroup> obsoleted_group_;
     bool obsoleted_success_;
     GURL found_url_;
     AppCacheEntry found_entry_;
-    GURL found_fallback_url_;
+    GURL found_namespace_entry_url_;
     AppCacheEntry found_fallback_entry_;
     int64 found_cache_id_;
     int64 found_group_id_;
     GURL found_manifest_url_;
     AppCacheStorageImplTest* test_;
   };
 
   class MockQuotaManager : public quota::QuotaManager {
    public:
     MockQuotaManager()
@@ skipping 665 matching lines @@
     storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
     EXPECT_NE(kEntryUrl, delegate()->found_url_);
   }
 
   void Verify_FindNoMainResponse() {
     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
     EXPECT_TRUE(delegate()->found_manifest_url_.is_empty());
     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_TRUE(delegate()->found_namespace_entry_url_.is_empty());
     EXPECT_EQ(0, delegate()->found_entry_.types());
     EXPECT_EQ(0, delegate()->found_fallback_entry_.types());
     TestFinished();
   }
 
   // BasicFindMainResponse  -------------------------------
 
   void BasicFindMainResponseInDatabase() {
     BasicFindMainResponse(true);
   }
@@ skipping 98 matching lines @@
     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_EQ(kEntryUrl2, delegate()->found_namespace_entry_url_);
     EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
     TestFinished();
   }
 
   // BasicFindMainInterceptResponse  -------------------------------
 
   void BasicFindMainInterceptResponseInDatabase() {
     BasicFindMainInterceptResponse(true);
   }
 
@@ skipping 48 matching lines @@
     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_EQ(kEntryUrl2, delegate()->found_namespace_entry_url_);
     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
     TestFinished();
   }
   // FindMainResponseWithMultipleHits  -------------------------------
 
   void FindMainResponseWithMultipleHits() {
     PushNextTask(base::Bind(
         &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits,
         base::Unretained(this)));
 
@@ skipping 110 matching lines @@
 
   void Verify_FindMainResponseWithMultipleHits4() {
     EXPECT_EQ(kFallbackTestUrl, 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_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_);
+    EXPECT_EQ(kEntryUrl2, delegate()->found_namespace_entry_url_);
 
     // Conduct another test preferring kManifestUrl2 that hits the fallback.
     delegate_.reset(new MockStorageDelegate(this));
     PushNextTask(base::Bind(
         &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits5,
         base::Unretained(this)));
     storage()->FindResponseForMainRequest(
         kFallbackTestUrl, kManifestUrl2, delegate());
     EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
   }
 
   void Verify_FindMainResponseWithMultipleHits5() {
     EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl2, delegate()->found_manifest_url_);
     EXPECT_EQ(2, delegate()->found_cache_id_);
     EXPECT_EQ(2, delegate()->found_group_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_);
+    EXPECT_EQ(kEntryUrl2, delegate()->found_namespace_entry_url_);
 
     TestFinished();
   }
 
   // FindMainResponseExclusions  -------------------------------
 
   void FindMainResponseExclusionsInDatabase() {
     FindMainResponseExclusions(true);
   }
 
@@ skipping 46 matching lines @@
     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_EQ(kNoCacheId, delegate()->found_cache_id_);
     EXPECT_EQ(0, delegate()->found_group_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_TRUE(delegate()->found_namespace_entry_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(
           base::Bind(&AppCacheStorageImplTest::Verify_ExclusionNotFound,
                      base::Unretained(this), kOnlineNamespace, 2));
       storage()->FindResponseForMainRequest(
           kOnlineNamespace, GURL(), delegate());
@@ skipping 175 matching lines @@
 }
 
 TEST_F(AppCacheStorageImplTest, FindMainResponseExclusionsInWorkingSet) {
   RunTestOnIOThread(
       &AppCacheStorageImplTest::FindMainResponseExclusionsInWorkingSet);
 }
 
 // That's all folks!
 
 }  // namespace appcache