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

content/browser/renderer_host/quota_dispatcher_host.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 "content/browser/renderer_host/quota_dispatcher_host.h"
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "content/common/quota_messages.h"
 #include "content/public/browser/quota_permission_context.h"
@@ skipping 95 matching lines @@
         weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
   virtual ~RequestQuotaDispatcher() {}
 
   void Start() {
     DCHECK(type_ == quota::kStorageTypeTemporary ||
            type_ == quota::kStorageTypePersistent);
     if (type_ == quota::kStorageTypePersistent) {
       quota_manager()->GetPersistentHostQuota(
           host_,
           base::Bind(&self_type::DidGetHostQuota,
-                     weak_factory_.GetWeakPtr()));
+                     weak_factory_.GetWeakPtr(), host_, type_));
     } else {
       quota_manager()->GetUsageAndQuota(
           origin_, type_,
           base::Bind(&self_type::DidGetTemporaryUsageAndQuota,
                      weak_factory_.GetWeakPtr()));
     }
   }
 
  private:
-  void DidGetHostQuota(QuotaStatusCode status,
-                       const std::string& host,
+  void DidGetHostQuota(const std::string& host,
                        StorageType type,
+                       QuotaStatusCode status,
                        int64 quota) {
     DCHECK_EQ(type_, type);
     DCHECK_EQ(host_, host);
     if (status != quota::kQuotaStatusOk) {
       DidFinish(status, 0);
       return;
     }
     if (requested_quota_ <= quota) {
       // Seems like we can just let it go.
       DidFinish(quota::kQuotaStatusOk, requested_quota_);
@@ skipping 18 matching lines @@
   void DidGetPermissionResponse(
       QuotaPermissionContext::QuotaPermissionResponse response) {
     if (response != QuotaPermissionContext::QUOTA_PERMISSION_RESPONSE_ALLOW) {
       // User didn't allow the new quota.  Just returning the current quota.
       DidFinish(quota::kQuotaStatusOk, current_quota_);
       return;
     }
     // Now we're allowed to set the new quota.
     quota_manager()->SetPersistentHostQuota(
         host_, requested_quota_,
-        base::Bind(&self_type::DidSetHostQuota,
-                   weak_factory_.GetWeakPtr()));
+        base::Bind(&self_type::DidSetHostQuota, weak_factory_.GetWeakPtr()));
   }
 
-  void DidSetHostQuota(QuotaStatusCode status,
-                       const std::string& host,
-                       StorageType type,
-                       int64 new_quota) {
-    DCHECK_EQ(host_, host);
-    DCHECK_EQ(type_, type);
+  void DidSetHostQuota(QuotaStatusCode status, int64 new_quota) {
     DidFinish(status, new_quota);
   }
 
   void DidFinish(QuotaStatusCode status, int64 granted_quota) {
     DCHECK(dispatcher_host());
     if (status != quota::kQuotaStatusOk) {
       dispatcher_host()->Send(new QuotaMsg_DidFail(request_id(), status));
     } else {
       dispatcher_host()->Send(new QuotaMsg_DidGrantStorageQuota(
           request_id(), granted_quota));
@@ skipping 60 matching lines @@
       type != quota::kStorageTypePersistent) {
     // Unsupported storage types.
     Send(new QuotaMsg_DidFail(request_id, quota::kQuotaErrorNotSupported));
     return;
   }
 
   RequestQuotaDispatcher* dispatcher = new RequestQuotaDispatcher(
       this, request_id, origin, type, requested_size, render_view_id);
   dispatcher->Start();
 }