Index: storage/browser/quota/usage_tracker.cc |
diff --git a/webkit/browser/quota/usage_tracker.cc b/storage/browser/quota/usage_tracker.cc |
similarity index 80% |
rename from webkit/browser/quota/usage_tracker.cc |
rename to storage/browser/quota/usage_tracker.cc |
index 2e4659f0e483fc016653e0f9e37d93bcf79970c2..978c1153a8e138077fdb176e002f9bb6aed43589 100644 |
--- a/webkit/browser/quota/usage_tracker.cc |
+++ b/storage/browser/quota/usage_tracker.cc |
@@ -2,7 +2,7 @@ |
// Use of this source code is governed by a BSD-style license that can be |
// found in the LICENSE file. |
-#include "webkit/browser/quota/usage_tracker.h" |
+#include "storage/browser/quota/usage_tracker.h" |
#include <algorithm> |
#include <deque> |
@@ -14,8 +14,8 @@ |
#include "base/message_loop/message_loop_proxy.h" |
#include "base/stl_util.h" |
#include "net/base/net_util.h" |
-#include "webkit/browser/quota/storage_monitor.h" |
-#include "webkit/browser/quota/storage_observer.h" |
+#include "storage/browser/quota/storage_monitor.h" |
+#include "storage/browser/quota/storage_observer.h" |
namespace quota { |
@@ -74,16 +74,13 @@ UsageTracker::UsageTracker(const QuotaClientList& clients, |
StorageType type, |
SpecialStoragePolicy* special_storage_policy, |
StorageMonitor* storage_monitor) |
- : type_(type), |
- storage_monitor_(storage_monitor), |
- weak_factory_(this) { |
+ : type_(type), storage_monitor_(storage_monitor), weak_factory_(this) { |
for (QuotaClientList::const_iterator iter = clients.begin(); |
- iter != clients.end(); |
- ++iter) { |
+ iter != clients.end(); |
+ ++iter) { |
if ((*iter)->DoesSupport(type)) { |
- client_tracker_map_[(*iter)->id()] = |
- new ClientUsageTracker(this, *iter, type, special_storage_policy, |
- storage_monitor_); |
+ client_tracker_map_[(*iter)->id()] = new ClientUsageTracker( |
+ this, *iter, type, special_storage_policy, storage_monitor_); |
} |
} |
} |
@@ -101,8 +98,8 @@ ClientUsageTracker* UsageTracker::GetClientTracker(QuotaClient::ID client_id) { |
void UsageTracker::GetGlobalLimitedUsage(const UsageCallback& callback) { |
if (global_usage_callbacks_.HasCallbacks()) { |
- global_usage_callbacks_.Add(base::Bind( |
- &DidGetGlobalUsageForLimitedGlobalUsage, callback)); |
+ global_usage_callbacks_.Add( |
+ base::Bind(&DidGetGlobalUsageForLimitedGlobalUsage, callback)); |
return; |
} |
@@ -118,9 +115,10 @@ void UsageTracker::GetGlobalLimitedUsage(const UsageCallback& callback) { |
// 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)); |
+ 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(); |
@@ -144,9 +142,10 @@ void UsageTracker::GetGlobalUsage(const GlobalUsageCallback& callback) { |
// 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; |
- GlobalUsageCallback accumulator = base::Bind( |
- &UsageTracker::AccumulateClientGlobalUsage, weak_factory_.GetWeakPtr(), |
- base::Owned(info)); |
+ GlobalUsageCallback accumulator = |
+ base::Bind(&UsageTracker::AccumulateClientGlobalUsage, |
+ weak_factory_.GetWeakPtr(), |
+ base::Owned(info)); |
for (ClientTrackerMap::iterator iter = client_tracker_map_.begin(); |
iter != client_tracker_map_.end(); |
@@ -171,9 +170,11 @@ void UsageTracker::GetHostUsage(const std::string& host, |
// 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::AccumulateClientHostUsage, weak_factory_.GetWeakPtr(), |
- base::Owned(info), host); |
+ UsageCallback accumulator = |
+ base::Bind(&UsageTracker::AccumulateClientHostUsage, |
+ weak_factory_.GetWeakPtr(), |
+ base::Owned(info), |
+ host); |
for (ClientTrackerMap::iterator iter = client_tracker_map_.begin(); |
iter != client_tracker_map_.end(); |
@@ -184,8 +185,9 @@ void UsageTracker::GetHostUsage(const std::string& host, |
accumulator.Run(0); |
} |
-void UsageTracker::UpdateUsageCache( |
- QuotaClient::ID client_id, const GURL& origin, int64 delta) { |
+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); |
@@ -196,7 +198,8 @@ void UsageTracker::GetCachedHostsUsage( |
DCHECK(host_usage); |
host_usage->clear(); |
for (ClientTrackerMap::const_iterator iter = client_tracker_map_.begin(); |
- iter != client_tracker_map_.end(); ++iter) { |
+ iter != client_tracker_map_.end(); |
+ ++iter) { |
iter->second->GetCachedHostsUsage(host_usage); |
} |
} |
@@ -205,7 +208,8 @@ 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 != client_tracker_map_.end(); |
+ ++iter) { |
iter->second->GetCachedOrigins(origins); |
} |
} |
@@ -273,7 +277,9 @@ void UsageTracker::AccumulateClientHostUsage(AccumulateInfo* info, |
// ClientUsageTracker ---------------------------------------------------- |
ClientUsageTracker::ClientUsageTracker( |
- UsageTracker* tracker, QuotaClient* client, StorageType type, |
+ UsageTracker* tracker, |
+ QuotaClient* client, |
+ StorageType type, |
SpecialStoragePolicy* special_storage_policy, |
StorageMonitor* storage_monitor) |
: tracker_(tracker), |
@@ -297,8 +303,8 @@ ClientUsageTracker::~ClientUsageTracker() { |
void ClientUsageTracker::GetGlobalLimitedUsage(const UsageCallback& callback) { |
if (!global_usage_retrieved_) { |
- GetGlobalUsage(base::Bind(&DidGetGlobalUsageForLimitedGlobalUsage, |
- callback)); |
+ GetGlobalUsage( |
+ base::Bind(&DidGetGlobalUsageForLimitedGlobalUsage, callback)); |
return; |
} |
@@ -309,15 +315,19 @@ void ClientUsageTracker::GetGlobalLimitedUsage(const UsageCallback& callback) { |
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); |
+ 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) { |
+ 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) |
+ origin_itr != host_itr->second.end(); |
+ ++origin_itr) |
client_->GetOriginUsage(*origin_itr, type_, accumulator); |
} |
@@ -325,21 +335,22 @@ void ClientUsageTracker::GetGlobalLimitedUsage(const UsageCallback& callback) { |
} |
void ClientUsageTracker::GetGlobalUsage(const GlobalUsageCallback& callback) { |
- if (global_usage_retrieved_ && |
- non_cached_limited_origins_by_host_.empty() && |
+ 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)); |
+ client_->GetOriginsForType( |
+ type_, |
+ base::Bind(&ClientUsageTracker::DidGetOriginsForGlobalUsage, |
+ AsWeakPtr(), |
+ callback)); |
} |
-void ClientUsageTracker::GetHostUsage( |
- const std::string& host, const UsageCallback& 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)) { |
@@ -348,15 +359,17 @@ void ClientUsageTracker::GetHostUsage( |
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)); |
+ client_->GetOriginsForHost( |
+ type_, |
+ host, |
+ base::Bind( |
+ &ClientUsageTracker::DidGetOriginsForHostUsage, AsWeakPtr(), host)); |
} |
-void ClientUsageTracker::UpdateUsageCache( |
- const GURL& origin, int64 delta) { |
+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)) |
@@ -380,15 +393,18 @@ void ClientUsageTracker::UpdateUsageCache( |
} |
// We don't know about this host yet, so populate our cache for it. |
- GetHostUsage(host, base::Bind(&ClientUsageTracker::DidGetHostUsageAfterUpdate, |
- AsWeakPtr(), origin)); |
+ 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++) { |
+ host_iter != cached_usage_by_host_.end(); |
+ host_iter++) { |
const std::string& host = host_iter->first; |
(*host_usage)[host] += GetCachedHostUsage(host); |
} |
@@ -397,10 +413,12 @@ void ClientUsageTracker::GetCachedHostsUsage( |
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++) { |
+ 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++) { |
+ origin_iter != origin_map.end(); |
+ origin_iter++) { |
origins->insert(origin_iter->first); |
} |
} |
@@ -434,10 +452,10 @@ void ClientUsageTracker::SetUsageCacheEnabled(const GURL& origin, |
} else { |
// Erase |origin| from |non_cached_origins_| and invalidate the usage cache |
// for the host. |
- if (EraseOriginFromOriginSet(&non_cached_limited_origins_by_host_, |
- host, origin) || |
- EraseOriginFromOriginSet(&non_cached_unlimited_origins_by_host_, |
- host, origin)) { |
+ 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; |
} |
@@ -460,7 +478,8 @@ void ClientUsageTracker::DidGetOriginsForGlobalUsage( |
const std::set<GURL>& origins) { |
OriginSetByHost origins_by_host; |
for (std::set<GURL>::const_iterator itr = origins.begin(); |
- itr != origins.end(); ++itr) |
+ itr != origins.end(); |
+ ++itr) |
origins_by_host[net::GetHostOrSpecFromURL(*itr)].insert(*itr); |
AccumulateInfo* info = new AccumulateInfo; |
@@ -471,11 +490,14 @@ void ClientUsageTracker::DidGetOriginsForGlobalUsage( |
// 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); |
+ base::Bind(&ClientUsageTracker::AccumulateHostUsage, |
+ AsWeakPtr(), |
+ base::Owned(info), |
+ callback); |
for (OriginSetByHost::iterator itr = origins_by_host.begin(); |
- itr != origins_by_host.end(); ++itr) { |
+ itr != origins_by_host.end(); |
+ ++itr) { |
if (host_usage_accumulators_.Add(itr->first, accumulator)) |
GetUsageForOrigins(itr->first, itr->second); |
} |
@@ -508,9 +530,8 @@ void ClientUsageTracker::DidGetOriginsForHostUsage( |
GetUsageForOrigins(host, origins); |
} |
-void ClientUsageTracker::GetUsageForOrigins( |
- const std::string& host, |
- const std::set<GURL>& origins) { |
+void ClientUsageTracker::GetUsageForOrigins(const std::string& host, |
+ const std::set<GURL>& origins) { |
AccumulateInfo* info = new AccumulateInfo; |
// Getting origin usage may synchronously return the result if the usage is |
// cached, which may in turn dispatch the completion callback before we finish |
@@ -519,19 +540,22 @@ void ClientUsageTracker::GetUsageForOrigins( |
// fire the sentinel callback at the end. |
info->pending_jobs = origins.size() + 1; |
OriginUsageAccumulator accumulator = |
- base::Bind(&ClientUsageTracker::AccumulateOriginUsage, AsWeakPtr(), |
- base::Owned(info), host); |
+ base::Bind(&ClientUsageTracker::AccumulateOriginUsage, |
+ AsWeakPtr(), |
+ base::Owned(info), |
+ host); |
for (std::set<GURL>::const_iterator itr = origins.begin(); |
- itr != origins.end(); ++itr) { |
+ itr != origins.end(); |
+ ++itr) { |
DCHECK_EQ(host, net::GetHostOrSpecFromURL(*itr)); |
int64 origin_usage = 0; |
if (GetCachedOriginUsage(*itr, &origin_usage)) { |
accumulator.Run(*itr, origin_usage); |
} else { |
- client_->GetOriginUsage(*itr, type_, base::Bind( |
- &DidGetOriginUsage, accumulator, *itr)); |
+ client_->GetOriginUsage( |
+ *itr, type_, base::Bind(&DidGetOriginUsage, accumulator, *itr)); |
} |
} |
@@ -562,8 +586,8 @@ void ClientUsageTracker::AccumulateOriginUsage(AccumulateInfo* info, |
host, MakeTuple(info->limited_usage, info->unlimited_usage)); |
} |
-void ClientUsageTracker::DidGetHostUsageAfterUpdate( |
- const GURL& origin, int64 usage) { |
+void ClientUsageTracker::DidGetHostUsageAfterUpdate(const GURL& origin, |
+ int64 usage) { |
if (!storage_monitor_) |
return; |
@@ -571,8 +595,7 @@ void ClientUsageTracker::DidGetHostUsageAfterUpdate( |
storage_monitor_->NotifyUsageChange(filter, 0); |
} |
-void ClientUsageTracker::AddCachedOrigin( |
- const GURL& origin, int64 new_usage) { |
+void ClientUsageTracker::AddCachedOrigin(const GURL& origin, int64 new_usage) { |
DCHECK(IsUsageCacheEnabledForOrigin(origin)); |
std::string host = net::GetHostOrSpecFromURL(origin); |
@@ -600,16 +623,14 @@ int64 ClientUsageTracker::GetCachedHostUsage(const std::string& host) const { |
int64 usage = 0; |
const UsageMap& map = found->second; |
- for (UsageMap::const_iterator iter = map.begin(); |
- iter != map.end(); ++iter) { |
+ for (UsageMap::const_iterator iter = map.begin(); iter != map.end(); ++iter) { |
usage += iter->second; |
} |
return usage; |
} |
-bool ClientUsageTracker::GetCachedOriginUsage( |
- const GURL& origin, |
- int64* usage) const { |
+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()) |
@@ -627,14 +648,13 @@ bool ClientUsageTracker::GetCachedOriginUsage( |
bool ClientUsageTracker::IsUsageCacheEnabledForOrigin( |
const GURL& origin) const { |
std::string host = net::GetHostOrSpecFromURL(origin); |
- return !OriginSetContainsOrigin(non_cached_limited_origins_by_host_, |
- host, origin) && |
- !OriginSetContainsOrigin(non_cached_unlimited_origins_by_host_, |
- host, 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) { |
+void ClientUsageTracker::OnGranted(const GURL& origin, int change_flags) { |
DCHECK(CalledOnValidThread()); |
if (change_flags & SpecialStoragePolicy::STORAGE_UNLIMITED) { |
int64 usage = 0; |
@@ -644,14 +664,13 @@ void ClientUsageTracker::OnGranted(const GURL& origin, |
} |
std::string host = net::GetHostOrSpecFromURL(origin); |
- if (EraseOriginFromOriginSet(&non_cached_limited_origins_by_host_, |
- host, 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) { |
+void ClientUsageTracker::OnRevoked(const GURL& origin, int change_flags) { |
DCHECK(CalledOnValidThread()); |
if (change_flags & SpecialStoragePolicy::STORAGE_UNLIMITED) { |
int64 usage = 0; |
@@ -661,8 +680,8 @@ void ClientUsageTracker::OnRevoked(const GURL& origin, |
} |
std::string host = net::GetHostOrSpecFromURL(origin); |
- if (EraseOriginFromOriginSet(&non_cached_unlimited_origins_by_host_, |
- host, origin)) |
+ if (EraseOriginFromOriginSet( |
+ &non_cached_unlimited_origins_by_host_, host, origin)) |
non_cached_limited_origins_by_host_[host].insert(origin); |
} |
} |