Retrieve per host storage usage from QuotaManager.

webkit/quota/usage_tracker.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/quota/usage_tracker.h"
 
 #include <algorithm>
 #include <deque>
 #include <set>
 #include <string>
@@ skipping 254 matching lines @@
   }
 }
 
 void UsageTracker::UpdateUsageCache(
     QuotaClient::ID client_id, const GURL& origin, int64 delta) {
   ClientUsageTracker* client_tracker = GetClientTracker(client_id);
   DCHECK(client_tracker);
   client_tracker->UpdateUsageCache(origin, delta);
 }
 
+void UsageTracker::GetCachedHostsUsage(
+    std::map<std::string, int64>* host_usage) const {
+  DCHECK(host_usage);
+  host_usage->clear();
+  for (ClientTrackerMap::const_iterator iter = client_tracker_map_.begin();
+       iter != client_tracker_map_.end(); ++iter) {
+    iter->second->GetCachedHostsUsage(host_usage);

[kinuko, 2011/10/03 07:49:20]

Don't we want to aggregate the usage across different clients?

[mnaganov (inactive), 2011/10/04 03:00:40]

Right. Fixed in ClientUsageTracker::GetCachedHostsUsage.

+  }
+}
+
 void UsageTracker::GetCachedOrigins(std::set<GURL>* origins) const {
   DCHECK(origins);
   origins->clear();
   for (ClientTrackerMap::const_iterator iter = client_tracker_map_.begin();
        iter != client_tracker_map_.end(); ++iter) {
     iter->second->GetCachedOrigins(origins);
   }
 }
 
 void UsageTracker::DidGetClientGlobalUsage(StorageType type,
@@ skipping 101 matching lines @@
     DCHECK_GE(cached_usage_[host][origin], 0);
     DCHECK_GE(global_usage_, 0);
     return;
   }
 
   // We don't know about this host yet, so populate our cache for it.
   GetHostUsage(host,
                NewCallback(this, &ClientUsageTracker::NoopHostUsageCallback));
 }
 
+void ClientUsageTracker::GetCachedHostsUsage(
+    std::map<std::string, int64>* host_usage) const {
+  DCHECK(host_usage);
+  for (HostUsageMap::const_iterator host_iter = cached_usage_.begin();
+       host_iter != cached_usage_.end(); host_iter++) {
+    host_usage->insert(std::pair<std::string, int64>(
+        host_iter->first, GetCachedHostUsage(host_iter->first)));
+  }
+}
+
 void ClientUsageTracker::GetCachedOrigins(std::set<GURL>* origins) const {
   DCHECK(origins);
   for (HostUsageMap::const_iterator host_iter = cached_usage_.begin();
        host_iter != cached_usage_.end(); host_iter++) {
     const UsageMap& origin_map = host_iter->second;
     for (UsageMap::const_iterator origin_iter = origin_map.begin();
          origin_iter != origin_map.end(); origin_iter++) {
       origins->insert(origin_iter->first);
     }
   }
@@ skipping 36 matching lines @@
   }
   host_usage_callbacks_.Clear();
 }
 
 void ClientUsageTracker::GatherHostUsageComplete(const std::string& host) {
   DCHECK(host_usage_tasks_.find(host) != host_usage_tasks_.end());
   host_usage_tasks_.erase(host);
   host_usage_callbacks_.Run(host, host, type_, GetCachedHostUsage(host));
 }
 
-int64 ClientUsageTracker::GetCachedHostUsage(const std::string& host) {
+int64 ClientUsageTracker::GetCachedHostUsage(const std::string& host) const {
   HostUsageMap::const_iterator found = cached_usage_.find(host);
   if (found == cached_usage_.end())
     return 0;
 
   int64 usage = 0;
   const UsageMap& map = found->second;
   for (UsageMap::const_iterator iter = map.begin();
        iter != map.end(); ++iter) {
     usage += iter->second;
   }
@@ skipping 25 matching lines @@
 void ClientUsageTracker::NoopHostUsageCallback(
     const std::string& host,  StorageType type, int64 usage) {
 }
 
 bool ClientUsageTracker::IsStorageUnlimited(const GURL& origin) const {
   return special_storage_policy_.get() &&
          special_storage_policy_->IsStorageUnlimited(origin);
 }
 
 }  // namespace quota