More groundwork for flat file based response storage.

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 <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
@@ skipping 312 matching lines @@
          group != groups.end(); ++group) {
       AppCacheDatabase::CacheRecord cache_record;
       database_->FindCacheForGroup(group->group_id, &cache_record);
       AppCacheInfo info;
       info.manifest_url = group->manifest_url;
       info.creation_time = group->creation_time;
       info.size = cache_record.cache_size;
       info.last_access_time = group->last_access_time;
       info.last_update_time = cache_record.update_time;
       info.cache_id = cache_record.cache_id;
+      info.group_id = group->group_id;
       info.is_complete = true;
       infos.push_back(info);
     }
   }
 }
 
 void AppCacheStorageImpl::GetAllInfoTask::RunCompleted() {
   DCHECK(delegates_.size() == 1);
   FOR_EACH_DELEGATE(delegates_, OnAllInfo(info_collection_));
 }
@@ skipping 277 matching lines @@
         newly_deletable_response_ids_.push_back(*id_iter);
         ++id_iter;
       }
 
       success_ =
           database_->DeleteCache(cache.cache_id) &&
           database_->DeleteEntriesForCache(cache.cache_id) &&
           database_->DeleteFallbackNameSpacesForCache(cache.cache_id) &&
           database_->DeleteOnlineWhiteListForCache(cache.cache_id) &&
           database_->InsertDeletableResponseIds(newly_deletable_response_ids_);
+          // TODO(michaeln): store group_id too with deletable ids
     } else {
       NOTREACHED() << "A existing group without a cache is unexpected";
     }
   }
 
   success_ =
       success_ &&
       database_->InsertCache(&cache_record_) &&
       database_->InsertEntryRecords(entry_records_) &&
       database_->InsertFallbackNameSpaceRecords(fallback_namespace_records_)&&
@@ skipping 66 matching lines @@
 // FindMainResponseTask -------
 
 class AppCacheStorageImpl::FindMainResponseTask : public DatabaseTask {
  public:
   FindMainResponseTask(AppCacheStorageImpl* storage,
                        const GURL& url,
                        const GURL& preferred_manifest_url,
                        const AppCacheWorkingSet::GroupMap* groups_in_use)
       : DatabaseTask(storage), url_(url),
         preferred_manifest_url_(preferred_manifest_url),
-        cache_id_(kNoCacheId) {
+        cache_id_(kNoCacheId), group_id_(0) {
     if (groups_in_use) {
       for (AppCacheWorkingSet::GroupMap::const_iterator it =
                groups_in_use->begin();
            it != groups_in_use->end(); ++it) {
         AppCacheGroup* group = it->second;
         AppCache* cache = group->newest_complete_cache();
         if (group->is_obsolete() || !cache)
           continue;
         cache_ids_in_use_.insert(cache->cache_id());
       }
@@ skipping 10 matching lines @@
   bool FindFallback(int64 preferred_id);
   bool FindFirstValidFallback(const FallbackNameSpaceVector& fallbacks);
 
   GURL url_;
   GURL preferred_manifest_url_;
   std::set<int64> cache_ids_in_use_;
   AppCacheEntry entry_;
   AppCacheEntry fallback_entry_;
   GURL fallback_url_;
   int64 cache_id_;
+  int64 group_id_;
   GURL manifest_url_;
 };
 
 // Helpers for FindMainResponseTask::Run()
 namespace {
 class SortByCachePreference
     : public std::binary_function<
         AppCacheDatabase::EntryRecord,
         AppCacheDatabase::EntryRecord,
         bool> {
@@ skipping 55 matching lines @@
       ++iter;
     }
   }
 
   // Key is cache id
   typedef std::map<int64, std::vector<GURL> > WhiteListMap;
   WhiteListMap namespaces_map_;
   AppCacheDatabase* database_;
 };
 
-bool FindManifestForEntry(
-    const AppCacheDatabase::EntryRecord& entry_record,
-    AppCacheDatabase* database,
-    GURL* manifest_url_out) {
-  AppCacheDatabase::GroupRecord group_record;
-  if (!database->FindGroupForCache(entry_record.cache_id, &group_record)) {
-    NOTREACHED() << "A cache without a group is not expected.";
-    return false;
-  }
-  *manifest_url_out = group_record.manifest_url;
-  return true;
-}
-
 }  // namespace
 
 void AppCacheStorageImpl::FindMainResponseTask::Run() {
   // NOTE: The heuristics around choosing amoungst multiple candidates
   // is underspecified, and just plain not fully understood. This needs
   // to be refined.
 
   // The 'preferred_manifest_url' is the url of the manifest associated
   // with the page that opened or embedded the page being loaded now.
   // We have a strong preference to use resources from that cache.
@@ skipping 10 matching lines @@
             preferred_manifest_url_, &preferred_group) &&
         database_->FindCacheForGroup(
             preferred_group.group_id, &preferred_cache)) {
       preferred_cache_id = preferred_cache.cache_id;
     }
   }
 
   if (FindExactMatch(preferred_cache_id) ||
       FindFallback(preferred_cache_id)) {
     // We found something.
-    DCHECK(cache_id_ != kNoCacheId && !manifest_url_.is_empty());
+    DCHECK(cache_id_ != kNoCacheId && !manifest_url_.is_empty() &&
+           group_id_ != 0);
     return;
   }
 
   // We didn't find anything.
-  DCHECK(cache_id_ == kNoCacheId && manifest_url_.is_empty());
+  DCHECK(cache_id_ == kNoCacheId && manifest_url_.is_empty() &&
+         group_id_ == 0);
 }
 
 bool AppCacheStorageImpl::
 FindMainResponseTask::FindExactMatch(int64 preferred_cache_id) {
   std::vector<AppCacheDatabase::EntryRecord> entries;
   if (database_->FindEntriesForUrl(url_, &entries) && !entries.empty()) {
     // Sort them in order of preference, from the preferred_cache first,
     // followed by hits from caches that are 'in use', then the rest.
     std::sort(entries.begin(), entries.end(),
               SortByCachePreference(preferred_cache_id, cache_ids_in_use_));
 
     // Take the first with a valid, non-foreign entry.
     std::vector<AppCacheDatabase::EntryRecord>::iterator iter;
     for (iter = entries.begin(); iter < entries.end(); ++iter) {
+      AppCacheDatabase::GroupRecord group_record;
       if ((iter->flags & AppCacheEntry::FOREIGN) ||
-          !FindManifestForEntry(*iter, database_, &manifest_url_)) {
+          !database_->FindGroupForCache(iter->cache_id, &group_record)) {
         continue;
       }
+      manifest_url_ = group_record.manifest_url;
+      group_id_ = group_record.group_id;
       entry_ = AppCacheEntry(iter->flags, iter->response_id);
       cache_id_ = iter->cache_id;
       return true;  // We found an exact match.
     }
   }
   return false;
 }
 
 bool AppCacheStorageImpl::
 FindMainResponseTask::FindFallback(int64 preferred_cache_id) {
@@ skipping 44 matching lines @@
 
 bool AppCacheStorageImpl::
 FindMainResponseTask::FindFirstValidFallback(
     const FallbackNameSpaceVector& fallbacks) {
   // Take the first with a valid, non-foreign entry.
   FallbackNameSpaceVector::const_iterator iter;
   for (iter = fallbacks.begin(); iter < fallbacks.end();  ++iter) {
     AppCacheDatabase::EntryRecord entry_record;
     if (database_->FindEntry((*iter)->cache_id, (*iter)->fallback_entry_url,
                              &entry_record)) {
+      AppCacheDatabase::GroupRecord group_record;
       if ((entry_record.flags & AppCacheEntry::FOREIGN) ||
-          !FindManifestForEntry(entry_record, database_, &manifest_url_)) {
+          !database_->FindGroupForCache(entry_record.cache_id, &group_record)) {
         continue;
       }
+      manifest_url_ = group_record.manifest_url;
+      group_id_ = group_record.group_id;
       cache_id_ = (*iter)->cache_id;
       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_->CallOnMainResponseFound(
       &delegates_, url_, entry_, fallback_url_, fallback_entry_,
-      cache_id_, manifest_url_);
+      cache_id_, group_id_, manifest_url_);
 }
 
 // MarkEntryAsForeignTask -------
 
 class AppCacheStorageImpl::MarkEntryAsForeignTask : public DatabaseTask {
  public:
   MarkEntryAsForeignTask(
       AppCacheStorageImpl* storage, const GURL& url, int64 cache_id)
       : DatabaseTask(storage), cache_id_(cache_id), entry_url_(url) {}
 
@@ skipping 100 matching lines @@
   virtual void Run();
   virtual void RunCompleted();
 
   int64 max_rowid_;
   std::vector<int64> response_ids_;
 };
 
 void AppCacheStorageImpl::GetDeletableResponseIdsTask::Run() {
   const int kSqlLimit = 1000;
   database_->GetDeletableResponseIds(&response_ids_, max_rowid_, kSqlLimit);
+  // TODO(michaeln): retrieve group_ids too
 }
 
 void AppCacheStorageImpl::GetDeletableResponseIdsTask::RunCompleted() {
   if (!response_ids_.empty())
     storage_->StartDeletingResponses(response_ids_);
 }
 
 // InsertDeletableResponseIdsTask -------
 
 class AppCacheStorageImpl::InsertDeletableResponseIdsTask
     : public DatabaseTask {
  public:
   explicit InsertDeletableResponseIdsTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
   virtual void Run();
   std::vector<int64> response_ids_;
 };
 
 void AppCacheStorageImpl::InsertDeletableResponseIdsTask::Run() {
   database_->InsertDeletableResponseIds(response_ids_);
+  // TODO(michaeln): store group_ids too
 }
 
 // DeleteDeletableResponseIdsTask -------
 
 class AppCacheStorageImpl::DeleteDeletableResponseIdsTask
     : public DatabaseTask {
  public:
   explicit DeleteDeletableResponseIdsTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
   virtual void Run();
@@ skipping 265 matching lines @@
     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);
     CallOnMainResponseFound(
         &delegates, url, found_entry,
         GURL(), AppCacheEntry(),
         cache.get() ? cache->cache_id() : kNoCacheId,
+        group.get() ? group->group_id() : kNoCacheId,
         group.get() ? group->manifest_url() : GURL());
   }
 }
 
 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) {
+    int64 cache_id, int64 group_id, const GURL& manifest_url) {
   FOR_EACH_DELEGATE(
       (*delegates),
       OnMainResponseFound(url, entry,
                           fallback_url, fallback_entry,
-                          cache_id, manifest_url));
+                          cache_id, group_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 29 matching lines @@
 void AppCacheStorageImpl::MakeGroupObsolete(
     AppCacheGroup* group, Delegate* delegate) {
   DCHECK(group && delegate);
   scoped_refptr<MakeGroupObsoleteTask> task(
       new MakeGroupObsoleteTask(this, group));
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
 }
 
 AppCacheResponseReader* AppCacheStorageImpl::CreateResponseReader(
-    const GURL& manifest_url, int64 response_id) {
-  return new AppCacheResponseReader(response_id, disk_cache());
+    const GURL& manifest_url, int64 group_id, int64 response_id) {
+  return new AppCacheResponseReader(response_id, group_id, disk_cache());
 }
 
 AppCacheResponseWriter* AppCacheStorageImpl::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 AppCacheStorageImpl::DoomResponses(
     const GURL& manifest_url, const std::vector<int64>& response_ids) {
   if (response_ids.empty())
     return;
 
   // Start deleting them from the disk cache lazily.
   StartDeletingResponses(response_ids);
 
@@ skipping 56 matching lines @@
   DCHECK(!deletable_response_ids_.empty());
 
   if (!disk_cache()) {
     DCHECK(is_disabled_);
     deletable_response_ids_.clear();
     deleted_response_ids_.clear();
     is_response_deletion_scheduled_ = false;
     return;
   }
 
+  // TODO(michaeln): add group_id to DoomEntry args
   int64 id = deletable_response_ids_.front();
   int rv = disk_cache_->DoomEntry(id, &doom_callback_);
   if (rv != net::ERR_IO_PENDING)
     OnDeletedOneResponse(rv);
 }
 
 void AppCacheStorageImpl::OnDeletedOneResponse(int rv) {
   is_response_deletion_scheduled_ = false;
   if (is_disabled_)
     return;
@@ skipping 102 matching lines @@
     Disable();
     if (!is_incognito_) {
       VLOG(1) << "Deleting existing appcache data and starting over.";
       db_thread_->PostTask(
           FROM_HERE, base::Bind(&DeleteDirectory, cache_directory_));
     }
   }
 }
 
 }  // namespace appcache