Send notifications on the IO thread when changes are made to the special storage policy. Listen f...

webkit/quota/usage_tracker.cc

 // Copyright (c) 2011 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 "base/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "net/base/net_util.h"
-#include "webkit/quota/special_storage_policy.h"
 
 namespace quota {
 
 namespace {
 bool SortByHost(const GURL& lhs, const GURL& rhs) {
   return net::GetHostOrSpecFromURL(lhs) > net::GetHostOrSpecFromURL(rhs);
 }
 }
 
 // A task class for getting the total amount of data used for a collection of
@@ skipping 301 matching lines @@
 
 ClientUsageTracker::ClientUsageTracker(
     UsageTracker* tracker, QuotaClient* client, StorageType type,
     SpecialStoragePolicy* special_storage_policy)
     : tracker_(tracker),
       client_(client),
       type_(type),
       global_usage_(0),
       global_unlimited_usage_(0),
       global_usage_retrieved_(false),
+      global_unlimited_usage_is_valid_(true),
       global_usage_task_(NULL),
       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(GlobalUsageCallback* callback) {
   if (global_usage_retrieved_) {
-    callback->Run(type_, global_usage_, global_unlimited_usage_);
+    callback->Run(type_, global_usage_, GetCachedGlobalUnlimitedUsage());
     delete callback;
     return;
   }
   DCHECK(!global_usage_callback_.HasCallbacks());
   global_usage_callback_.Add(callback);
   global_usage_task_ = new GatherGlobalUsageTask(tracker_, client_);
   global_usage_task_->Start();
 }
 
 void ClientUsageTracker::GetHostUsage(
@@ skipping 11 matching lines @@
   host_usage_tasks_[host] = task;
   task->Start();
 }
 
 void ClientUsageTracker::UpdateUsageCache(
     const GURL& origin, int64 delta) {
   std::string host = net::GetHostOrSpecFromURL(origin);
   if (cached_hosts_.find(host) != cached_hosts_.end()) {
     cached_usage_[host][origin] += delta;
     global_usage_ += delta;
-    if (IsStorageUnlimited(origin))
+    if (global_unlimited_usage_is_valid_ && IsStorageUnlimited(origin))
       global_unlimited_usage_ += delta;
     DCHECK_GE(cached_usage_[host][origin], 0);
     DCHECK_GE(global_usage_, 0);
     return;
   }
 
   // We don't know about this host yet, so populate our cache for it.
   GetHostUsage(host,
                NewCallback(this, &ClientUsageTracker::NoopHostUsageCallback));
 }
@@ skipping 13 matching lines @@
 void ClientUsageTracker::AddCachedOrigin(
     const GURL& origin, int64 usage) {
   std::string host = net::GetHostOrSpecFromURL(origin);
   UsageMap::iterator iter = cached_usage_[host].
       insert(UsageMap::value_type(origin, 0)).first;
   int64 old_usage = iter->second;
   iter->second = usage;
   int64 delta = usage - old_usage;
   if (delta) {
     global_usage_ += delta;
-    if (IsStorageUnlimited(origin))
+    if (global_unlimited_usage_is_valid_ && IsStorageUnlimited(origin))
       global_unlimited_usage_ += delta;
   }
   DCHECK_GE(iter->second, 0);
   DCHECK_GE(global_usage_, 0);
 }
 
 void ClientUsageTracker::AddCachedHost(const std::string& host) {
   cached_hosts_.insert(host);
 }
 
 void ClientUsageTracker::GatherGlobalUsageComplete() {
   DCHECK(global_usage_task_ != NULL);
   global_usage_task_ = NULL;
   // TODO(kinuko): Record when it has retrieved the global usage.
   global_usage_retrieved_ = true;
 
   DCHECK(global_usage_callback_.HasCallbacks());
-  global_usage_callback_.Run(type_, global_usage_, global_unlimited_usage_);
+  global_usage_callback_.Run(type_, global_usage_,
+                             GetCachedGlobalUnlimitedUsage());
 
   for (HostUsageCallbackMap::iterator iter = host_usage_callbacks_.Begin();
        iter != host_usage_callbacks_.End(); ++iter) {
     iter->second.Run(iter->first, type_, GetCachedHostUsage(iter->first));
   }
   host_usage_callbacks_.Clear();
 }
 
 void ClientUsageTracker::GatherHostUsageComplete(const std::string& host) {
   DCHECK(host_usage_tasks_.find(host) != host_usage_tasks_.end());
   host_usage_tasks_.erase(host);
   host_usage_callbacks_.Run(host, host, type_, GetCachedHostUsage(host));
 }
 
 int64 ClientUsageTracker::GetCachedHostUsage(const std::string& host) {
   HostUsageMap::const_iterator found = cached_usage_.find(host);
   if (found == cached_usage_.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;
 }
 
+int64 ClientUsageTracker::GetCachedGlobalUnlimitedUsage() {
+  if (!global_unlimited_usage_is_valid_) {
+    global_unlimited_usage_ = 0;
+    for (HostUsageMap::const_iterator host_iter = cached_usage_.begin();
+         host_iter != cached_usage_.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++) {
+        if (IsStorageUnlimited(origin_iter->first))
+          global_unlimited_usage_ += origin_iter->second;
+      }
+    }
+    global_unlimited_usage_is_valid_ = true;
+  }
+  return global_unlimited_usage_;
+}
+
+void ClientUsageTracker::OnSpecialStoragePolicyChanged() {
+  DCHECK(CalledOnValidThread());
+  global_unlimited_usage_is_valid_ = false;
+}
+
 void ClientUsageTracker::NoopHostUsageCallback(
     const std::string& host,  StorageType type, int64 usage) {
 }
 
 bool ClientUsageTracker::IsStorageUnlimited(const GURL& origin) const {
   return special_storage_policy_.get() &&
          special_storage_policy_->IsStorageUnlimited(origin);
 }
 
 }  // namespace quota