[Quota] Wire up limited origin usage retrieving.

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 11 matching lines @@
 typedef ClientUsageTracker::OriginUsageAccumulator OriginUsageAccumulator;
 typedef ClientUsageTracker::OriginSetByHost OriginSetByHost;
 
 void DidGetOriginUsage(const OriginUsageAccumulator& accumulator,
                        const GURL& origin,
                        int64 usage) {
   accumulator.Run(origin, usage);
 }
 
 void DidGetHostUsage(const UsageCallback& callback,
-                     int64 cached_usage,
-                     int64 non_cached_usage) {
-  DCHECK_GE(cached_usage, 0);
-  DCHECK_GE(non_cached_usage, 0);
-  callback.Run(cached_usage + non_cached_usage);
+                     int64 limited_usage,
+                     int64 unlimited_usage) {
+  DCHECK_GE(limited_usage, 0);
+  DCHECK_GE(unlimited_usage, 0);
+  callback.Run(limited_usage + unlimited_usage);
 }
 
 void NoopHostUsageCallback(int64 usage) {}
 
 bool EraseOriginFromOriginSet(OriginSetByHost* origins_by_host,
                               const std::string& host,
                               const GURL& origin) {
   OriginSetByHost::iterator found = origins_by_host->find(host);
   if (found == origins_by_host->end())
     return false;
@@ skipping 41 matching lines @@
 }
 
 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));
+  if (global_usage_callbacks_.HasCallbacks()) {
+    global_usage_callbacks_.Add(base::Bind(
+        &DidGetGlobalUsageForLimitedGlobalUsage, callback));
+    return;
+  }
+
+  if (!global_limited_usage_callbacks_.Add(callback))
+    return;
+
+  AccumulateInfo* info = new AccumulateInfo;
+  // Calling GetGlobalLimitedUsage(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).
+  // To avoid this, we add one more pending client as a sentinel
+  // and fire the sentinel callback at the end.
+  info->pending_clients = client_tracker_map_.size() + 1;
+  UsageCallback accumulator = base::Bind(
+      &UsageTracker::AccumulateClientGlobalLimitedUsage,
+      weak_factory_.GetWeakPtr(), base::Owned(info));
+
+  for (ClientTrackerMap::iterator iter = client_tracker_map_.begin();
+       iter != client_tracker_map_.end();
+       ++iter)
+    iter->second->GetGlobalLimitedUsage(accumulator);
+
+  // Fire the sentinel as we've now called GetGlobalUsage for all clients.
+  accumulator.Run(0);

[kinuko, 2013/05/30 05:56:32]

Hmm, can we possibly cleanup this pattern in a separate patch in the future?

 }
 
 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
@@ skipping 70 matching lines @@
 
 void UsageTracker::SetUsageCacheEnabled(QuotaClient::ID client_id,
                                         const GURL& origin,
                                         bool enabled) {
   ClientUsageTracker* client_tracker = GetClientTracker(client_id);
   DCHECK(client_tracker);
 
   client_tracker->SetUsageCacheEnabled(origin, enabled);
 }
 
+void UsageTracker::AccumulateClientGlobalLimitedUsage(AccumulateInfo* info,
+                                                      int64 limited_usage) {
+  info->usage += limited_usage;
+  if (--info->pending_clients)
+    return;
+
+  // All the clients have returned their usage data.  Dispatch the
+  // pending callbacks.
+  global_limited_usage_callbacks_.Run(MakeTuple(info->usage));
+}
+
 void UsageTracker::AccumulateClientGlobalUsage(AccumulateInfo* info,
                                                int64 usage,
                                                int64 unlimited_usage) {
   info->usage += usage;
   info->unlimited_usage += unlimited_usage;
-
   if (--info->pending_clients)
     return;
 
   // Defend against confusing inputs from clients.
   if (info->usage < 0)
     info->usage = 0;
 
   // TODO(michaeln): The unlimited number is not trustworthy, it
   // can get out of whack when apps are installed or uninstalled.
   if (info->unlimited_usage > info->usage)
@@ skipping 38 matching lines @@
   DCHECK(client_);
   if (special_storage_policy_)
     special_storage_policy_->AddObserver(this);
 }
 
 ClientUsageTracker::~ClientUsageTracker() {
   if (special_storage_policy_)
     special_storage_policy_->RemoveObserver(this);
 }
 
+void ClientUsageTracker::GetGlobalLimitedUsage(const UsageCallback& callback) {
+  if (!global_usage_retrieved_) {
+    GetGlobalUsage(base::Bind(&DidGetGlobalUsageForLimitedGlobalUsage,
+                              callback));
+    return;
+  }
+
+  if (non_cached_limited_origins_by_host_.empty()) {
+    callback.Run(global_limited_usage_);
+    return;
+  }
+
+  AccumulateInfo* info = new AccumulateInfo;
+  info->pending_jobs = non_cached_limited_origins_by_host_.size() + 1;
+  UsageCallback accumulator = base::Bind(
+      &ClientUsageTracker::AccumulateLimitedOriginUsage, AsWeakPtr(),
+      base::Owned(info), callback);
+
+  for (OriginSetByHost::iterator host_itr =
+           non_cached_limited_origins_by_host_.begin();
+       host_itr != non_cached_limited_origins_by_host_.end(); ++host_itr) {
+    for (std::set<GURL>::iterator origin_itr = host_itr->second.begin();
+         origin_itr != host_itr->second.end(); ++origin_itr)
+      client_->GetOriginUsage(*origin_itr, type_, accumulator);
+  }
+
+  accumulator.Run(global_limited_usage_);
+}
+
 void ClientUsageTracker::GetGlobalUsage(const GlobalUsageCallback& callback) {
   if (global_usage_retrieved_ &&
       non_cached_limited_origins_by_host_.empty() &&
       non_cached_unlimited_origins_by_host_.empty()) {
     callback.Run(global_limited_usage_ + global_unlimited_usage_,
                  global_unlimited_usage_);
     return;
   }
 
   client_->GetOriginsForType(type_, base::Bind(
       &ClientUsageTracker::DidGetOriginsForGlobalUsage, AsWeakPtr(),
       callback));
 }
 
 void ClientUsageTracker::GetHostUsage(
     const std::string& host, const UsageCallback& callback) {
   if (ContainsKey(cached_hosts_, host) &&
       !ContainsKey(non_cached_limited_origins_by_host_, host) &&
       !ContainsKey(non_cached_unlimited_origins_by_host_, host)) {
     // TODO(kinuko): Drop host_usage_map_ cache periodically.
     callback.Run(GetCachedHostUsage(host));
     return;
   }
 
-  if (!host_usage_accumulators_.Add(host, base::Bind(
-          &DidGetHostUsage, callback)))
+  if (!host_usage_accumulators_.Add(
+          host, base::Bind(&DidGetHostUsage, callback)))
     return;
   client_->GetOriginsForHost(type_, host, base::Bind(
       &ClientUsageTracker::DidGetOriginsForHostUsage, AsWeakPtr(), host));
 }
 
 void ClientUsageTracker::UpdateUsageCache(
     const GURL& origin, int64 delta) {
   std::string host = net::GetHostOrSpecFromURL(origin);
   if (cached_hosts_.find(host) != cached_hosts_.end()) {
     if (!IsUsageCacheEnabledForOrigin(origin))
@@ skipping 66 matching lines @@
     if (EraseOriginFromOriginSet(&non_cached_limited_origins_by_host_,
                                  host, origin) ||
         EraseOriginFromOriginSet(&non_cached_unlimited_origins_by_host_,
                                  host, origin)) {
       cached_hosts_.erase(host);
       global_usage_retrieved_ = false;
     }
   }
 }
 
+void ClientUsageTracker::AccumulateLimitedOriginUsage(
+    AccumulateInfo* info,
+    const UsageCallback& callback,
+    int64 usage) {
+  info->limited_usage += usage;
+  if (--info->pending_jobs)
+    return;
+
+  callback.Run(info->limited_usage);
+}
+
 void ClientUsageTracker::DidGetOriginsForGlobalUsage(
     const GlobalUsageCallback& callback,
     const std::set<GURL>& origins) {
   OriginSetByHost origins_by_host;
   for (std::set<GURL>::const_iterator itr = origins.begin();
        itr != origins.end(); ++itr)
     origins_by_host[net::GetHostOrSpecFromURL(*itr)].insert(*itr);
 
   AccumulateInfo* info = new AccumulateInfo;
   // Getting host usage may synchronously return the result if the usage is
@@ skipping 12 matching lines @@
       GetUsageForOrigins(itr->first, itr->second);
   }
 
   // Fire the sentinel as we've now called GetUsageForOrigins for all clients.
   accumulator.Run(0, 0);
 }
 
 void ClientUsageTracker::AccumulateHostUsage(
     AccumulateInfo* info,
     const GlobalUsageCallback& callback,
-    int64 cached_usage,
-    int64 non_cached_usage) {
-  info->cached_usage += cached_usage;
-  info->non_cached_usage += non_cached_usage;
+    int64 limited_usage,
+    int64 unlimited_usage) {
+  info->limited_usage += limited_usage;
+  info->unlimited_usage += unlimited_usage;
   if (--info->pending_jobs)
     return;
 
-  int64 total_usage = info->cached_usage + info->non_cached_usage;
-  int64 unlimited_usage = global_unlimited_usage_ + info->non_cached_usage;
-
-  DCHECK_GE(total_usage, 0);
-  DCHECK_GE(unlimited_usage, 0);
-  if (unlimited_usage > total_usage)
-    unlimited_usage = total_usage;
+  DCHECK_GE(info->limited_usage, 0);
+  DCHECK_GE(info->unlimited_usage, 0);
 
   global_usage_retrieved_ = true;
-  callback.Run(total_usage, unlimited_usage);
+  callback.Run(info->limited_usage + info->unlimited_usage,
+               info->unlimited_usage);
 }
 
 void ClientUsageTracker::DidGetOriginsForHostUsage(
     const std::string& host,
     const std::set<GURL>& origins) {
   GetUsageForOrigins(host, origins);
 }
 
 void ClientUsageTracker::GetUsageForOrigins(
     const std::string& host,
@@ skipping 27 matching lines @@
 }
 
 void ClientUsageTracker::AccumulateOriginUsage(AccumulateInfo* info,
                                                const std::string& host,
                                                const GURL& origin,
                                                int64 usage) {
   if (!origin.is_empty()) {
     if (usage < 0)
       usage = 0;
 
-    if (IsUsageCacheEnabledForOrigin(origin)) {
-      info->cached_usage += usage;
+    if (IsStorageUnlimited(origin))
+      info->unlimited_usage += usage;
+    else
+      info->limited_usage += usage;
+    if (IsUsageCacheEnabledForOrigin(origin))
       AddCachedOrigin(origin, usage);
-    } else {
-      info->non_cached_usage += usage;
-    }
   }
   if (--info->pending_jobs)
     return;
 
   AddCachedHost(host);
   host_usage_accumulators_.Run(
-      host, MakeTuple(info->cached_usage, info->non_cached_usage));
+      host, MakeTuple(info->limited_usage, info->unlimited_usage));
 }
 
 void ClientUsageTracker::AddCachedOrigin(
     const GURL& origin, int64 new_usage) {
-  if (!IsUsageCacheEnabledForOrigin(origin))
-    return;
+  DCHECK(IsUsageCacheEnabledForOrigin(origin));
 
   std::string host = net::GetHostOrSpecFromURL(origin);
   int64* usage = &cached_usage_by_host_[host][origin];
   int64 delta = new_usage - *usage;
   *usage = new_usage;
   if (delta) {
     if (IsStorageUnlimited(origin))
       global_unlimited_usage_ += delta;
     else
       global_limited_usage_ += delta;
@@ skipping 98 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