Quota: Clean up (Client)UsageTracker

storage/browser/quota/client_usage_tracker.cc

 // Copyright 2014 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 "storage/browser/quota/client_usage_tracker.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "net/base/net_util.h"
 #include "storage/browser/quota/storage_monitor.h"
 #include "storage/browser/quota/storage_observer.h"
 
 namespace storage {
 
 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 limited_usage,
                      int64 unlimited_usage) {
   DCHECK_GE(limited_usage, 0);
   DCHECK_GE(unlimited_usage, 0);
   callback.Run(limited_usage + unlimited_usage);
 }
 
 bool EraseOriginFromOriginSet(OriginSetByHost* origins_by_host,
                               const std::string& host,
@@ skipping 59 matching lines @@
     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);
+  for (const auto& host_and_origins : non_cached_limited_origins_by_host_) {
+    for (const auto& origin : host_and_origins.second)
+      client_->GetOriginUsage(origin, 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_,
@@ skipping 48 matching lines @@
   }
 
   // We don't know about this host yet, so populate our cache for it.
   GetHostUsage(host, base::Bind(&ClientUsageTracker::DidGetHostUsageAfterUpdate,
                                 AsWeakPtr(), origin));
 }
 
 void ClientUsageTracker::GetCachedHostsUsage(
     std::map<std::string, int64>* host_usage) const {
   DCHECK(host_usage);
-  for (HostUsageMap::const_iterator host_iter = cached_usage_by_host_.begin();
-       host_iter != cached_usage_by_host_.end(); host_iter++) {
-    const std::string& host = host_iter->first;
+  for (const auto& host_and_usage_map : cached_usage_by_host_) {
+    const std::string& host = host_and_usage_map.first;
     (*host_usage)[host] += GetCachedHostUsage(host);
   }
 }
 
 void ClientUsageTracker::GetCachedOrigins(std::set<GURL>* origins) const {
   DCHECK(origins);
-  for (HostUsageMap::const_iterator host_iter = cached_usage_by_host_.begin();
-       host_iter != cached_usage_by_host_.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);
-    }
+  for (const auto& host_and_usage_map : cached_usage_by_host_) {
+    for (const auto& origin_and_usage : host_and_usage_map.second)
+      origins->insert(origin_and_usage.first);
   }
 }
 
 void ClientUsageTracker::SetUsageCacheEnabled(const GURL& origin,
                                               bool enabled) {
   std::string host = net::GetHostOrSpecFromURL(origin);
   if (!enabled) {
     // Erase |origin| from cache and subtract its usage.
     HostUsageMap::iterator found_host = cached_usage_by_host_.find(host);
     if (found_host != cached_usage_by_host_.end()) {
@@ skipping 36 matching lines @@
   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);
+  for (const auto& origin : origins)
+    origins_by_host[net::GetHostOrSpecFromURL(origin)].insert(origin);
 
   AccumulateInfo* info = new AccumulateInfo;
   // Getting host usage may synchronously return the result if the usage is
   // cached, which may in turn dispatch the completion callback before we finish
   // looping over all hosts (because info->pending_jobs may reach 0 during the
   // loop).  To avoid this, we add one more pending host as a sentinel and
   // fire the sentinel callback at the end.
   info->pending_jobs = origins_by_host.size() + 1;
   HostUsageAccumulator accumulator =
       base::Bind(&ClientUsageTracker::AccumulateHostUsage, AsWeakPtr(),
                  base::Owned(info), callback);
 
-  for (OriginSetByHost::iterator itr = origins_by_host.begin();
-       itr != origins_by_host.end(); ++itr) {
-    if (host_usage_accumulators_.Add(itr->first, accumulator))
-      GetUsageForOrigins(itr->first, itr->second);
+  for (const auto& host_and_origins : origins_by_host) {
+    const std::string& host = host_and_origins.first;
+    const std::set<GURL>& origins = host_and_origins.second;
+    if (host_usage_accumulators_.Add(host, accumulator))
+      GetUsageForOrigins(host, origins);
   }
 
   // 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 limited_usage,
@@ skipping 24 matching lines @@
   // Getting origin usage may synchronously return the result if the usage is
   // cached, which may in turn dispatch the completion callback before we finish
   // looping over all origins (because info->pending_jobs may reach 0 during the
   // loop).  To avoid this, we add one more pending origin as a sentinel and
   // fire the sentinel callback at the end.
   info->pending_jobs = origins.size() + 1;
   OriginUsageAccumulator accumulator =
       base::Bind(&ClientUsageTracker::AccumulateOriginUsage, AsWeakPtr(),
                  base::Owned(info), host);
 
-  for (std::set<GURL>::const_iterator itr = origins.begin();
-       itr != origins.end(); ++itr) {
-    DCHECK_EQ(host, net::GetHostOrSpecFromURL(*itr));
+  for (const auto& origin : origins) {
+    DCHECK_EQ(host, net::GetHostOrSpecFromURL(origin));
 
     int64 origin_usage = 0;
-    if (GetCachedOriginUsage(*itr, &origin_usage)) {
-      accumulator.Run(*itr, origin_usage);
-    } else {
-      client_->GetOriginUsage(*itr, type_, base::Bind(
-          &DidGetOriginUsage, accumulator, *itr));
-    }
+    if (GetCachedOriginUsage(origin, &origin_usage))
+      accumulator.Run(origin, origin_usage);
+    else
+      client_->GetOriginUsage(origin, type_, base::Bind(accumulator, origin));
   }
 
   // Fire the sentinel as we've now called GetOriginUsage for all clients.
   accumulator.Run(GURL(), 0);
 }
 
 void ClientUsageTracker::AccumulateOriginUsage(AccumulateInfo* info,
                                                const std::string& host,
                                                const GURL& origin,
                                                int64 usage) {
@@ skipping 46 matching lines @@
 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;
 
   int64 usage = 0;
-  const UsageMap& map = found->second;
-  for (UsageMap::const_iterator iter = map.begin();
-       iter != map.end(); ++iter) {
-    usage += iter->second;
-  }
+  const UsageMap& usage_map = found->second;
+  for (const auto& origin_and_usage : usage_map)
+    usage += origin_and_usage.second;
   return usage;
 }
 
 bool ClientUsageTracker::GetCachedOriginUsage(
     const GURL& origin,
     int64* usage) const {
   std::string host = net::GetHostOrSpecFromURL(origin);
   HostUsageMap::const_iterator found_host = cached_usage_by_host_.find(host);
   if (found_host == cached_usage_by_host_.end())
     return false;
@@ skipping 48 matching lines @@
                                  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);
+  for (const auto& host_and_origins : non_cached_unlimited_origins_by_host_) {
+    const auto& host = host_and_origins.first;
+    for (const auto& origin : host_and_origins.second)
+      non_cached_limited_origins_by_host_[host].insert(origin);
   }
   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 storage