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

webkit/appcache/appcache_storage_impl.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/appcache_storage_impl.h"
 
 #include "app/sql/connection.h"
 #include "app/sql/transaction.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 535 matching lines @@
     }
   }
 
   virtual void Run();
   virtual void RunCompleted();
 
   GURL url_;
   std::set<int64> cache_ids_in_use_;
   AppCacheEntry entry_;
   AppCacheEntry fallback_entry_;
+  GURL fallback_url_;
   int64 cache_id_;
   GURL manifest_url_;
 };
 
 namespace {
 bool SortByLength(
     const AppCacheDatabase::FallbackNameSpaceRecord& lhs,
     const AppCacheDatabase::FallbackNameSpaceRecord& rhs) {
   return lhs.namespace_url.spec().length() > rhs.namespace_url.spec().length();
 }
@@ skipping 63 matching lines @@
 
       AppCacheDatabase::EntryRecord entry_record;
       if (take_new_candidate &&
           database_->FindEntry(iter->cache_id, iter->fallback_entry_url,
                                &entry_record)) {
         AppCacheDatabase::GroupRecord group_record;
         if (!database_->FindGroupForCache(iter->cache_id, &group_record)) {
           NOTREACHED() << "A cache without a group is not expected.";
           continue;
         }
+        if (entry_record.flags & AppCacheEntry::FOREIGN)
+          continue;

[kinuko, 2010/11/02 07:47:23]

do we want to check this before looking up a group record? (just wondering)

[michaeln, 2010/11/02 20:25:36]

Yes, thank you!

         cache_id_ = iter->cache_id;
+        fallback_url_ = iter->fallback_entry_url;
         manifest_url_ = group_record.manifest_url;
         fallback_entry_ = AppCacheEntry(
             entry_record.flags, entry_record.response_id);
         if (is_cache_in_use)
           break;  // Stop iterating since we favor hits from in-use caches.
         candidate_fallback_namespace = iter->namespace_url;
         has_candidate = true;
       }
     }
   }
 }
 
 void AppCacheStorageImpl::FindMainResponseTask::RunCompleted() {
   storage_->CheckPolicyAndCallOnMainResponseFound(
-      &delegates_, url_, entry_, fallback_entry_, cache_id_, manifest_url_);
+      &delegates_, url_, entry_, fallback_url_, fallback_entry_,
+      cache_id_, manifest_url_);
 }
 
 // MarkEntryAsForeignTask -------
 
 class AppCacheStorageImpl::MarkEntryAsForeignTask : public DatabaseTask {
  public:
   MarkEntryAsForeignTask(
       AppCacheStorageImpl* storage, const GURL& url, int64 cache_id)
       : DatabaseTask(storage), cache_id_(cache_id), entry_url_(url) {}
 
@@ skipping 375 matching lines @@
   task->Schedule();
 }
 
 void AppCacheStorageImpl::DeliverShortCircuitedFindMainResponse(
     const GURL& url, AppCacheEntry found_entry,
     scoped_refptr<AppCacheGroup> group, scoped_refptr<AppCache> cache,
     scoped_refptr<DelegateReference> delegate_ref) {
   if (delegate_ref->delegate) {
     DelegateReferenceVector delegates(1, delegate_ref);
     CheckPolicyAndCallOnMainResponseFound(
-        &delegates, url, found_entry, AppCacheEntry(),
+        &delegates, url, found_entry,
+        GURL(), AppCacheEntry(),
         cache.get() ? cache->cache_id() : kNoCacheId,
         group.get() ? group->manifest_url() : GURL());
   }
 }
 
 void AppCacheStorageImpl::CheckPolicyAndCallOnMainResponseFound(
-    DelegateReferenceVector* delegates, const GURL& url,
-    const AppCacheEntry& entry, const AppCacheEntry& fallback_entry,
+    DelegateReferenceVector* delegates,
+    const GURL& url, const AppCacheEntry& entry,
+    const GURL& fallback_url, const AppCacheEntry& fallback_entry,
     int64 cache_id, const GURL& manifest_url) {
   if (!manifest_url.is_empty()) {
     // Check the policy prior to returning a main resource from the appcache.
     AppCachePolicy* policy = service()->appcache_policy();
     if (policy && !policy->CanLoadAppCache(manifest_url)) {
       FOR_EACH_DELEGATE(
           (*delegates),
-          OnMainResponseFound(url, AppCacheEntry(), AppCacheEntry(),
+          OnMainResponseFound(url, AppCacheEntry(),
+                              GURL(), AppCacheEntry(),
                               kNoCacheId, manifest_url, true));
       return;
     }
   }
 
   FOR_EACH_DELEGATE(
       (*delegates),
-      OnMainResponseFound(url, entry, fallback_entry,
+      OnMainResponseFound(url, entry,
+                          fallback_url, fallback_entry,
                           cache_id, manifest_url, false));
 }
 
 void AppCacheStorageImpl::FindResponseForSubRequest(
     AppCache* cache, const GURL& url,
     AppCacheEntry* found_entry, AppCacheEntry* found_fallback_entry,
     bool* found_network_namespace) {
   DCHECK(cache && cache->is_complete());
 
   // When a group is forcibly deleted, all subresource loads for pages
@@ skipping 234 matching lines @@
     Disable();
     if (!is_incognito_) {
       VLOG(1) << "Deleting existing appcache data and starting over.";
       AppCacheThread::PostTask(AppCacheThread::db(), FROM_HERE,
           NewRunnableFunction(DeleteDirectory, cache_directory_));
     }
   }
 }
 
 }  // namespace appcache