Third-party appcache blocking.

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_policy.h"
 #include "webkit/appcache/appcache_url_request_job.h"
 
 namespace appcache {
 
 AppCacheRequestHandler::AppCacheRequestHandler(AppCacheHost* host,
                                                ResourceType::Type resource_type)
     : host_(host), resource_type_(resource_type),
       is_waiting_for_cache_selection_(false), found_cache_id_(0),
       found_network_namespace_(false), cache_entry_not_found_(false) {
   DCHECK(host_);
@@ skipping 190 matching lines @@
   // 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(), 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) {
+    int64 cache_id, const GURL& manifest_url) {
   DCHECK(job_);
   DCHECK(host_);
   DCHECK(is_main_resource());
   DCHECK(!entry.IsForeign());
   DCHECK(!fallback_entry.IsForeign());
   DCHECK(!(entry.has_response_id() && fallback_entry.has_response_id()));
 
   if (!job_)
     return;
 
-  if (ResourceType::IsFrame(resource_type_)) {
-    if (was_blocked_by_policy)
+  AppCachePolicy* policy = host_->service()->appcache_policy();
+  bool was_blocked_by_policy = !manifest_url.is_empty() && policy &&
+      !policy->CanLoadAppCache(manifest_url, host_->first_party_url());
+
+  if (was_blocked_by_policy) {
+    if (ResourceType::IsFrame(resource_type_)) {
       host_->NotifyMainResourceBlocked(manifest_url);
+    } else {
+      DCHECK(ResourceType::IsSharedWorker(resource_type_));
+      host_->frontend()->OnContentBlocked(host_->host_id(), manifest_url);
+    }
+    DeliverNetworkResponse();
+    return;
+  }
 
-    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);
+  if (ResourceType::IsFrame(resource_type_) && 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);
   }
 
   // 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
@@ skipping 91 matching lines @@
   if (!host_->associated_cache() ||
       !host_->associated_cache()->is_complete()) {
     DeliverNetworkResponse();
     return;
   }
 
   ContinueMaybeLoadSubResource();
 }
 
 }  // namespace appcache