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

webkit/appcache/appcache_request_handler.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_request_handler.h"
 
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_url_request_job.h"
@@ skipping 79 matching lines @@
   if (!host_ || !IsSchemeAndMethodSupported(request) || cache_entry_not_found_)
     return NULL;
   if (is_main_resource())
     return NULL;
   if (request->url().GetOrigin() == location.GetOrigin())
     return NULL;
 
   DCHECK(!job_);  // our jobs never generate redirects
 
   if (found_fallback_entry_.has_response_id()) {
     // 6.9.6, step 4: If this results in a redirect to another origin,

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

(not a review comment) I thought it would be nice if an URL or some pointer to
the spec that has this '6.9.6' is given somewhere...

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

Comments that refer section number in the HTML5 draft are are pretty common in a
few of the .cc files in the /appcache directory. Most of the numbers are
probably stale by now since the draft changes and the numbers change with those
changes. I should probably go thru and update the references throughout. I could
put in some links at that time. A link at each reference seems like overkill...
maybe a link by one of the references in each of the most reference heavy .cc
files?

[kinuko, 2010/11/03 00:25:18]

That's true. I just wasn't able to find a relevant section whose number is
6.9.6.  Might be nice if section / subsection title was given together with the
numbers for important ones?  (Again, this is not a review comment.)

     // get the resource of the fallback entry.
     job_ = new AppCacheURLRequestJob(request, storage());
     DeliverAppCachedResponse(
-        found_fallback_entry_, found_cache_id_, found_manifest_url_, true);
+        found_fallback_entry_, found_cache_id_, found_manifest_url_,
+        true, found_fallback_url_);
   } else if (!found_network_namespace_) {
     // 6.9.6, step 6: Fail the resource load.
     job_ = new AppCacheURLRequestJob(request, storage());
     DeliverErrorResponse();
   } else {
     // 6.9.6 step 3 and 5: Fetch the resource normally.
   }
 
   return job_;
 }
@@ skipping 20 matching lines @@
   if (request->status().is_success()) {
     int code_major = request->GetResponseCode() / 100;
     if (code_major !=4 && code_major != 5)
       return NULL;
   }
 
   // 6.9.6, step 4: If this results in a 4xx or 5xx status code
   // or there were network errors, get the resource of the fallback entry.
   job_ = new AppCacheURLRequestJob(request, storage());
   DeliverAppCachedResponse(
-      found_fallback_entry_, found_cache_id_,  found_manifest_url_, true);
+      found_fallback_entry_, found_cache_id_,  found_manifest_url_,
+      true, found_fallback_url_);
   return job_;
 }
 
 void AppCacheRequestHandler::OnDestructionImminent(AppCacheHost* host) {
   storage()->CancelDelegateCallbacks(this);
   host_ = NULL;  // no need to RemoveObserver, the host is being deleted
 
   // Since the host is being deleted, we don't have to complete any job
   // that is current running. It's destined for the bit bucket anyway.
   if (job_) {
     job_->Kill();
     job_ = NULL;
   }
 }
 
 void AppCacheRequestHandler::DeliverAppCachedResponse(
     const AppCacheEntry& entry, int64 cache_id, const GURL& manifest_url,
-    bool is_fallback) {
-  DCHECK(job_ && job_->is_waiting());
+    bool is_fallback, const GURL& fallback_url) {
+  DCHECK(host_ && job_ && job_->is_waiting());
   DCHECK(entry.has_response_id());
+
+  if (ResourceType::IsFrame(resource_type_) && is_fallback) {
+    DCHECK(!fallback_url.is_empty());
+    host_->NotifyMainResourceFallback(fallback_url);
+  }
+
   job_->DeliverAppCachedResponse(manifest_url, cache_id, entry, is_fallback);
 }
 
 void AppCacheRequestHandler::DeliverErrorResponse() {
   DCHECK(job_ && job_->is_waiting());
   job_->DeliverErrorResponse();
 }
 
 void AppCacheRequestHandler::DeliverNetworkResponse() {
   DCHECK(job_ && job_->is_waiting());
   job_->DeliverNetworkResponse();
 }
 
 // Main-resource handling ----------------------------------------------
 
 void AppCacheRequestHandler::MaybeLoadMainResource(URLRequest* request) {
   DCHECK(!job_);
 
   // We may have to wait for our storage query to complete, but
   // this query can also complete syncrhonously.
   job_ = new AppCacheURLRequestJob(request, storage());
   storage()->FindResponseForMainRequest(request->url(), this);
 }
 
 void AppCacheRequestHandler::OnMainResponseFound(
     const GURL& url, const AppCacheEntry& entry,
-    const AppCacheEntry& fallback_entry,
+    const GURL& fallback_url, const AppCacheEntry& fallback_entry,
     int64 cache_id, const GURL& manifest_url,
     bool was_blocked_by_policy) {
   DCHECK(host_);
   DCHECK(is_main_resource());
   DCHECK(!entry.IsForeign());
   DCHECK(!fallback_entry.IsForeign());
   DCHECK(!(entry.has_response_id() && fallback_entry.has_response_id()));
 
   if (ResourceType::IsFrame(resource_type_)) {
     if (was_blocked_by_policy)
       host_->NotifyMainResourceBlocked(manifest_url);
 
     if (cache_id != kNoCacheId) {
       // AppCacheHost loads and holds a reference to the main resource cache
       // for two reasons, firstly to preload the cache into the working set
       // in advance of subresource loads happening, secondly to prevent the
       // AppCache from falling out of the working set on frame navigations.
       host_->LoadMainResourceCache(cache_id);
     }
   } else {
     DCHECK(ResourceType::IsSharedWorker(resource_type_));
     if (was_blocked_by_policy)
       host_->frontend()->OnContentBlocked(host_->host_id(), manifest_url);
   }
 
   // 6.11.1 Navigating across documents, steps 10 and 14.
 
   found_entry_ = entry;
+  found_fallback_url_ = fallback_url;
   found_fallback_entry_ = fallback_entry;
   found_cache_id_ = cache_id;
   found_manifest_url_ = manifest_url;
   found_network_namespace_ = false;  // not applicable to main requests
 
   if (found_entry_.has_response_id()) {
     DeliverAppCachedResponse(
-        found_entry_, found_cache_id_, found_manifest_url_, false);
+        found_entry_, found_cache_id_, found_manifest_url_,
+        false, GURL());
   } else {
     DeliverNetworkResponse();
   }
 }
 
 // Sub-resource handling ----------------------------------------------
 
 void AppCacheRequestHandler::MaybeLoadSubResource(
     URLRequest* request) {
   DCHECK(!job_);
@@ skipping 29 matching lines @@
       host_->associated_cache(), url,
       &found_entry_, &found_fallback_entry_, &found_network_namespace_);
 
   if (found_entry_.has_response_id()) {
     // Step 2: If there's an entry, get it instead.
     DCHECK(!found_network_namespace_ &&
            !found_fallback_entry_.has_response_id());
     found_cache_id_ = cache->cache_id();
     found_manifest_url_ = cache->owning_group()->manifest_url();
     DeliverAppCachedResponse(
-        found_entry_, found_cache_id_, found_manifest_url_, false);
+        found_entry_, found_cache_id_, found_manifest_url_,
+        false, GURL());
     return;
   }
 
   if (found_fallback_entry_.has_response_id()) {
     // Step 4: Fetch the resource normally, if this results
     // in certain conditions, then use the fallback.
     DCHECK(!found_network_namespace_ &&
            !found_entry_.has_response_id());
     found_cache_id_ = cache->cache_id();
     found_manifest_url_ = cache->owning_group()->manifest_url();
@@ skipping 25 matching lines @@
   if (!host_->associated_cache() ||
       !host_->associated_cache()->is_complete()) {
     DeliverNetworkResponse();
     return;
   }
 
   ContinueMaybeLoadSubResource();
 }
 
 }  // namespace appcache