[Quota] Add UsageTracker::GetGlobalLimitedUsage

webkit/quota/usage_tracker.cc

 // Copyright (c) 2012 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 42 matching lines @@
   return true;
 }
 
 bool OriginSetContainsOrigin(const OriginSetByHost& origins,
                              const std::string& host,
                              const GURL& origin) {
   OriginSetByHost::const_iterator itr = origins.find(host);
   return itr != origins.end() && ContainsKey(itr->second, origin);
 }
 
+void DidGetGlobalUsageForLimitedGlobalUsage(const UsageCallback& callback,
+                                            int64 total_global_usage,
+                                            int64 global_unlimited_usage) {
+  callback.Run(total_global_usage - global_unlimited_usage);
+}
+
 }  // namespace
 
 // UsageTracker ----------------------------------------------------------
 
 UsageTracker::UsageTracker(const QuotaClientList& clients,
                            StorageType type,
                            SpecialStoragePolicy* special_storage_policy)
     : type_(type),
       weak_factory_(this) {
   for (QuotaClientList::const_iterator iter = clients.begin();
       iter != clients.end();
       ++iter) {
     client_tracker_map_[(*iter)->id()] =
         new ClientUsageTracker(this, *iter, type, special_storage_policy);
   }
 }
 
 UsageTracker::~UsageTracker() {
   STLDeleteValues(&client_tracker_map_);
 }
 
 ClientUsageTracker* UsageTracker::GetClientTracker(QuotaClient::ID client_id) {
   ClientTrackerMap::iterator found = client_tracker_map_.find(client_id);
   if (found != client_tracker_map_.end())
     return found->second;
   return NULL;
 }
 
+void UsageTracker::GetGlobalLimitedUsage(const UsageCallback& callback) {
+  GetGlobalUsage(base::Bind(&DidGetGlobalUsageForLimitedGlobalUsage, callback));
+}
+
 void UsageTracker::GetGlobalUsage(const GlobalUsageCallback& callback) {
   if (!global_usage_callbacks_.Add(callback))
     return;
 
   AccumulateInfo* info = new AccumulateInfo;
   // Calling GetGlobalUsage(accumulator) may synchronously
   // return if the usage is cached, which may in turn dispatch
   // the completion callback before we finish looping over
   // all clients (because info->pending_clients may reach 0
   // during the loop).
@@ skipping 478 matching lines @@
 }
 
 bool ClientUsageTracker::IsStorageUnlimited(const GURL& origin) const {
   if (type_ == kStorageTypeSyncable)
     return false;
   return special_storage_policy_.get() &&
          special_storage_policy_->IsStorageUnlimited(origin);
 }
 
 }  // namespace quota