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

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 218 matching lines @@
 
   void DidGetHostUsage(const std::string& host, StorageType type, int64 usage) {
     DCHECK_EQ(this->host(), host);
     DCHECK_EQ(this->type(), type);
     if (quota_status_ == kQuotaStatusUnknown)
       quota_status_ = kQuotaStatusOk;
     host_usage_ = usage;
     CheckCompleted();
   }
 
-  void DidGetHostQuota(QuotaStatusCode status,
-                       const std::string& host,
+  void DidGetHostQuota(const std::string& host,
                        StorageType type,
+                       QuotaStatusCode status,
                        int64 host_quota) {
     DCHECK_EQ(this->host(), host);
     DCHECK_EQ(this->type(), type);
     if (quota_status_ == kQuotaStatusUnknown || quota_status_ == kQuotaStatusOk)
       quota_status_ = status;
     host_quota_ = host_quota;
     CheckCompleted();
   }
 
   void DidGetAvailableSpace(QuotaStatusCode status, int64 space) {
@@ skipping 103 matching lines @@
                       weak_factory_.GetWeakPtr());
   }
   UsageCallback NewWaitableHostUsageCallback() {
     ++waiting_callbacks_;
     return base::Bind(&UsageAndQuotaDispatcherTask::DidGetHostUsage,
                       weak_factory_.GetWeakPtr(), host(), type());
   }
   HostQuotaCallback NewWaitableHostQuotaCallback() {
     ++waiting_callbacks_;
     return base::Bind(&UsageAndQuotaDispatcherTask::DidGetHostQuota,
-                      weak_factory_.GetWeakPtr());
+                      weak_factory_.GetWeakPtr(), host(), type());
   }
   AvailableSpaceCallback NewWaitableAvailableSpaceCallback() {
     ++waiting_callbacks_;
     return base::Bind(&UsageAndQuotaDispatcherTask::DidGetAvailableSpace,
                       weak_factory_.GetWeakPtr());
   }
 
 
  private:
   void CheckCompleted() {
@@ skipping 637 matching lines @@
                  base::Owned(new_quota_ptr)));
 }
 
 void QuotaManager::GetPersistentHostQuota(const std::string& host,
                                           const HostQuotaCallback& callback) {
   LazyInitialize();
   if (host.empty()) {
     // This could happen if we are called on file:///.
     // TODO(kinuko) We may want to respect --allow-file-access-from-files
     // command line switch.
-    callback.Run(kQuotaStatusOk, host, kStorageTypePersistent, 0);
+    callback.Run(kQuotaStatusOk, 0);
     return;
   }
 
   int64* quota_ptr = new int64(0);
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&GetPersistentHostQuotaOnDBThread,
                  host,
                  base::Unretained(quota_ptr)),
       base::Bind(&QuotaManager::DidGetPersistentHostQuota,
                  weak_factory_.GetWeakPtr(),
                  callback,
                  host,
                  base::Owned(quota_ptr)));
 }
 
 void QuotaManager::SetPersistentHostQuota(const std::string& host,
                                           int64 new_quota,
                                           const HostQuotaCallback& callback) {
   LazyInitialize();
   if (host.empty()) {
     // This could happen if we are called on file:///.
-    callback.Run(kQuotaErrorNotSupported, host, kStorageTypePersistent, 0);
+    callback.Run(kQuotaErrorNotSupported, 0);
     return;
   }
   if (new_quota < 0) {
-    callback.Run(kQuotaErrorInvalidModification,
-                 host, kStorageTypePersistent, -1);
+    callback.Run(kQuotaErrorInvalidModification, -1);
     return;
   }
 
   if (db_disabled_) {
-    callback.Run(kQuotaErrorInvalidAccess,
-                 host, kStorageTypePersistent, -1);
+    callback.Run(kQuotaErrorInvalidAccess, -1);
     return;
   }
 
   int64* new_quota_ptr = new int64(new_quota);
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&SetPersistentHostQuotaOnDBThread,
                  host,
                  base::Unretained(new_quota_ptr)),
       base::Bind(&QuotaManager::DidSetPersistentHostQuota,
@@ skipping 427 matching lines @@
     return;
 
   callback.Run(status, kStorageTypeTemporary, *new_quota);
 }
 
 void QuotaManager::DidGetPersistentHostQuota(const HostQuotaCallback& callback,
                                              const std::string& host,
                                              const int64* quota,
                                              bool success) {
   DidDatabaseWork(success);
-  callback.Run(kQuotaStatusOk, host, kStorageTypePersistent, *quota);
+  callback.Run(kQuotaStatusOk, *quota);
 }
 
 void QuotaManager::DidSetPersistentHostQuota(const std::string& host,
                                              const HostQuotaCallback& callback,
                                              const int64* new_quota,
                                              bool success) {
   DidDatabaseWork(success);
-  callback.Run(success ? kQuotaStatusOk : kQuotaErrorInvalidAccess,
-               host, kStorageTypePersistent, *new_quota);
+  callback.Run(success ? kQuotaStatusOk : kQuotaErrorInvalidAccess, *new_quota);
 }
 
 void QuotaManager::DidInitialize(int64* temporary_quota_override,
                                  int64* desired_available_space,
                                  bool success) {
   temporary_quota_override_ = *temporary_quota_override;
   desired_available_space_ = *desired_available_space;
   temporary_quota_initialized_ = true;
   DidDatabaseWork(success);
 
@@ skipping 172 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::SingleThreadTaskRunner* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota