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

webkit/appcache/appcache_host.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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_host.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_backend_impl.h"
@@ skipping 14 matching lines @@
     info->last_update_time = cache->update_time();
     info->creation_time = cache->owning_group()->creation_time();
     info->size = cache->cache_size();
   }
 }
 
 }  // Anonymous namespace
 
 AppCacheHost::AppCacheHost(int host_id, AppCacheFrontend* frontend,
                            AppCacheService* service)
-    : host_id_(host_id), parent_host_id_(kNoHostId), parent_process_id_(0),
+    : host_id_(host_id),
+      spawning_host_id_(kNoHostId), spawning_process_id_(0),
+      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_was_fallback_(false), main_resource_blocked_(false),
       associated_cache_info_pending_(false) {
 }
 
 AppCacheHost::~AppCacheHost() {
@@ skipping 35 matching lines @@
   if (cache_document_was_loaded_from != kNoCacheId) {
     LoadSelectedCache(cache_document_was_loaded_from);
     return;
   }
 
   if (!manifest_url.is_empty() &&
       (manifest_url.GetOrigin() == document_url.GetOrigin())) {
     // Note: The client detects if the document was not loaded using HTTP GET
     // and invokes SelectCache without a manifest url, so that detection step
     // is also skipped here. See WebApplicationCacheHostImpl.cc
+    set_preferred_manifest_url(manifest_url);
     new_master_entry_url_ = document_url;
     LoadOrCreateGroup(manifest_url);
     return;
   }
 
   // TODO(michaeln): If there was a manifest URL, the user agent may report
   // to the user that it was ignored, to aid in application development.
   FinishCacheSelection(NULL, NULL);
 }
 
@@ skipping 121 matching lines @@
     }
   }
 
   pending_swap_cache_callback_->Run(
       success, pending_callback_param_);
 
   pending_swap_cache_callback_ = NULL;
   pending_callback_param_ = NULL;
 }
 
+void AppCacheHost::SetSpawningHostId(
+    int spawning_process_id, int spawning_host_id) {
+  spawning_process_id_ = spawning_process_id;
+  spawning_host_id_ = spawning_host_id;
+}
+
+const AppCacheHost* AppCacheHost::GetSpawningHost() const {
+  AppCacheBackendImpl* backend = service_->GetBackend(spawning_process_id_);
+  return backend ? backend->GetHost(spawning_host_id_) : NULL;
+}
+
 AppCacheHost* AppCacheHost::GetParentAppCacheHost() const {
   DCHECK(is_for_dedicated_worker());
   AppCacheBackendImpl* backend = service_->GetBackend(parent_process_id_);
   return backend ? backend->GetHost(parent_host_id_) : NULL;
 }
 
 AppCacheRequestHandler* AppCacheHost::CreateRequestHandler(
     net::URLRequest* request,
     ResourceType::Type resource_type) {
   if (is_for_dedicated_worker()) {
@@ skipping 88 matching lines @@
   DCHECK(!associated_cache());
 
   // 6.9.6 The application cache selection algorithm
   if (cache) {
     // If document was loaded from an application cache, Associate document
     // with the application cache from which it was loaded. Invoke the
     // application cache update process for that cache and with the browsing
     // context being navigated.
     DCHECK(cache->owning_group());
     DCHECK(new_master_entry_url_.is_empty());
+    DCHECK_EQ(cache->owning_group()->manifest_url(), preferred_manifest_url_);
     AppCacheGroup* owing_group = cache->owning_group();
     const char* kFormatString =
         "Document was loaded from Application Cache with manifest %s";
     frontend_->OnLogMessage(
         host_id_, LOG_INFO,
         base::StringPrintf(
             kFormatString, owing_group->manifest_url().spec().c_str()));
     AssociateCache(cache);
     if (!owing_group->is_obsolete() && !owing_group->is_being_deleted()) {
       owing_group->StartUpdateWithHost(this);
       ObserveGroupBeingUpdated(owing_group);
     }
   } else if (group && !group->is_being_deleted()) {
     // If document was loaded using HTTP GET or equivalent, and, there is a
     // manifest URL, and manifest URL has the same origin as document.
     // Invoke the application cache update process for manifest URL, with
     // the browsing context being navigated, and with document and the
     // resource from which document was loaded as the new master resourse.
     DCHECK(!group->is_obsolete());
     DCHECK(new_master_entry_url_.is_valid());
+    DCHECK_EQ(group->manifest_url(), preferred_manifest_url_);
     const char* kFormatString = group->HasCache() ?
         "Adding master entry to Application Cache with manifest %s" :
         "Creating Application Cache with manifest %s";
     frontend_->OnLogMessage(
         host_id_, LOG_INFO,
         base::StringPrintf(kFormatString,
                            group->manifest_url().spec().c_str()));
     AssociateCache(NULL);  // The UpdateJob may produce one for us later.
     group->StartUpdateWithNewMasterEntry(this, new_master_entry_url_);
     ObserveGroupBeingUpdated(group);
@@ skipping 86 matching lines @@
   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