Select a more appropiate appcache based on the opener or the parent of the new document.

webkit/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/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 170 matching lines @@
 
 void AppCacheRequestHandler::DeliverNetworkResponse() {
   DCHECK(job_ && job_->is_waiting());
   job_->DeliverNetworkResponse();
 }
 
 // Main-resource handling ----------------------------------------------
 
 void AppCacheRequestHandler::MaybeLoadMainResource(net::URLRequest* request) {
   DCHECK(!job_);
+  DCHECK(host_);
+
+  AppCacheHost* spawning_host = ResourceType::IsSharedWorker(resource_type_) ?

[jennb, 2011/04/12 00:07:56]

How does SharedWorker affect which host to use as spawning_host?  I'm not
familiar with the significance.

[michaeln, 2011/04/14 23:41:23]

In the current system, the main resource of a shared worker is loaded by the
context (and its appcacheHost) that first creates that worker. This is very
unlike other 'main-resources' (pages) which are the first resource loaded by the
empty context which the page will populate.

So in the SharedWorker case, the spawning host is the page that's creating the
worker == the page that loading the main resource for the shared worker = host_.

+      host_ : host_->GetSpawningHost();
+  GURL preferred_manifest_url = spawning_host ?
+      spawning_host->preferred_manifest_url() : GURL();
 
   // 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);
+  storage()->FindResponseForMainRequest(
+      request->url(), preferred_manifest_url, this);
 }
 
 void AppCacheRequestHandler::OnMainResponseFound(
     const GURL& url, const AppCacheEntry& 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);
+      host_->set_preferred_manifest_url(manifest_url);
     }
   } 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;
@@ skipping 96 matching lines @@
   if (!host_->associated_cache() ||
       !host_->associated_cache()->is_complete()) {
     DeliverNetworkResponse();
     return;
   }
 
   ContinueMaybeLoadSubResource();
 }
 
 }  // namespace appcache