Fix http/tests/appcache/foreign-fallback.html

webkit/appcache/mock_appcache_storage.cc

 // Copyright (c) 2010 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 "webkit/appcache/mock_appcache_storage.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "base/stl_util-inl.h"
@@ skipping 194 matching lines @@
     RemoveStoredCaches(copy);
   }
 
   if (delegate)
     delegate->OnGroupAndNewestCacheStored(group, newest_cache, true, false);
 }
 
 namespace {
 
 struct FoundCandidate {
+  GURL url;
   AppCacheEntry entry;
   int64 cache_id;
   GURL manifest_url;
   bool is_cache_in_use;
 
   FoundCandidate() : cache_id(kNoCacheId), is_cache_in_use(false) {}
 };
 
 }  // namespace
 
 void MockAppCacheStorage::ProcessFindResponseForMainRequest(
     const GURL& url, scoped_refptr<DelegateReference> delegate_ref) {
   if (simulate_find_main_resource_) {
     simulate_find_main_resource_ = false;
     if (delegate_ref->delegate) {
       delegate_ref->delegate->OnMainResponseFound(
-          url, simulated_found_entry_, simulated_found_fallback_entry_,
+          url, simulated_found_entry_,
+          simulated_found_fallback_url_, simulated_found_fallback_entry_,
           simulated_found_cache_id_, simulated_found_manifest_url_, false);
     }
     return;
   }
 
   // This call has no persistent side effects, if the delegate has gone
   // away, we can just bail out early.
   if (!delegate_ref->delegate)
     return;
 
@@ skipping 34 matching lines @@
         (found_entry.has_response_id() && found_entry.IsForeign()) ||
         (found_fallback_entry.has_response_id() &&
          found_fallback_entry.IsForeign())) {
       continue;
     }
 
     // We have a bias for hits from caches that are in use.
     bool is_in_use = IsCacheStored(cache) && !cache->HasOneRef();
 
     if (found_entry.has_response_id()) {
+      found_candidate.url = url;
       found_candidate.entry = found_entry;
       found_candidate.cache_id = cache->cache_id();
       found_candidate.manifest_url = group->manifest_url();
       found_candidate.is_cache_in_use = is_in_use;
       if (is_in_use)
         break;  // We break out of the loop with this direct hit.
     } else {
       DCHECK(found_fallback_entry.has_response_id());
 
       bool take_new_candidate = true;
@@ skipping 10 matching lines @@
           take_new_candidate = true;
         } else if (found_length == candidate_length &&
                    is_in_use && !found_fallback_candidate.is_cache_in_use) {
           take_new_candidate = true;
         } else {
           take_new_candidate = false;
         }
       }
 
       if (take_new_candidate) {
+        found_fallback_candidate.url =
+            cache->GetFallbackEntryUrl(found_fallback_namespace);
         found_fallback_candidate.entry = found_fallback_entry;
         found_fallback_candidate.cache_id = cache->cache_id();
         found_fallback_candidate.manifest_url = group->manifest_url();
         found_fallback_candidate.is_cache_in_use = is_in_use;
         found_fallback_candidate_namespace = found_fallback_namespace;
       }
     }
   }
 
   // Found a direct hit.
   if (found_candidate.entry.has_response_id()) {
     delegate_ref->delegate->OnMainResponseFound(
-        url, found_candidate.entry, AppCacheEntry(),
+        url, found_candidate.entry, GURL(), AppCacheEntry(),
         found_candidate.cache_id, found_candidate.manifest_url, false);
     return;
   }
 
   // Found a fallback namespace.
   if (found_fallback_candidate.entry.has_response_id()) {
     delegate_ref->delegate->OnMainResponseFound(
-        url, AppCacheEntry(), found_fallback_candidate.entry,
+        url, AppCacheEntry(),
+        found_fallback_candidate.url,
+        found_fallback_candidate.entry,
         found_fallback_candidate.cache_id,
         found_fallback_candidate.manifest_url, false);
     return;
   }
 
   // Didn't find anything.
   delegate_ref->delegate->OnMainResponseFound(
-      url, AppCacheEntry(), AppCacheEntry(), kNoCacheId, GURL(), false);
+      url, AppCacheEntry(), GURL(), AppCacheEntry(), kNoCacheId, GURL(), false);
 }
 
 void MockAppCacheStorage::ProcessMakeGroupObsolete(
     scoped_refptr<AppCacheGroup> group,
     scoped_refptr<DelegateReference> delegate_ref) {
   if (simulate_make_group_obsolete_failure_) {
     if (delegate_ref->delegate)
       delegate_ref->delegate->OnGroupMadeObsolete(group, false);
     return;
   }
@@ skipping 100 matching lines @@
 bool MockAppCacheStorage::ShouldCacheLoadAppearAsync(const AppCache* cache) {
   if (!cache)
     return true;
 
   // If the 'stored' ref is the only ref, real storage will have to load from
   // the database.
   return IsCacheStored(cache) && cache->HasOneRef();
 }
 
 }  // namespace appcache