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

webkit/appcache/appcache_host.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_host.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "webkit/appcache/appcache.h"
@@ skipping 21 matching lines @@
 }  // Anonymous namespace
 
 AppCacheHost::AppCacheHost(int host_id, AppCacheFrontend* frontend,
                            AppCacheService* service)
     : host_id_(host_id), parent_host_id_(kNoHostId), parent_process_id_(0),
       pending_main_resource_cache_id_(kNoCacheId),
       pending_selected_cache_id_(kNoCacheId),
       frontend_(frontend), service_(service),
       pending_get_status_callback_(NULL), pending_start_update_callback_(NULL),
       pending_swap_cache_callback_(NULL), pending_callback_param_(NULL),
-      main_resource_blocked_(false), associated_cache_info_pending_(false) {
+      main_resource_was_fallback_(false), main_resource_blocked_(false),
+      associated_cache_info_pending_(false) {
 }
 
 AppCacheHost::~AppCacheHost() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDestructionImminent(this));
   if (associated_cache_.get())
     associated_cache_->UnassociateHost(this);
   if (group_being_updated_.get())
     group_being_updated_->RemoveUpdateObserver(this);
   service_->storage()->CancelDelegateCallbacks(this);
 }
@@ skipping 84 matching lines @@
   if (appcache_id != kNoCacheId) {
     LoadSelectedCache(appcache_id);
     return;
   }
   FinishCacheSelection(NULL, NULL);
 }
 
 // TODO(michaeln): change method name to MarkEntryAsForeign for consistency
 void AppCacheHost::MarkAsForeignEntry(const GURL& document_url,
                                       int64 cache_document_was_loaded_from) {
+  // The document url is not the resource url in the fallback case.
   service_->storage()->MarkEntryAsForeign(
-      document_url, cache_document_was_loaded_from);
+      main_resource_was_fallback_ ? fallback_url_ : document_url,
+      cache_document_was_loaded_from);
   SelectCache(document_url, kNoCacheId, GURL());
 }
 
 void AppCacheHost::GetStatusWithCallback(GetStatusCallback* callback,
                                          void* callback_param) {
   DCHECK(!pending_start_update_callback_ &&
          !pending_swap_cache_callback_ &&
          !pending_get_status_callback_);
 
   pending_get_status_callback_ = callback;
@@ skipping 286 matching lines @@
 void AppCacheHost::LoadMainResourceCache(int64 cache_id) {
   DCHECK(cache_id != kNoCacheId);
   if (pending_main_resource_cache_id_ == cache_id ||
       (main_resource_cache_ && main_resource_cache_->cache_id() == cache_id)) {
     return;
   }
   pending_main_resource_cache_id_ = cache_id;
   service_->storage()->LoadCache(cache_id, this);
 }
 
+void AppCacheHost::NotifyMainResourceFallback(const GURL& fallback_url) {
+  main_resource_was_fallback_ = true;
+  fallback_url_ = fallback_url;
+}
+
 void AppCacheHost::NotifyMainResourceBlocked(const GURL& manifest_url) {
   main_resource_blocked_ = true;
   blocked_manifest_url_ = manifest_url;
 }
 
 void AppCacheHost::AssociateCache(AppCache* cache) {
   if (associated_cache_.get()) {
     associated_cache_->UnassociateHost(this);
   }
 
   associated_cache_ = cache;
   SetSwappableCache(cache ? cache->owning_group() : NULL);
   associated_cache_info_pending_ = cache && !cache->is_complete();
   AppCacheInfo info;
   if (cache) {
     cache->AssociateHost(this);
     FillCacheInfo(cache, GetStatus(), &info);
   }
   frontend_->OnCacheSelected(host_id_, info);
 }
 
 }  // namespace appcache