Migrate webkit/browser/ to storage/browser/

webkit/browser/quota/usage_tracker.cc

Index: webkit/browser/quota/usage_tracker.cc
diff --git a/webkit/browser/quota/usage_tracker.cc b/webkit/browser/quota/usage_tracker.cc
deleted file mode 100644
index c2aa4c66bad622d4f11b86d2a35604763389db44..0000000000000000000000000000000000000000
--- a/webkit/browser/quota/usage_tracker.cc
+++ /dev/null
@@ -1,694 +0,0 @@
-// Copyright 2013 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/browser/quota/usage_tracker.h"
-
-#include <algorithm>
-#include <deque>
-#include <set>
-#include <string>
-#include <vector>
-
-#include "base/bind.h"
-#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"
-
-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,
-                              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);
-}
-
-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,
-                           StorageMonitor* storage_monitor)
-    : type_(type),
-      storage_monitor_(storage_monitor),
-      weak_factory_(this) {
-  for (QuotaClientList::const_iterator iter = clients.begin();
-      iter != clients.end();
-      ++iter) {
-    if ((*iter)->DoesSupport(type)) {
-      client_tracker_map_[(*iter)->id()] =
-          new ClientUsageTracker(this, *iter, type, special_storage_policy,
-                                 storage_monitor_);
-    }
-  }
-}
-
-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) {
-  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);
-}
-
-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).
-  // 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));
-
-  for (ClientTrackerMap::iterator iter = client_tracker_map_.begin();
-       iter != client_tracker_map_.end();
-       ++iter)
-    iter->second->GetGlobalUsage(accumulator);
-
-  // Fire the sentinel as we've now called GetGlobalUsage for all clients.
-  accumulator.Run(0, 0);
-}
-
-void UsageTracker::GetHostUsage(const std::string& host,
-                                const UsageCallback& callback) {
-  if (!host_usage_callbacks_.Add(host, callback))
-    return;
-
-  AccumulateInfo* info = new AccumulateInfo;
-  // Calling GetHostUsage(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::AccumulateClientHostUsage, weak_factory_.GetWeakPtr(),
-      base::Owned(info), host);
-
-  for (ClientTrackerMap::iterator iter = client_tracker_map_.begin();
-       iter != client_tracker_map_.end();
-       ++iter)
-    iter->second->GetHostUsage(host, accumulator);
-
-  // Fire the sentinel as we've now called GetHostUsage for all clients.
-  accumulator.Run(0);
-}
-
-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);
-}
-
-void UsageTracker::GetCachedHostsUsage(
-    std::map<std::string, int64>* host_usage) const {
-  DCHECK(host_usage);
-  host_usage->clear();
-  for (ClientTrackerMap::const_iterator iter = client_tracker_map_.begin();
-       iter != client_tracker_map_.end(); ++iter) {
-    iter->second->GetCachedHostsUsage(host_usage);
-  }
-}
-
-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->second->GetCachedOrigins(origins);
-  }
-}
-
-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)
-    info->unlimited_usage = info->usage;
-  else if (info->unlimited_usage < 0)
-    info->unlimited_usage = 0;
-
-  // All the clients have returned their usage data.  Dispatch the
-  // pending callbacks.
-  global_usage_callbacks_.Run(MakeTuple(info->usage, info->unlimited_usage));
-}
-
-void UsageTracker::AccumulateClientHostUsage(AccumulateInfo* info,
-                                             const std::string& host,
-                                             int64 usage) {
-  info->usage += usage;
-  if (--info->pending_clients)
-    return;
-
-  // Defend against confusing inputs from clients.
-  if (info->usage < 0)
-    info->usage = 0;
-
-  // All the clients have returned their usage data.  Dispatch the
-  // pending callbacks.
-  host_usage_callbacks_.Run(host, MakeTuple(info->usage));
-}
-
-// ClientUsageTracker ----------------------------------------------------
-
-ClientUsageTracker::ClientUsageTracker(
-    UsageTracker* tracker, QuotaClient* client, StorageType type,
-    SpecialStoragePolicy* special_storage_policy,
-    StorageMonitor* storage_monitor)
-    : tracker_(tracker),
-      client_(client),
-      type_(type),
-      storage_monitor_(storage_monitor),
-      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_.get())
-    special_storage_policy_->AddObserver(this);
-}
-
-ClientUsageTracker::~ClientUsageTracker() {
-  if (special_storage_policy_.get())
-    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)))
-    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;
-    if (IsStorageUnlimited(origin))
-      global_unlimited_usage_ += delta;
-    else
-      global_limited_usage_ += delta;
-    DCHECK_GE(cached_usage_by_host_[host][origin], 0);
-    DCHECK_GE(global_limited_usage_, 0);
-
-    // Notify the usage monitor that usage has changed. The storage monitor may
-    // be NULL during tests.
-    if (storage_monitor_) {
-      StorageObserver::Filter filter(type_, origin);
-      storage_monitor_->NotifyUsageChange(filter, delta);
-    }
-    return;
-  }
-
-  // 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;
-    (*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);
-    }
-  }
-}
-
-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()) {
-      UsageMap& cached_usage_for_host = found_host->second;
-
-      UsageMap::iterator found = cached_usage_for_host.find(origin);
-      if (found != cached_usage_for_host.end()) {
-        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);
-        }
-      }
-    }
-
-    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.
-    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
-  // 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);
-  }
-
-  // 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,
-    int64 unlimited_usage) {
-  info->limited_usage += limited_usage;
-  info->unlimited_usage += unlimited_usage;
-  if (--info->pending_jobs)
-    return;
-
-  DCHECK_GE(info->limited_usage, 0);
-  DCHECK_GE(info->unlimited_usage, 0);
-
-  global_usage_retrieved_ = true;
-  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,
-    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
-  // 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));
-
-    int64 origin_usage = 0;
-    if (GetCachedOriginUsage(*itr, &origin_usage)) {
-      accumulator.Run(*itr, origin_usage);
-    } else {
-      client_->GetOriginUsage(*itr, type_, base::Bind(
-          &DidGetOriginUsage, accumulator, *itr));
-    }
-  }
-
-  // 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) {
-  if (!origin.is_empty()) {
-    if (usage < 0)
-      usage = 0;
-
-    if (IsStorageUnlimited(origin))
-      info->unlimited_usage += usage;
-    else
-      info->limited_usage += usage;
-    if (IsUsageCacheEnabledForOrigin(origin))
-      AddCachedOrigin(origin, usage);
-  }
-  if (--info->pending_jobs)
-    return;
-
-  AddCachedHost(host);
-  host_usage_accumulators_.Run(
-      host, MakeTuple(info->limited_usage, info->unlimited_usage));
-}
-
-void ClientUsageTracker::DidGetHostUsageAfterUpdate(
-    const GURL& origin, int64 usage) {
-  if (!storage_monitor_)
-    return;
-
-  StorageObserver::Filter filter(type_, origin);
-  storage_monitor_->NotifyUsageChange(filter, 0);
-}
-
-void ClientUsageTracker::AddCachedOrigin(
-    const GURL& origin, int64 new_usage) {
-  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;
-  }
-  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;
-
-  int64 usage = 0;
-  const UsageMap& map = found->second;
-  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 {
-  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;
-
-  UsageMap::const_iterator found = found_host->second.find(origin);
-  if (found == found_host->second.end())
-    return false;
-
-  DCHECK(IsUsageCacheEnabledForOrigin(origin));
-  *usage = found->second;
-  return true;
-}
-
-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);
-}
-
-void ClientUsageTracker::OnGranted(const GURL& origin,
-                                   int change_flags) {
-  DCHECK(CalledOnValidThread());
-  if (change_flags & SpecialStoragePolicy::STORAGE_UNLIMITED) {
-    int64 usage = 0;
-    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)) {
-      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 storage