[Quota][Clean up] Drop StorageType in GlobalUsageCallback

webkit/quota/usage_tracker.cc

 // Copyright (c) 2012 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>
@@ skipping 236 matching lines @@
 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::GetGlobalUsage(const GlobalUsageCallback& callback) {
   if (client_tracker_map_.size() == 0) {
     // No clients registered.
-    callback.Run(type_, 0, 0);
+    callback.Run(0, 0);
     return;
   }
   if (global_usage_callbacks_.Add(callback)) {
     // This is the first call.  Asks each ClientUsageTracker to collect
     // usage information.
     global_usage_.pending_clients = client_tracker_map_.size();
     global_usage_.usage = 0;
     global_usage_.unlimited_usage = 0;
     for (ClientTrackerMap::iterator iter = client_tracker_map_.begin();
          iter != client_tracker_map_.end();
@@ skipping 14 matching lines @@
   }
   if (host_usage_callbacks_.Add(host, callback)) {
     // This is the first call for the given host.
     DCHECK(outstanding_host_usage_.find(host) == outstanding_host_usage_.end());
     outstanding_host_usage_[host].pending_clients = client_tracker_map_.size();
     for (ClientTrackerMap::iterator iter = client_tracker_map_.begin();
          iter != client_tracker_map_.end();
          ++iter) {
       iter->second->GetHostUsage(host,
           base::Bind(&UsageTracker::DidGetClientHostUsage,
-                     weak_factory_.GetWeakPtr(), host, type_));
+                     weak_factory_.GetWeakPtr(), host));
     }
   }
 }
 
 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);
 }
@@ skipping 19 matching lines @@
 
 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::DidGetClientGlobalUsage(StorageType type,
-                                           int64 usage,
+void UsageTracker::DidGetClientGlobalUsage(int64 usage,
                                            int64 unlimited_usage) {
-  DCHECK_EQ(type, type_);
   global_usage_.usage += usage;
   global_usage_.unlimited_usage += unlimited_usage;
   if (--global_usage_.pending_clients == 0) {
     // Defend against confusing inputs from clients.
     if (global_usage_.usage < 0)
       global_usage_.usage = 0;
     // TODO(michaeln): The unlimited number is not trustworthy, it
     // can get out of whack when apps are installed or uninstalled.
     if (global_usage_.unlimited_usage > global_usage_.usage)
       global_usage_.unlimited_usage = global_usage_.usage;
     else if (global_usage_.unlimited_usage < 0)
       global_usage_.unlimited_usage = 0;
 
     // All the clients have returned their usage data.  Dispatches the
     // pending callbacks.
     global_usage_callbacks_.Run(
-        MakeTuple(type, global_usage_.usage,
-                  global_usage_.unlimited_usage));
+        MakeTuple(global_usage_.usage, global_usage_.unlimited_usage));
   }
 }
 
 void UsageTracker::DidGetClientHostUsage(const std::string& host,
-                                         StorageType type,
                                          int64 usage) {
-  DCHECK_EQ(type, type_);
   TrackingInfo& info = outstanding_host_usage_[host];
   info.usage += usage;
   if (--info.pending_clients == 0) {
     // Defend against confusing inputs from clients.
     if (info.usage < 0)
       info.usage = 0;
     // All the clients have returned their usage data.  Dispatches the
     // pending callbacks.
     host_usage_callbacks_.Run(host, MakeTuple(info.usage));
     outstanding_host_usage_.erase(host);
@@ skipping 19 matching lines @@
     special_storage_policy_->AddObserver(this);
 }
 
 ClientUsageTracker::~ClientUsageTracker() {
   if (special_storage_policy_)
     special_storage_policy_->RemoveObserver(this);
 }
 
 void ClientUsageTracker::GetGlobalUsage(const GlobalUsageCallback& callback) {
   if (global_usage_retrieved_ && non_cached_origins_by_host_.empty()) {
-    callback.Run(type_, global_usage_, GetCachedGlobalUnlimitedUsage());
+    callback.Run(global_usage_, GetCachedGlobalUnlimitedUsage());
     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(
     const std::string& host, const UsageCallback& callback) {
@@ skipping 137 matching lines @@
     int64 global_usage,
     int64 non_cached_global_usage,
     const std::map<std::string, int64>& non_cached_host_usage) {
   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(
-      MakeTuple(type_, global_usage,
+      MakeTuple(global_usage,
                 GetCachedGlobalUnlimitedUsage() + non_cached_global_usage));
 
   for (HostUsageCallbackMap::iterator iter = host_usage_callbacks_.Begin();
        iter != host_usage_callbacks_.End(); ++iter) {
     int64 host_usage = GetCachedHostUsage(iter->first);
     std::map<std::string, int64>::const_iterator found =
         non_cached_host_usage.find(iter->first);
     if (found != non_cached_host_usage.end())
       host_usage += found->second;
     iter->second.Run(MakeTuple(host_usage));
@@ skipping 79 matching lines @@
 void ClientUsageTracker::NoopHostUsageCallback(int64 usage) {}
 
 bool ClientUsageTracker::IsStorageUnlimited(const GURL& origin) const {
   if (type_ == kStorageTypeSyncable)
     return false;
   return special_storage_policy_.get() &&
          special_storage_policy_->IsStorageUnlimited(origin);
 }
 
 }  // namespace quota