Third-party appcache blocking.

webkit/appcache/appcache_storage_impl.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_storage_impl.h"
 
 #include <set>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_errors.h"
 #include "sql/connection.h"
 #include "sql/transaction.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_database.h"
 #include "webkit/appcache/appcache_entry.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_histograms.h"
-#include "webkit/appcache/appcache_policy.h"
 #include "webkit/appcache/appcache_quota_client.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_service.h"
 #include "webkit/appcache/appcache_thread.h"
 #include "webkit/quota/quota_client.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/special_storage_policy.h"
 
 namespace appcache {
 
@@ skipping 909 matching lines @@
       fallback_url_ = (*iter)->fallback_entry_url;
       fallback_entry_ = AppCacheEntry(
           entry_record.flags, entry_record.response_id);
       return true;  // We found one.
     }
   }
   return false;  // We didn't find a match.
 }
 
 void AppCacheStorageImpl::FindMainResponseTask::RunCompleted() {
-  storage_->CheckPolicyAndCallOnMainResponseFound(
+  storage_->CallOnMainResponseFound(
       &delegates_, url_, entry_, fallback_url_, fallback_entry_,
       cache_id_, manifest_url_);
 }
 
 // MarkEntryAsForeignTask -------
 
 class AppCacheStorageImpl::MarkEntryAsForeignTask : public DatabaseTask {
  public:
   MarkEntryAsForeignTask(
       AppCacheStorageImpl* storage, const GURL& url, int64 cache_id)
@@ skipping 401 matching lines @@
 }
 
 void AppCacheStorageImpl::DeliverShortCircuitedFindMainResponse(
     const GURL& url,
     const AppCacheEntry& found_entry,
     scoped_refptr<AppCacheGroup> group,
     scoped_refptr<AppCache> cache,
     scoped_refptr<DelegateReference> delegate_ref) {
   if (delegate_ref->delegate) {
     DelegateReferenceVector delegates(1, delegate_ref);
-    CheckPolicyAndCallOnMainResponseFound(
+    CallOnMainResponseFound(
         &delegates, url, found_entry,
         GURL(), AppCacheEntry(),
         cache.get() ? cache->cache_id() : kNoCacheId,
         group.get() ? group->manifest_url() : GURL());
   }
 }
 
-void AppCacheStorageImpl::CheckPolicyAndCallOnMainResponseFound(
+void AppCacheStorageImpl::CallOnMainResponseFound(
     DelegateReferenceVector* delegates,
     const GURL& url, const AppCacheEntry& entry,
     const GURL& fallback_url, const AppCacheEntry& fallback_entry,
     int64 cache_id, const GURL& manifest_url) {
-  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;
-    }
-  }
-
   FOR_EACH_DELEGATE(
       (*delegates),
       OnMainResponseFound(url, entry,
                           fallback_url, fallback_entry,
-                          cache_id, manifest_url, false));
+                          cache_id, manifest_url));
 }
 
 void AppCacheStorageImpl::FindResponseForSubRequest(
     AppCache* cache, const GURL& url,
     AppCacheEntry* found_entry, AppCacheEntry* found_fallback_entry,
     bool* found_network_namespace) {
   DCHECK(cache && cache->is_complete());
 
   // When a group is forcibly deleted, all subresource loads for pages
   // using caches in the group will result in a synthesized network errors.
@@ skipping 233 matching lines @@
     Disable();
     if (!is_incognito_) {
       VLOG(1) << "Deleting existing appcache data and starting over.";
       AppCacheThread::PostTask(AppCacheThread::db(), FROM_HERE,
           NewRunnableFunction(DeleteDirectory, cache_directory_));
     }
   }
 }
 
 }  // namespace appcache