Third-party appcache blocking.

webkit/appcache/appcache_host.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_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"
+#include "webkit/appcache/appcache_policy.h"
 #include "webkit/appcache/appcache_request_handler.h"
 #include "webkit/quota/quota_manager.h"
 
 namespace appcache {
 
 namespace {
 
 void FillCacheInfo(
     const AppCache* cache, Status status, AppCacheInfo* info) {
   DCHECK(cache);
@@ skipping 65 matching lines @@
   // Note: Foreign entries are detected on the client side and
   // MarkAsForeignEntry is called in that case, so that detection
   // step is skipped here. See WebApplicationCacheHostImpl.cc
 
   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())) {

[michaeln, 2011/08/31 23:42:08]

maybe DCHECK(!first_party_url_.empty());

[marja, 2011/09/02 13:40:24]

Done. For this, I also needed to add a call to CreateRequestHandler in
MasterEntryFailStoreNewestCacheTest.

+    AppCachePolicy* policy = service()->appcache_policy();
+    if (policy &&
+        !policy->CanCreateAppCache(manifest_url, first_party_url_)) {

[michaeln, 2011/08/31 23:42:08]

We need to call FinishCacheSelection(NULL,NULL) in this clause.

Also, i think we'll want to synthesize the correct sequence of appcache events
and message at this point. These are things the update job used to do.

frontend_->OnEventRaised(CHECKING);
frontend_->OnErrorEventRaised("Cache creation was blocked by the content
policy");
frontend_->OnContentBlocked(manifest_url);
return;

[marja, 2011/09/02 13:40:24]

Done.

+      return;
+    }
+
     // 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
@@ skipping 145 matching lines @@
 
 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) {
+  // Store the first party origin so that it can be used later in SelectCache
+  // for checking whether the creation of the appcache is allowed.
+  first_party_url_ = request->first_party_for_cookies();

[michaeln, 2011/08/31 23:42:08]

Can this be moved down into the if (IsMainResourceType()) block? Where it is, we
reset the value for every subresource request but we only need the value for the
main resource request.

[marja, 2011/09/02 13:40:24]

Done.

+
   if (is_for_dedicated_worker()) {
     AppCacheHost* parent_host = GetParentAppCacheHost();
     if (parent_host)
       return parent_host->CreateRequestHandler(request, resource_type);
     return NULL;
   }
 
-  if (AppCacheRequestHandler::IsMainResourceType(resource_type))
+  if (AppCacheRequestHandler::IsMainResourceType(resource_type)) {
     return new AppCacheRequestHandler(this, resource_type);
+  }
 
   if ((associated_cache() && associated_cache()->is_complete()) ||
       is_selection_pending()) {
     return new AppCacheRequestHandler(this, resource_type);
   }
   return NULL;
 }
 
 void AppCacheHost::GetResourceList(
     AppCacheResourceInfoVector* resource_infos) {
@@ skipping 132 matching lines @@
 
   if (associated_cache_info_pending_ && associated_cache_.get() &&
       associated_cache_->is_complete()) {
     AppCacheInfo info;
     FillCacheInfo(associated_cache_.get(), GetStatus(), &info);
     associated_cache_info_pending_ = false;
     frontend_->OnCacheSelected(host_id_, info);
   }
 }
 
 void AppCacheHost::OnContentBlocked(AppCacheGroup* group) {

[michaeln, 2011/08/31 23:42:08]

i think this method can be removed now that the update job doesn't call it
anymore

[marja, 2011/09/02 13:40:24]

Done.

   frontend_->OnContentBlocked(host_id_, group->manifest_url());
 }
 
 void AppCacheHost::SetSwappableCache(AppCacheGroup* group) {
   if (!group) {
     swappable_cache_ = NULL;
   } else {
     AppCache* new_cache = group->newest_complete_cache();
     if (new_cache != associated_cache_)
       swappable_cache_ = new_cache;
@@ skipping 32 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