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

webkit/quota/quota_manager.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/quota_manager.h"
 
 #include <algorithm>
 #include <deque>
 #include <set>
 
@@ skipping 336 matching lines @@
     return avail_space * kTemporaryQuotaRatioToAvail;
   }
 
   // Subclasses must call following methods to create a new 'waitable'
   // callback, which decrements waiting_callbacks when it is called.
   GlobalUsageCallback NewWaitableGlobalUsageCallback() {
     ++waiting_callbacks_;
     return base::Bind(&UsageAndQuotaDispatcherTask::DidGetGlobalUsage,
                       weak_factory_.GetWeakPtr());
   }
-  HostUsageCallback NewWaitableHostUsageCallback() {
+  HostUsageCallback NewWaitableHostUsageCallback(const std::string& host,
+                                                 quota::StorageType type) {
     ++waiting_callbacks_;
     return base::Bind(&UsageAndQuotaDispatcherTask::DidGetHostUsage,
-                      weak_factory_.GetWeakPtr());
+                      weak_factory_.GetWeakPtr(), host, type);

[kinuko, 2012/09/17 19:15:42]

looks like we can call host() and type() here rather than passing them as args
to NewWaitableHostUsageCallback

[calvinlo, 2012/09/18 05:59:18]

Done.

   }
   HostQuotaCallback NewWaitableHostQuotaCallback() {
     ++waiting_callbacks_;
     return base::Bind(&UsageAndQuotaDispatcherTask::DidGetHostQuota,
                       weak_factory_.GetWeakPtr());
   }
   AvailableSpaceCallback NewWaitableAvailableSpaceCallback() {
     ++waiting_callbacks_;
     return base::Bind(&UsageAndQuotaDispatcherTask::DidGetAvailableSpace,
                       weak_factory_.GetWeakPtr());
@@ skipping 102 matching lines @@
  public:
   UsageAndQuotaDispatcherTaskForTemporary(
       QuotaManager* manager, const HostAndType& host_and_type)
       : UsageAndQuotaDispatcherTask(manager, host_and_type) {}
 
  protected:
   virtual void RunBody() OVERRIDE {
     manager()->GetUsageTracker(type())->GetGlobalUsage(
         NewWaitableGlobalUsageCallback());
     manager()->GetUsageTracker(type())->GetHostUsage(
-        host(), NewWaitableHostUsageCallback());
+        host(), NewWaitableHostUsageCallback(host(), type()));
     manager()->GetAvailableSpace(NewWaitableAvailableSpaceCallback());
   }
 
   virtual void DispatchCallbacks() OVERRIDE {
     // Allow an individual host to utilize a fraction of the total
     // pool available for temp storage.
     int64 host_quota = temporary_global_quota() / kPerHostTemporaryPortion;
 
     // But if total temp usage is over-budget, stop letting new data in
     // until we reclaim space.
@@ skipping 11 matching lines @@
 class QuotaManager::UsageAndQuotaDispatcherTaskForPersistent
     : public QuotaManager::UsageAndQuotaDispatcherTask {
  public:
   UsageAndQuotaDispatcherTaskForPersistent(
       QuotaManager* manager, const HostAndType& host_and_type)
       : UsageAndQuotaDispatcherTask(manager, host_and_type) {}
 
  protected:
   virtual void RunBody() OVERRIDE {
     manager()->GetUsageTracker(type())->GetHostUsage(
-        host(), NewWaitableHostUsageCallback());
+        host(), NewWaitableHostUsageCallback(host(), type()));
     manager()->GetPersistentHostQuota(
         host(), NewWaitableHostQuotaCallback());
     manager()->GetAvailableSpace(NewWaitableAvailableSpaceCallback());
   }
 
   virtual void DispatchCallbacks() OVERRIDE {
     CallCallbacksAndClear(quota_status(),
                           host_usage(), host_usage(), host_quota(),
                           available_space());
   }
 };
 
 class QuotaManager::UsageAndQuotaDispatcherTaskForSyncable
     : public QuotaManager::UsageAndQuotaDispatcherTask {
  public:
   UsageAndQuotaDispatcherTaskForSyncable(
       QuotaManager* manager, const HostAndType& host_and_type)
       : UsageAndQuotaDispatcherTask(manager, host_and_type) {}
 
  protected:
   virtual void RunBody() OVERRIDE {
     manager()->GetUsageTracker(type())->GetHostUsage(
-        host(), NewWaitableHostUsageCallback());
+        host(), NewWaitableHostUsageCallback(host(), type()));
   }
 
   virtual void DispatchCallbacks() OVERRIDE {
     // TODO(kinuko): We should reflect the backend's actual quota instead
     // of returning a fixed default value.
     CallCallbacksAndClear(quota_status(),
                           host_usage(), host_usage(),
                           kSyncableStorageDefaultHostQuota,
                           available_space());
   }
@@ skipping 1148 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::SingleThreadTaskRunner* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota