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

webkit/appcache/appcache.cc

 // Copyright (c) 2009 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 <algorithm>
 
 #include "webkit/appcache/appcache.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_host.h"
 #include "webkit/appcache/appcache_interfaces.h"
 #include "webkit/appcache/appcache_service.h"
 #include "webkit/appcache/appcache_storage.h"
 
 namespace appcache {
 
 AppCache::AppCache(AppCacheService *service, int64 cache_id)
     : cache_id_(cache_id),
       owning_group_(NULL),
       online_whitelist_all_(false),
       is_complete_(false),
+      cache_size_(0),
       service_(service) {
   service_->storage()->working_set()->AddCache(this);
 }
 
 AppCache::~AppCache() {
   DCHECK(associated_hosts_.empty());
   if (owning_group_) {
     DCHECK(is_complete_);
     owning_group_->RemoveCache(this);
   }
@@ skipping 10 matching lines @@
   entries_.insert(EntryMap::value_type(url, entry));
 }
 
 bool AppCache::AddOrModifyEntry(const GURL& url, const AppCacheEntry& entry) {
   std::pair<EntryMap::iterator, bool> ret =
       entries_.insert(EntryMap::value_type(url, entry));
 
   // Entry already exists.  Merge the types of the new and existing entries.
   if (!ret.second)
     ret.first->second.add_types(entry.types());
-
+  else
+    cache_size_ += entry.response_size();  // New entry. Add to cache size.
   return ret.second;
 }
 
 AppCacheEntry* AppCache::GetEntry(const GURL& url) {
   EntryMap::iterator it = entries_.find(url);
   return (it != entries_.end()) ? &(it->second) : NULL;
 }
 
 namespace {
-
 bool SortByLength(
     const FallbackNamespace& lhs, const FallbackNamespace& rhs) {
   return lhs.first.spec().length() > rhs.first.spec().length();
 }
-
 }
 
 void AppCache::InitializeWithManifest(Manifest* manifest) {
   DCHECK(manifest);
   fallback_namespaces_.swap(manifest->fallback_namespaces);
   online_whitelist_namespaces_.swap(manifest->online_whitelist_namespaces);
   online_whitelist_all_ = manifest->online_whitelist_all;
 
   // Sort the fallback namespaces by url string length, longest to shortest,
   // since longer matches trump when matching a url to a namespace.
@@ skipping 75 matching lines @@
   if (!online_whitelist_all_) {
     for (size_t i = 0; i < online_whitelist_namespaces_.size(); ++i) {
       whitelists->push_back(AppCacheDatabase::OnlineWhiteListRecord());
       AppCacheDatabase::OnlineWhiteListRecord& record = whitelists->back();
       record.cache_id = cache_id_;
       record.namespace_url = online_whitelist_namespaces_[i];
     }
   }
 }
 
-
 bool AppCache::FindResponseForRequest(const GURL& url,
     AppCacheEntry* found_entry, AppCacheEntry* found_fallback_entry,
     GURL* found_fallback_namespace, bool* found_network_namespace) {
   // Ignore fragments when looking up URL in the cache.
   GURL url_no_ref;
   if (url.has_ref()) {
     GURL::Replacements replacements;
     replacements.ClearRef();
     url_no_ref = url.ReplaceComponents(replacements);
   } else {
@@ skipping 39 matching lines @@
   for (size_t i = 0; i < count; ++i) {
     if (StartsWithASCII(
             url.spec(), online_whitelist_namespaces_[i].spec(), true)) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace appcache