More WebSQLDatabase and QuotaManager integration.

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 <deque>
 #include <set>
 #include <string>
 
@@ skipping 54 matching lines @@
   }
 
   UsageTracker* tracker() const { return tracker_; }
   ClientUsageTracker* client_tracker() const { return client_tracker_; }
   const std::map<GURL, int64>& origin_usage_map() const {
     return origin_usage_map_;
   }
 
  private:
   void DidGetUsage(int64 usage) {
+    // Defend against confusing inputs from QuotaClients.
+    DCHECK_GE(usage, 0);
+    if (usage < 0)
+      usage = 0;
+
     // This code assumes DidGetUsage callbacks are called in the same
     // order as we dispatched GetOriginUsage calls.
     DCHECK(original_message_loop()->BelongsToCurrentThread());
     DCHECK(!pending_origins_.empty());
     origin_usage_map_.insert(std::make_pair(
         pending_origins_.front(), usage));
     pending_origins_.pop_front();
     if (pending_origins_.empty()) {
       // We're done.
       CallCompleted();
@@ skipping 241 matching lines @@
       origins_to_process->insert(*iter);
   }
 }
 
 void ClientUsageTracker::UpdateUsageCache(
     const GURL& origin, int64 delta) {
   std::string host = net::GetHostOrSpecFromURL(origin);
   if (cached_origins_.find(origin) != cached_origins_.end()) {
     host_usage_map_[host] += delta;
     global_usage_ += delta;
+    DCHECK_GE(host_usage_map_[host], 0);
+    DCHECK_GE(global_usage_, 0);
     return;
   }
   if (global_usage_retrieved_ ||
       host_usage_map_.find(host) != host_usage_map_.end()) {
     // This might be for a new origin.
     cached_origins_.insert(origin);
     host_usage_map_[host] = delta;
     global_usage_ += delta;
+    DCHECK_GE(host_usage_map_[host], 0);
+    DCHECK_GE(global_usage_, 0);
     return;
   }
   // See if the origin has been processed in outstanding gather tasks
   // and add up the delta if it has.
   if (global_usage_task_ && global_usage_task_->IsOriginDone(origin)) {
     host_usage_map_[host] += delta;
     global_usage_ += delta;
+    DCHECK_GE(host_usage_map_[host], 0);
+    DCHECK_GE(global_usage_, 0);
     return;
   }
   if (host_usage_tasks_.find(host) != host_usage_tasks_.end() &&
       host_usage_tasks_[host]->IsOriginDone(origin)) {
     host_usage_map_[host] += delta;
+    DCHECK_GE(host_usage_map_[host], 0);
   }
   // Otherwise we have not cached usage info for the origin yet.
   // Succeeding GetUsage tasks would eventually catch the change.
 }
 
 void ClientUsageTracker::DidGetGlobalUsage(
     const std::map<GURL, int64>& origin_usage_map) {
   DCHECK(global_usage_task_ != NULL);
   global_usage_task_ = NULL;
   // TODO(kinuko): Record when it has retrieved the global usage.
   global_usage_retrieved_ = true;
   for (std::map<GURL, int64>::const_iterator iter = origin_usage_map.begin();
        iter != origin_usage_map.end();
        ++iter) {
     if (cached_origins_.insert(iter->first).second) {
       global_usage_ += iter->second;
       std::string host = net::GetHostOrSpecFromURL(iter->first);
       host_usage_map_[host] += iter->second;
+      DCHECK_GE(host_usage_map_[host], 0);
+      DCHECK_GE(global_usage_, 0);
     }
   }
 
   // Dispatches the global usage callback.
   DCHECK(global_usage_callback_.HasCallbacks());
   global_usage_callback_.Run(global_usage_);
 
   // Dispatches host usage callbacks.
   for (HostUsageCallbackMap::iterator iter = host_usage_callbacks_.Begin();
        iter != host_usage_callbacks_.End();
@@ skipping 12 matching lines @@
     const std::string& host,
     const std::map<GURL, int64>& origin_usage_map) {
   DCHECK(host_usage_tasks_.find(host) != host_usage_tasks_.end());
   host_usage_tasks_.erase(host);
   for (std::map<GURL, int64>::const_iterator iter = origin_usage_map.begin();
        iter != origin_usage_map.end();
        ++iter) {
     if (cached_origins_.insert(iter->first).second) {
       global_usage_ += iter->second;
       host_usage_map_[host] += iter->second;
+      DCHECK_GE(host_usage_map_[host], 0);
+      DCHECK_GE(global_usage_, 0);
     }
   }
 
   // Dispatches the host usage callback.
   host_usage_callbacks_.Run(host, host, host_usage_map_[host]);
 }
 
 }  // namespace quota