Provide monitoring of usage for a storage type and origin

webkit/browser/quota/usage_tracker.cc

 // 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 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 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;
 
   if (!found->second.erase(origin))
     return false;
 
@@ skipping 14 matching lines @@
                                             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)
+                           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);
+          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);
@@ skipping 170 matching lines @@
 
   // 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)
+    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);
 }
 
@@ skipping 69 matching lines @@
     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(&NoopHostUsageCallback));
+  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);
   }
@@ skipping 160 matching lines @@
       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))
@@ skipping 101 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