More groundwork for flat file based response storage.

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 16 matching lines @@
 namespace appcache {
 
 MockAppCacheStorage::MockAppCacheStorage(AppCacheService* service)
     : AppCacheStorage(service),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       simulate_make_group_obsolete_failure_(false),
       simulate_store_group_and_newest_cache_failure_(false),
       simulate_find_main_resource_(false),
       simulate_find_sub_resource_(false),
       simulated_found_cache_id_(kNoCacheId),
+      simulated_found_group_id_(0),
       simulated_found_network_namespace_(false) {
   last_cache_id_ = 0;
   last_group_id_ = 0;
   last_response_id_ = 0;
 }
 
 MockAppCacheStorage::~MockAppCacheStorage() {
   STLDeleteElements(&pending_tasks_);
 }
 
@@ skipping 92 matching lines @@
   DCHECK(group && delegate);
 
   // Always make this method look async.
   ScheduleTask(method_factory_.NewRunnableMethod(
       &MockAppCacheStorage::ProcessMakeGroupObsolete,
       make_scoped_refptr(group),
       make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
 }
 
 AppCacheResponseReader* MockAppCacheStorage::CreateResponseReader(
-    const GURL& manifest_url, int64 response_id) {
+    const GURL& manifest_url, int64 group_id, int64 response_id) {
   if (simulated_reader_.get())
     return simulated_reader_.release();
-  return new AppCacheResponseReader(response_id, disk_cache());
+  return new AppCacheResponseReader(response_id, group_id, disk_cache());
 }
 
 AppCacheResponseWriter* MockAppCacheStorage::CreateResponseWriter(
-    const GURL& manifest_url) {
-  return new AppCacheResponseWriter(NewResponseId(), disk_cache());
+    const GURL& manifest_url, int64 group_id) {
+  return new AppCacheResponseWriter(NewResponseId(),  group_id, disk_cache());
 }
 
 void MockAppCacheStorage::DoomResponses(
     const GURL& manifest_url, const std::vector<int64>& response_ids) {
   DeleteResponses(manifest_url, response_ids);
 }
 
 void MockAppCacheStorage::DeleteResponses(
     const GURL& manifest_url, const std::vector<int64>& response_ids) {
   // We don't bother with actually removing responses from the disk-cache,
@@ skipping 57 matching lines @@
   if (delegate)
     delegate->OnGroupAndNewestCacheStored(group, newest_cache, true, false);
 }
 
 namespace {
 
 struct FoundCandidate {
   GURL url;
   AppCacheEntry entry;
   int64 cache_id;
+  int64 group_id;
   GURL manifest_url;
   bool is_cache_in_use;
 
-  FoundCandidate() : cache_id(kNoCacheId), is_cache_in_use(false) {}
+  FoundCandidate()
+      : cache_id(kNoCacheId), group_id(0), is_cache_in_use(false) {}
 };
 
 }  // 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_);
+          simulated_found_cache_id_, simulated_found_group_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 36 matching lines @@
       continue;
     }
 
     // We have a bias for hits from caches that are in use.
     bool is_in_use = IsCacheStored(cache) && !cache->HasOneRef();
 
     if (found_entry.has_response_id()) {
       found_candidate.url = url;
       found_candidate.entry = found_entry;
       found_candidate.cache_id = cache->cache_id();
+      found_candidate.group_id = group->group_id();
       found_candidate.manifest_url = group->manifest_url();
       found_candidate.is_cache_in_use = is_in_use;
       if (is_in_use)
         break;  // We break out of the loop with this direct hit.
     } else {
       DCHECK(found_fallback_entry.has_response_id());
 
       bool take_new_candidate = true;
 
       // Does the newly found entry trump our current candidate?
@@ skipping 12 matching lines @@
         } else {
           take_new_candidate = false;
         }
       }
 
       if (take_new_candidate) {
         found_fallback_candidate.url =
             cache->GetFallbackEntryUrl(found_fallback_namespace);
         found_fallback_candidate.entry = found_fallback_entry;
         found_fallback_candidate.cache_id = cache->cache_id();
+        found_fallback_candidate.group_id = group->group_id();
         found_fallback_candidate.manifest_url = group->manifest_url();
         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);
+        found_candidate.cache_id, found_candidate.group_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.group_id,
         found_fallback_candidate.manifest_url);
     return;
   }
 
   // Didn't find anything.
   delegate_ref->delegate->OnMainResponseFound(
-      url, AppCacheEntry(), GURL(), AppCacheEntry(), kNoCacheId, GURL());
+      url, AppCacheEntry(), GURL(), AppCacheEntry(), kNoCacheId, 0, 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