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 189 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(host_);
   DCHECK(is_main_resource());
   DCHECK(!entry.IsForeign());
   DCHECK(!fallback_entry.IsForeign());
   DCHECK(!(entry.has_response_id() && fallback_entry.has_response_id()));
 
+  AppCachePolicy* policy = host_->service()->appcache_policy();
+  bool was_blocked_by_policy = policy &&
+      !policy->CanLoadAppCache(manifest_url, host_->first_party_url());

[michaeln, 2011/09/02 18:47:47]

in most cases (the "nothing was found" case), manifest_url will be empty

[marja, 2011/09/05 10:42:24]

Ok, in the current code in
AppCacheStorageImpl::CheckPolicyAndCallOnMainResponseFound, when manifest_url is
empty, the policy check is not done and OnMainResponseFound is called with
non-nullified values. So here I added !manifest_url.is_empty() to the policy
check.

+
   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);

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

we shouldn't do these things if 'blocked'

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

Hmm, I don't understand. They were done when the was_blocked_by_policy was
passed to this func as a param, why shouldn't they be done now?

I changed this to "else if" though.

[michaeln, 2011/09/02 18:47:47]

Here's the current callsite for OnMainResponseFound in the blocked case, notice
the values being passed in.

  if (!manifest_url.is_empty()) {
    // Check the policy prior to returning a main resource from the appcache.
    AppCachePolicy* policy = service()->appcache_policy();
    if (policy && !policy->CanLoadAppCache(manifest_url)) {
      FOR_EACH_DELEGATE(
          (*delegates),
          OnMainResponseFound(url, AppCacheEntry(),
                              GURL(), AppCacheEntry(),
                              kNoCacheId, manifest_url, true));
      return;
    }
  }

[marja, 2011/09/05 10:42:24]

Ah, of course, thanks.

       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;

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

if was_blocked, these data members cannot be set to these values... doing so
will cause the 'blocked' resource to be used

not sure, you may want to make an early exit in the blocked case which calls
DeliverNetworkResponse() prior to exit

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

Done.

   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
 
   if (found_entry_.has_response_id()) {
     DeliverAppCachedResponse(
         found_entry_, found_cache_id_, found_manifest_url_,
         false, GURL());
@@ skipping 86 matching lines @@
   if (!host_->associated_cache() ||
       !host_->associated_cache()->is_complete()) {
     DeliverNetworkResponse();
     return;
   }
 
   ContinueMaybeLoadSubResource();
 }
 
 }  // namespace appcache