Third-party appcache blocking.

webkit/appcache/mock_appcache_storage.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/mock_appcache_storage.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 230 matching lines @@
 }  // namespace
 
 void MockAppCacheStorage::ProcessFindResponseForMainRequest(
     const GURL& url, scoped_refptr<DelegateReference> delegate_ref) {
   if (simulate_find_main_resource_) {
     simulate_find_main_resource_ = false;
     if (delegate_ref->delegate) {
       delegate_ref->delegate->OnMainResponseFound(
           url, simulated_found_entry_,
           simulated_found_fallback_url_, simulated_found_fallback_entry_,
-          simulated_found_cache_id_, simulated_found_manifest_url_, false);
+          simulated_found_cache_id_, simulated_found_manifest_url_);
     }
     return;
   }
 
   // This call has no persistent side effects, if the delegate has gone
   // away, we can just bail out early.
   if (!delegate_ref->delegate)
     return;
 
   // TODO(michaeln): The heuristics around choosing amoungst
@@ skipping 79 matching lines @@
         found_fallback_candidate.is_cache_in_use = is_in_use;
         found_fallback_candidate_namespace = found_fallback_namespace;
       }
     }
   }
 
   // Found a direct hit.
   if (found_candidate.entry.has_response_id()) {
     delegate_ref->delegate->OnMainResponseFound(
         url, found_candidate.entry, GURL(), AppCacheEntry(),
-        found_candidate.cache_id, found_candidate.manifest_url, false);
+        found_candidate.cache_id, found_candidate.manifest_url);
     return;
   }
 
   // Found a fallback namespace.
   if (found_fallback_candidate.entry.has_response_id()) {
     delegate_ref->delegate->OnMainResponseFound(
         url, AppCacheEntry(),
         found_fallback_candidate.url,
         found_fallback_candidate.entry,
         found_fallback_candidate.cache_id,
-        found_fallback_candidate.manifest_url, false);
+        found_fallback_candidate.manifest_url);
     return;
   }
 
   // Didn't find anything.
   delegate_ref->delegate->OnMainResponseFound(
-      url, AppCacheEntry(), GURL(), AppCacheEntry(), kNoCacheId, GURL(), false);
+      url, AppCacheEntry(), GURL(), AppCacheEntry(), kNoCacheId, GURL());
 }
 
 void MockAppCacheStorage::ProcessMakeGroupObsolete(
     scoped_refptr<AppCacheGroup> group,
     scoped_refptr<DelegateReference> delegate_ref) {
   if (simulate_make_group_obsolete_failure_) {
     if (delegate_ref->delegate)
       delegate_ref->delegate->OnGroupMadeObsolete(group, false);
     return;
   }
@@ skipping 104 matching lines @@
 bool MockAppCacheStorage::ShouldCacheLoadAppearAsync(const AppCache* cache) {
   if (!cache)
     return true;
 
   // If the 'stored' ref is the only ref, real storage will have to load from
   // the database.
   return IsCacheStored(cache) && cache->HasOneRef();
 }
 
 }  // namespace appcache