Chrome side of changes required to populate appcache resource list....

webkit/appcache/appcache_storage_impl.cc

 // Copyright (c) 2010 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 "app/sql/connection.h"
 #include "app/sql/transaction.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 203 matching lines @@
        origin != origins.end(); ++origin) {
     AppCacheInfoVector& infos =
         info_collection_->infos_by_origin[*origin];
     std::vector<AppCacheDatabase::GroupRecord> groups;
     database_->FindGroupsForOrigin(*origin, &groups);
     for (std::vector<AppCacheDatabase::GroupRecord>::const_iterator
          group = groups.begin();
          group != groups.end(); ++group) {
       AppCacheDatabase::CacheRecord cache_record;
       database_->FindCacheForGroup(group->group_id, &cache_record);
-      infos.push_back(
-          AppCacheInfo(
-              group->manifest_url, cache_record.cache_size,
-              group->creation_time, group->last_access_time,
-              cache_record.update_time));
+      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.is_complete = true;

[michaeln, 2010/07/27 19:10:50]

did you intend to set status here too?

+      infos.push_back(info);
     }
   }
 }
 
 void AppCacheStorageImpl::GetAllInfoTask::RunCompleted() {
   DCHECK(delegates_.size() == 1);
   FOR_EACH_DELEGATE(delegates_, OnAllInfo(info_collection_));
 }
 
 // StoreOrLoadTask -------
@@ skipping 36 matching lines @@
   cache->get()->set_complete(true);
 
   (*group) = storage_->working_set_.GetGroup(group_record_.manifest_url);
   if (group->get()) {
     DCHECK(group_record_.group_id == group->get()->group_id());
     group->get()->AddCache(cache->get());
   } else {
     (*group) = new AppCacheGroup(
         storage_->service_, group_record_.manifest_url,
         group_record_.group_id);
+    group->get()->set_creation_time(group_record_.creation_time);
     group->get()->AddCache(cache->get());
   }
   DCHECK(group->get()->newest_complete_cache() == cache->get());
 
   // We have to update foriegn entries if MarkEntryAsForeignTasks
   // are in flight.
   std::vector<GURL> urls;
   storage_->GetPendingForeignMarkingsForCache(cache->get()->cache_id(), &urls);
   for (std::vector<GURL>::iterator iter = urls.begin();
        iter != urls.end(); ++iter) {
@@ skipping 74 matching lines @@
   scoped_refptr<AppCacheGroup> group;
   scoped_refptr<AppCache> cache;
   if (!storage_->is_disabled()) {
     if (success_) {
       DCHECK(group_record_.manifest_url == manifest_url_);
       DCHECK(!storage_->working_set_.GetGroup(manifest_url_));
       DCHECK(!storage_->working_set_.GetCache(cache_record_.cache_id));
       CreateCacheAndGroupFromRecords(&cache, &group);
     } else {
       group = new AppCacheGroup(
-          storage_->service_, manifest_url_,
-          storage_->NewGroupId());
+          storage_->service_, manifest_url_, storage_->NewGroupId());
     }
   }
   FOR_EACH_DELEGATE(delegates_, OnGroupLoaded(group, manifest_url_));
 }
 
 // StoreGroupAndCacheTask -------
 
 class AppCacheStorageImpl::StoreGroupAndCacheTask : public StoreOrLoadTask {
  public:
   StoreGroupAndCacheTask(AppCacheStorageImpl* storage, AppCacheGroup* group,
@@ skipping 85 matching lines @@
       database_->InsertEntryRecords(entry_records_) &&
       database_->InsertFallbackNameSpaceRecords(fallback_namespace_records_)&&
       database_->InsertOnlineWhiteListRecords(online_whitelist_records_) &&
       (database_->GetOriginUsage(group_record_.origin) <=
        database_->GetOriginQuota(group_record_.origin)) &&
       transaction.Commit();
 }
 
 void AppCacheStorageImpl::StoreGroupAndCacheTask::RunCompleted() {
   if (success_) {
+    // TODO(kkanetkar): Add to creation time when that's enabled.
     storage_->origins_with_groups_.insert(group_->manifest_url().GetOrigin());
     if (cache_ != group_->newest_complete_cache()) {
       cache_->set_complete(true);
       group_->AddCache(cache_);
     }
     group_->AddNewlyDeletableResponseIds(&newly_deletable_response_ids_);
   }
   FOR_EACH_DELEGATE(delegates_,
                     OnGroupAndNewestCacheStored(group_, cache_, success_));
   group_ = NULL;
@@ skipping 33 matching lines @@
 
   GURL url_;
   std::set<int64> cache_ids_in_use_;
   AppCacheEntry entry_;
   AppCacheEntry fallback_entry_;
   int64 cache_id_;
   GURL manifest_url_;
 };
 
 namespace {
-
 bool SortByLength(
     const AppCacheDatabase::FallbackNameSpaceRecord& lhs,
     const AppCacheDatabase::FallbackNameSpaceRecord& rhs) {
   return lhs.namespace_url.spec().length() > rhs.namespace_url.spec().length();
 }
-
 }
 
 void AppCacheStorageImpl::FindMainResponseTask::Run() {
   // We have a bias for hits from caches that are in use.
 
   // TODO(michaeln): The heuristics around choosing amoungst
   // multiple candidates is under specified, and just plain
   // not fully understood. Refine these over time. In particular,
   // * prefer candidates from newer caches
   // * take into account the cache associated with the document
@@ skipping 743 matching lines @@
     Disable();
     if (!is_incognito_) {
       LOG(INFO) << "Deleting existing appcache data and starting over.";
       AppCacheThread::PostTask(AppCacheThread::db(), FROM_HERE,
           NewRunnableFunction(DeleteDirectory, cache_directory_));
     }
   }
 }
 
 }  // namespace appcache