NavigationController prototype

webkit/browser/appcache/appcache_request_handler.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 "webkit/browser/appcache/appcache_request_handler.h"
 
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 #include "webkit/browser/appcache/appcache.h"
 #include "webkit/browser/appcache/appcache_policy.h"
@@ skipping 18 matching lines @@
   }
 }
 
 AppCacheStorage* AppCacheRequestHandler::storage() const {
   DCHECK(host_);
   return host_->service()->storage();
 }
 
 void AppCacheRequestHandler::GetExtraResponseInfo(
     int64* cache_id, GURL* manifest_url) {
-  if (job_.get() && job_->is_delivering_appcache_response()) {
+  if (job_.get() && (job_->is_delivering_appcache_response() ||
+                     job_->is_delivering_synthesized_response())) {
     *cache_id = job_->cache_id();
     *manifest_url = job_->manifest_url();
   }
 }
 
 AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadResource(
     net::URLRequest* request, net::NetworkDelegate* network_delegate) {
   maybe_load_resource_executed_ = true;
   if (!host_ || !IsSchemeAndMethodSupported(request) || cache_entry_not_found_)
     return NULL;
 
   // This method can get called multiple times over the life
   // of a request. The case we detect here is having scheduled
   // delivery of a "network response" using a job setup on an
   // earlier call thru this method. To send the request thru
   // to the network involves restarting the request altogether,
   // which will call thru to our interception layer again.
   // This time thru, we return NULL so the request hits the wire.
   if (job_.get()) {
-    DCHECK(job_->is_delivering_network_response() ||
-           job_->cache_entry_not_found());
+    // Note: no longer valid since we can generate 302s now.
+    //DCHECK(job_->is_delivering_network_response() ||
+    //       job_->cache_entry_not_found());
+    bool use_network = job_->is_delivering_network_response();
     if (job_->cache_entry_not_found())
       cache_entry_not_found_ = true;
     job_ = NULL;
     storage()->CancelDelegateCallbacks(this);
-    return NULL;
+    if (use_network)
+      return NULL;
   }
 
   // Clear out our 'found' fields since we're starting a request for a
   // new resource, any values in those fields are no longer valid.
   found_entry_ = AppCacheEntry();
   found_fallback_entry_ = AppCacheEntry();
   found_cache_id_ = kNoCacheId;
   found_manifest_url_ = GURL();
   found_network_namespace_ = false;
 
@@ skipping 109 matching lines @@
 void AppCacheRequestHandler::DeliverAppCachedResponse(
     const AppCacheEntry& entry, int64 cache_id, int64 group_id,
     const GURL& manifest_url,  bool is_fallback,
     const GURL& namespace_entry_url) {
   DCHECK(host_ && job_.get() && job_->is_waiting());
   DCHECK(entry.has_response_id());
 
   if (ResourceType::IsFrame(resource_type_) && !namespace_entry_url.is_empty())
     host_->NotifyMainResourceIsNamespaceEntry(namespace_entry_url);
 
+  // Executable handler hackery to distinguish between main vs sub resource
+  // loads in the handler script.
+  if (entry.IsExecutable())
+    job_->set_is_main_resource_load(is_main_resource());
+
   job_->DeliverAppCachedResponse(manifest_url, group_id, cache_id,
                                  entry, is_fallback);
 }
 
 void AppCacheRequestHandler::DeliverErrorResponse() {
   DCHECK(job_.get() && job_->is_waiting());
   job_->DeliverErrorResponse();
 }
 
 void AppCacheRequestHandler::DeliverNetworkResponse() {
@@ skipping 105 matching lines @@
   ContinueMaybeLoadSubResource();
 }
 
 void AppCacheRequestHandler::ContinueMaybeLoadSubResource() {
   // 6.9.6 Changes to the networking model
   // If the resource is not to be fetched using the HTTP GET mechanism or
   // equivalent ... then fetch the resource normally.
   DCHECK(job_.get());
   DCHECK(host_->associated_cache() && host_->associated_cache()->is_complete());
 
+  // Hackery for navcontroller semantics where the controller gets a crack
+  // and any and all subresource requests <period>.
+  if (host_->associated_cache()->owning_group()->IsFakeNavControllerGroup()) {
+    // We assume there's one entry and its the controller script.
+    AppCache* cache = host_->associated_cache();
+    found_cache_id_ = cache->cache_id();
+    found_group_id_ = cache->owning_group()->group_id();
+    found_manifest_url_ = cache->owning_group()->manifest_url();
+    found_entry_ = cache->entries().begin()->second;
+    DCHECK(found_entry_.IsExecutable());
+    DeliverAppCachedResponse(
+        found_entry_, found_cache_id_, found_group_id_, found_manifest_url_,
+        false, GURL());
+    return;
+  }
+
   const GURL& url = job_->request()->url();
   AppCache* cache = host_->associated_cache();
   storage()->FindResponseForSubRequest(
       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());
@@ skipping 41 matching lines @@
   if (!host_->associated_cache() ||
       !host_->associated_cache()->is_complete()) {
     DeliverNetworkResponse();
     return;
   }
 
   ContinueMaybeLoadSubResource();
 }
 
 }  // namespace appcache