[Quota] Refine usage handling in ClientUsageTracker.

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>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "net/base/net_util.h"
 
 namespace quota {
 
 namespace {
 
 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);
 }
 
 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;
+
+  if (!found->second.erase(origin))
+    return false;
+
+  if (found->second.empty())
+    origins_by_host->erase(host);
+  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);
+}
+
 }  // 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();
@@ skipping 145 matching lines @@
 }
 
 // ClientUsageTracker ----------------------------------------------------
 
 ClientUsageTracker::ClientUsageTracker(
     UsageTracker* tracker, QuotaClient* client, StorageType type,
     SpecialStoragePolicy* special_storage_policy)
     : tracker_(tracker),
       client_(client),
       type_(type),
-      global_usage_(0),
+      global_limited_usage_(0),
       global_unlimited_usage_(0),
       global_usage_retrieved_(false),
       special_storage_policy_(special_storage_policy) {
   DCHECK(tracker_);
   DCHECK(client_);
   if (special_storage_policy_)
     special_storage_policy_->AddObserver(this);
 }
 
 ClientUsageTracker::~ClientUsageTracker() {
   if (special_storage_policy_)
     special_storage_policy_->RemoveObserver(this);
 }
 
 void ClientUsageTracker::GetGlobalUsage(const GlobalUsageCallback& callback) {
-  if (global_usage_retrieved_ && non_cached_origins_by_host_.empty()) {
-    callback.Run(global_usage_, global_unlimited_usage_);
+  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_origins_by_host_, 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)))
     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))
       return;
 
     cached_usage_by_host_[host][origin] += delta;
-    global_usage_ += delta;
     if (IsStorageUnlimited(origin))
       global_unlimited_usage_ += delta;
+    else
+      global_limited_usage_ += delta;
     DCHECK_GE(cached_usage_by_host_[host][origin], 0);
-    DCHECK_GE(global_usage_, 0);
+    DCHECK_GE(global_limited_usage_, 0);
     return;
   }
 
   // We don't know about this host yet, so populate our cache for it.
   GetHostUsage(host, base::Bind(&NoopHostUsageCallback));
 }
 
 void ClientUsageTracker::GetCachedHostsUsage(
     std::map<std::string, int64>* host_usage) const {
   DCHECK(host_usage);
@@ skipping 30 matching lines @@
         int64 usage = found->second;
         UpdateUsageCache(origin, -usage);
         cached_usage_for_host.erase(found);
         if (cached_usage_for_host.empty()) {
           cached_usage_by_host_.erase(found_host);
           cached_hosts_.erase(host);
         }
       }
     }
 
-    non_cached_origins_by_host_[host].insert(origin);
+    if (IsStorageUnlimited(origin))
+      non_cached_unlimited_origins_by_host_[host].insert(origin);
+    else
+      non_cached_limited_origins_by_host_[host].insert(origin);
   } else {
     // Erase |origin| from |non_cached_origins_| and invalidate the usage cache
     // for the host.
-    OriginSetByHost::iterator found = non_cached_origins_by_host_.find(host);
-    if (found == non_cached_origins_by_host_.end())
-      return;
-
-    found->second.erase(origin);
-    if (found->second.empty()) {
-      non_cached_origins_by_host_.erase(found);
+    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::DidGetOriginsForGlobalUsage(
     const GlobalUsageCallback& callback,
     const std::set<GURL>& origins, StorageType type) {
   OriginSetByHost origins_by_host;
@@ skipping 99 matching lines @@
   }
   if (--info->pending_jobs)
     return;
 
   AddCachedHost(host);
   host_usage_accumulators_.Run(
       host, MakeTuple(info->cached_usage, info->non_cached_usage));
 }
 
 void ClientUsageTracker::AddCachedOrigin(
-    const GURL& origin, int64 usage) {
+    const GURL& origin, int64 new_usage) {
   if (!IsUsageCacheEnabledForOrigin(origin))
     return;
 
   std::string host = net::GetHostOrSpecFromURL(origin);
-  UsageMap::iterator iter = cached_usage_by_host_[host].
-      insert(UsageMap::value_type(origin, 0)).first;
-  int64 old_usage = iter->second;
-  iter->second = usage;
-  int64 delta = usage - old_usage;
+  int64* usage = &cached_usage_by_host_[host][origin];
+  int64 delta = new_usage - *usage;
+  *usage = new_usage;
   if (delta) {
-    global_usage_ += delta;
     if (IsStorageUnlimited(origin))
       global_unlimited_usage_ += delta;
+    else
+      global_limited_usage_ += delta;
   }
-  DCHECK_GE(iter->second, 0);
-  DCHECK_GE(global_usage_, 0);
+  DCHECK_GE(*usage, 0);
+  DCHECK_GE(global_limited_usage_, 0);
 }
 
 void ClientUsageTracker::AddCachedHost(const std::string& host) {
   cached_hosts_.insert(host);
 }
 
 int64 ClientUsageTracker::GetCachedHostUsage(const std::string& host) const {
   HostUsageMap::const_iterator found = cached_usage_by_host_.find(host);
   if (found == cached_usage_by_host_.end())
     return 0;
@@ skipping 20 matching lines @@
     return false;
 
   DCHECK(IsUsageCacheEnabledForOrigin(origin));
   *usage = found->second;
   return true;
 }
 
 bool ClientUsageTracker::IsUsageCacheEnabledForOrigin(
     const GURL& origin) const {
   std::string host = net::GetHostOrSpecFromURL(origin);
-  OriginSetByHost::const_iterator found =
-      non_cached_origins_by_host_.find(host);
-  return found == non_cached_origins_by_host_.end() ||
-      !ContainsKey(found->second, origin);
+  return !OriginSetContainsOrigin(non_cached_limited_origins_by_host_,
+                                  host, origin) &&
+      !OriginSetContainsOrigin(non_cached_unlimited_origins_by_host_,
+                               host, origin);
 }
 
 void ClientUsageTracker::OnGranted(const GURL& origin,
                                    int change_flags) {
   DCHECK(CalledOnValidThread());
   if (change_flags & SpecialStoragePolicy::STORAGE_UNLIMITED) {
     int64 usage = 0;
-    if (GetCachedOriginUsage(origin, &usage))
+    if (GetCachedOriginUsage(origin, &usage)) {
       global_unlimited_usage_ += usage;
+      global_limited_usage_ -= usage;
+    }
+
+    std::string host = net::GetHostOrSpecFromURL(origin);
+    if (EraseOriginFromOriginSet(&non_cached_limited_origins_by_host_,
+                                 host, origin))
+      non_cached_unlimited_origins_by_host_[host].insert(origin);
   }
 }
 
 void ClientUsageTracker::OnRevoked(const GURL& origin,
                                    int change_flags) {
   DCHECK(CalledOnValidThread());
   if (change_flags & SpecialStoragePolicy::STORAGE_UNLIMITED) {
     int64 usage = 0;
-    if (GetCachedOriginUsage(origin, &usage))
+    if (GetCachedOriginUsage(origin, &usage)) {
       global_unlimited_usage_ -= usage;
+      global_limited_usage_ += usage;
+    }
+
+    std::string host = net::GetHostOrSpecFromURL(origin);
+    if (EraseOriginFromOriginSet(&non_cached_unlimited_origins_by_host_,
+                                 host, origin))
+      non_cached_limited_origins_by_host_[host].insert(origin);
   }
 }
 
 void ClientUsageTracker::OnCleared() {
   DCHECK(CalledOnValidThread());
+  global_limited_usage_ += global_unlimited_usage_;
   global_unlimited_usage_ = 0;
+
+  for (OriginSetByHost::const_iterator host_itr =
+           non_cached_unlimited_origins_by_host_.begin();
+       host_itr != non_cached_unlimited_origins_by_host_.end();
+       ++host_itr) {
+    for (std::set<GURL>::const_iterator origin_itr = host_itr->second.begin();
+         origin_itr != host_itr->second.end();
+         ++origin_itr)
+      non_cached_limited_origins_by_host_[host_itr->first].insert(*origin_itr);
+  }
+  non_cached_unlimited_origins_by_host_.clear();
 }
 
 bool ClientUsageTracker::IsStorageUnlimited(const GURL& origin) const {
   if (type_ == kStorageTypeSyncable)
     return false;
   return special_storage_policy_.get() &&
          special_storage_policy_->IsStorageUnlimited(origin);
 }
 
 }  // namespace quota