[Quota][Clean up] Drop StorageType in GlobalUsageCallback

webkit/quota/quota_manager_unittest.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 <set>
 #include <sstream>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 113 matching lines @@
     quota_manager_->GetUsageAndQuota(
         origin, type, base::Bind(&QuotaManagerTest::DidGetUsageAndQuota,
                                  weak_factory_.GetWeakPtr()));
   }
 
   void GetTemporaryGlobalQuota() {
     quota_status_ = kQuotaStatusUnknown;
     quota_ = -1;
     quota_manager_->GetTemporaryGlobalQuota(
         base::Bind(&QuotaManagerTest::DidGetQuota,
-                   weak_factory_.GetWeakPtr(), quota::kStorageTypeTemporary));
+                   weak_factory_.GetWeakPtr()));
   }
 
   void SetTemporaryGlobalQuota(int64 new_quota) {
     quota_status_ = kQuotaStatusUnknown;
     quota_ = -1;
     quota_manager_->SetTemporaryGlobalOverrideQuota(
         new_quota,
         base::Bind(&QuotaManagerTest::DidGetQuota,
-                   weak_factory_.GetWeakPtr(), quota::kStorageTypeTemporary));
+                   weak_factory_.GetWeakPtr()));
   }
 
   void GetPersistentHostQuota(const std::string& host) {
     quota_status_ = kQuotaStatusUnknown;
-    host_.clear();
-    type_ = kStorageTypeUnknown;
     quota_ = -1;
     quota_manager_->GetPersistentHostQuota(
         host,
         base::Bind(&QuotaManagerTest::DidGetHostQuota,
                    weak_factory_.GetWeakPtr()));
   }
 
   void SetPersistentHostQuota(const std::string& host, int64 new_quota) {
     quota_status_ = kQuotaStatusUnknown;
-    host_.clear();
-    type_ = kStorageTypeUnknown;
     quota_ = -1;
     quota_manager_->SetPersistentHostQuota(
         host, new_quota,
         base::Bind(&QuotaManagerTest::DidGetHostQuota,
                    weak_factory_.GetWeakPtr()));
   }
 
   void GetGlobalUsage(StorageType type) {
-    type_ = kStorageTypeUnknown;
     usage_ = -1;
     unlimited_usage_ = -1;
     quota_manager_->GetGlobalUsage(
         type,
         base::Bind(&QuotaManagerTest::DidGetGlobalUsage,
                    weak_factory_.GetWeakPtr()));
   }
 
   void GetHostUsage(const std::string& host, StorageType type) {
-    host_.clear();
-    type_ = kStorageTypeUnknown;
     usage_ = -1;
     quota_manager_->GetHostUsage(
         host, type,
         base::Bind(&QuotaManagerTest::DidGetHostUsage,
-                   weak_factory_.GetWeakPtr(), host, type));
+                   weak_factory_.GetWeakPtr()));
   }
 
   void RunAdditionalUsageAndQuotaTask(const GURL& origin, StorageType type) {
     quota_manager_->GetUsageAndQuota(
         origin, type,
         base::Bind(&QuotaManagerTest::DidGetUsageAndQuotaAdditional,
                    weak_factory_.GetWeakPtr()));
   }
 
   void DeleteClientOriginData(QuotaClient* client,
@@ skipping 115 matching lines @@
   void DidGetUsageInfo(const UsageInfoEntries& entries) {
     usage_info_.insert(usage_info_.begin(), entries.begin(), entries.end());
   }
 
   void DidGetUsageAndQuota(QuotaStatusCode status, int64 usage, int64 quota) {
     quota_status_ = status;
     usage_ = usage;
     quota_ = quota;
   }
 
-  void DidGetQuota(StorageType type,
-                   QuotaStatusCode status,
+  void DidGetQuota(QuotaStatusCode status,
                    int64 quota) {
     quota_status_ = status;
-    type_ = type;
     quota_ = quota;
   }
 
   void DidGetAvailableSpace(QuotaStatusCode status, int64 available_space) {
     quota_status_ = status;
     available_space_ = available_space;
   }
 
   void DidGetHostQuota(QuotaStatusCode status,
                        int64 quota) {
     quota_status_ = status;
     quota_ = quota;
   }
 
-  void DidGetGlobalUsage(StorageType type, int64 usage,
+  void DidGetGlobalUsage(int64 usage,
                          int64 unlimited_usage) {
-    type_ = type;
     usage_ = usage;
     unlimited_usage_ = unlimited_usage;
   }
 
-  void DidGetHostUsage(const std::string& host,
-                       StorageType type,
-                       int64 usage) {
-    host_ = host;
-    type_ = type;
+  void DidGetHostUsage(int64 usage) {
     usage_ = usage;
   }
 
   void StatusCallback(QuotaStatusCode status) {
     ++status_callback_count_;
     quota_status_ = status;
   }
 
   void DidGetUsageAndQuotaForEviction(QuotaStatusCode status,
                                       const UsageAndQuota& usage_and_quota) {
@@ skipping 34 matching lines @@
   void set_quota_manager(QuotaManager* quota_manager) {
     quota_manager_ = quota_manager;
   }
 
   MockSpecialStoragePolicy* mock_special_storage_policy() const {
     return mock_special_storage_policy_.get();
   }
 
   QuotaStatusCode status() const { return quota_status_; }
   const UsageInfoEntries& usage_info() const { return usage_info_; }
-  const std::string& host() const { return host_; }
-  StorageType type() const { return type_; }
   int64 usage() const { return usage_; }
   int64 unlimited_usage() const { return unlimited_usage_; }
   int64 quota() const { return quota_; }
   int64 available_space() const { return available_space_; }
   const GURL& lru_origin() const { return lru_origin_; }
   const std::set<GURL>& modified_origins() const { return modified_origins_; }
   StorageType modified_origins_type() const { return modified_origins_type_; }
   const QuotaTableEntries& quota_entries() const { return quota_entries_; }
   const OriginInfoTableEntries& origin_info_entries() const {
     return origin_info_entries_;
@@ skipping 10 matching lines @@
 
   base::MessageLoop message_loop_;
   base::ScopedTempDir data_dir_;
   base::WeakPtrFactory<QuotaManagerTest> weak_factory_;
 
   scoped_refptr<QuotaManager> quota_manager_;
   scoped_refptr<MockSpecialStoragePolicy> mock_special_storage_policy_;
 
   QuotaStatusCode quota_status_;
   UsageInfoEntries usage_info_;
-  std::string host_;
-  StorageType type_;
   int64 usage_;
   int64 unlimited_usage_;
   int64 quota_;
   int64 available_space_;
   GURL lru_origin_;
   std::set<GURL> modified_origins_;
   StorageType modified_origins_type_;
   QuotaTableEntries quota_entries_;
   OriginInfoTableEntries origin_info_entries_;
   int status_callback_count_;
@@ skipping 141 matching lines @@
     { "https://bar.com/",       kTemp,   7 },
     { "http://baz.com/",        kTemp,  30 },
     { "http://foo.com/",        kPerm,  40 },
   };
   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
       QuotaClient::kFileSystem));
 
   // This time explicitly sets a temporary global quota.
   SetTemporaryGlobalQuota(100);
   base::MessageLoop::current()->RunUntilIdle();
-  EXPECT_EQ(kTemp, type());
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(100, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20, usage());
 
   const int kPerHostQuota = 100 / kPerHostTemporaryPortion;
 
@@ skipping 1563 matching lines @@
   EXPECT_EQ(QuotaManager::kIncognitoDefaultQuotaLimit, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
   EXPECT_EQ(QuotaManager::kIncognitoDefaultQuotaLimit, quota());
 }
 
 }  // namespace quota