Cleanup: quota::HostQuotaCallback do not need to pass host and type as arguments

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 239 matching lines @@
          iter != client_tracker_map_.end();
          ++iter) {
       iter->second->GetGlobalUsage(
           base::Bind(&UsageTracker::DidGetClientGlobalUsage,
                      weak_factory_.GetWeakPtr()));
     }
   }
 }
 
 void UsageTracker::GetHostUsage(
-    const std::string& host, const HostUsageCallback& callback) {
+    const std::string& host, const UsageCallback& callback) {
   if (client_tracker_map_.size() == 0) {
     // No clients registered.
-    callback.Run(host, type_, 0);
+    callback.Run(0);
     return;
   }
   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()));
+                     weak_factory_.GetWeakPtr(), host, type_));
     }
   }
 }
 
 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 46 matching lines @@
                                          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, host, type, info.usage);
+    host_usage_callbacks_.Run(host, info.usage);
     outstanding_host_usage_.erase(host);
   }
 }
 
 // ClientUsageTracker ----------------------------------------------------
 
 ClientUsageTracker::ClientUsageTracker(
     UsageTracker* tracker, QuotaClient* client, StorageType type,
     SpecialStoragePolicy* special_storage_policy)
     : tracker_(tracker),
@@ skipping 21 matching lines @@
     callback.Run(type_, 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 HostUsageCallback& callback) {
+    const std::string& host, const UsageCallback& callback) {
   HostSet::const_iterator found = cached_hosts_.find(host);
   if (found != cached_hosts_.end()) {
     // TODO(kinuko): Drop host_usage_map_ cache periodically.
-    callback.Run(host, type_, GetCachedHostUsage(host));
+    callback.Run(GetCachedHostUsage(host));
     return;
   }
   if (!host_usage_callbacks_.Add(host, callback) || global_usage_task_)
     return;
   GatherHostUsageTask* task = new GatherHostUsageTask(tracker_, client_, host);
   host_usage_tasks_[host] = task;
   task->Start();
 }
 
 void ClientUsageTracker::UpdateUsageCache(
@@ skipping 63 matching lines @@
   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_,
                              GetCachedGlobalUnlimitedUsage());
 
   for (HostUsageCallbackMap::iterator iter = host_usage_callbacks_.Begin();
        iter != host_usage_callbacks_.End(); ++iter) {
-    iter->second.Run(iter->first, type_, GetCachedHostUsage(iter->first));
+    iter->second.Run(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));
+  host_usage_callbacks_.Run(host, GetCachedHostUsage(host));
 }
 
 int64 ClientUsageTracker::GetCachedHostUsage(const std::string& host) const {
   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();
@@ skipping 18 matching lines @@
     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) {
-}
+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