Merged HostQuotaCallback into QuotaCallback

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 173 matching lines @@
   } else {
     usage = quota_and_usage.usage;
     quota = quota_and_usage.quota;
   }
 
   callback.Run(status, usage, quota);
 }
 
 void CallQuotaCallback(
     const QuotaCallback& callback,
-    StorageType type,
     QuotaStatusCode status,
     const QuotaAndUsage& quota_and_usage) {
-  callback.Run(status, type, quota_and_usage.quota);
+  callback.Run(status, quota_and_usage.quota);
 }
 
 // This class is for posting GetUsage/GetQuota tasks, gathering
 // results and dispatching GetAndQuota callbacks.
 // This class is self-destructed.
 class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {
  public:
   typedef UsageAndQuotaDispatcherCallback Callback;
   typedef std::deque<Callback> CallbackList;
 
@@ skipping 144 matching lines @@
   GlobalUsageCallback NewWaitableGlobalUsageCallback() {
     ++waiting_callbacks_;
     return base::Bind(&UsageAndQuotaDispatcherTask::DidGetGlobalUsage,
                       weak_factory_.GetWeakPtr());
   }
   UsageCallback NewWaitableHostUsageCallback() {
     ++waiting_callbacks_;
     return base::Bind(&UsageAndQuotaDispatcherTask::DidGetHostUsage,
                       weak_factory_.GetWeakPtr(), host(), type());
   }
-  HostQuotaCallback NewWaitableHostQuotaCallback() {
+  QuotaCallback NewWaitableHostQuotaCallback() {
     ++waiting_callbacks_;
     return base::Bind(&UsageAndQuotaDispatcherTask::DidGetHostQuota,
                       weak_factory_.GetWeakPtr(), host(), type());
   }
   AvailableSpaceCallback NewWaitableAvailableSpaceCallback() {
     ++waiting_callbacks_;
     return base::Bind(&UsageAndQuotaDispatcherTask::DidGetAvailableSpace,
                       weak_factory_.GetWeakPtr());
   }
 
@@ skipping 595 matching lines @@
       db_thread_,
       FROM_HERE,
       base::Bind(get_disk_space_fn_, profile_path_),
       base::Bind(&QuotaManager::DidGetAvailableSpace,
                  weak_factory_.GetWeakPtr(),
                  callback));
 }
 
 void QuotaManager::GetTemporaryGlobalQuota(const QuotaCallback& callback) {
   if (temporary_quota_override_ > 0) {
-    callback.Run(kQuotaStatusOk, kStorageTypeTemporary,
-                 temporary_quota_override_);
+    callback.Run(kQuotaStatusOk, temporary_quota_override_);
     return;
   }
   GetUsageAndQuotaInternal(
       GURL(), kStorageTypeTemporary, true /* global */,
-      base::Bind(&CallQuotaCallback, callback, kStorageTypeTemporary));
+      base::Bind(&CallQuotaCallback, callback));
 }
 
 void QuotaManager::SetTemporaryGlobalOverrideQuota(
     int64 new_quota, const QuotaCallback& callback) {
   LazyInitialize();
 
   if (new_quota < 0) {
     if (!callback.is_null())
-      callback.Run(kQuotaErrorInvalidModification,
-                   kStorageTypeTemporary, -1);
+      callback.Run(kQuotaErrorInvalidModification, -1);
     return;
   }
 
   if (db_disabled_) {
     if (callback.is_null())
-      callback.Run(kQuotaErrorInvalidAccess,
-                   kStorageTypeTemporary, -1);
+      callback.Run(kQuotaErrorInvalidAccess, -1);
     return;
   }
 
   int64* new_quota_ptr = new int64(new_quota);
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&SetTemporaryGlobalOverrideQuotaOnDBThread,
                  base::Unretained(new_quota_ptr)),
       base::Bind(&QuotaManager::DidSetTemporaryGlobalOverrideQuota,
                  weak_factory_.GetWeakPtr(),
                  callback,
                  base::Owned(new_quota_ptr)));
 }
 
 void QuotaManager::GetPersistentHostQuota(const std::string& host,
-                                          const HostQuotaCallback& callback) {
+                                          const QuotaCallback& 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, 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) {
+                                          const QuotaCallback& callback) {
   LazyInitialize();
   if (host.empty()) {
     // This could happen if we are called on file:///.
     callback.Run(kQuotaErrorNotSupported, 0);
     return;
   }
   if (new_quota < 0) {
     callback.Run(kQuotaErrorInvalidModification, -1);
     return;
   }
@@ skipping 432 matching lines @@
   QuotaStatusCode status = kQuotaErrorInvalidAccess;
   DidDatabaseWork(success);
   if (success) {
     temporary_quota_override_ = *new_quota;
     status = kQuotaStatusOk;
   }
 
   if (callback.is_null())
     return;
 
-  callback.Run(status, kStorageTypeTemporary, *new_quota);
+  callback.Run(status, *new_quota);
 }
 
-void QuotaManager::DidGetPersistentHostQuota(const HostQuotaCallback& callback,
+void QuotaManager::DidGetPersistentHostQuota(const QuotaCallback& callback,
                                              const std::string& host,
                                              const int64* quota,
                                              bool success) {
   DidDatabaseWork(success);
   callback.Run(kQuotaStatusOk, *quota);
 }
 
 void QuotaManager::DidSetPersistentHostQuota(const std::string& host,
-                                             const HostQuotaCallback& callback,
+                                             const QuotaCallback& callback,
                                              const int64* new_quota,
                                              bool success) {
   DidDatabaseWork(success);
   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;
@@ skipping 32 matching lines @@
   if (origins_in_use_.find(*origin) != origins_in_use_.end() ||
       access_notified_origins_.find(*origin) != access_notified_origins_.end())
     lru_origin_callback_.Run(GURL());
   else
     lru_origin_callback_.Run(*origin);
   access_notified_origins_.clear();
   lru_origin_callback_.Reset();
 }
 
 void QuotaManager::DidGetInitialTemporaryGlobalQuota(
-    QuotaStatusCode status, StorageType type, int64 quota_unused) {
-  DCHECK_EQ(type, kStorageTypeTemporary);
-
+    QuotaStatusCode status, int64 quota_unused) {
   if (eviction_disabled_)
     return;
 
   std::set<GURL>* origins = new std::set<GURL>;
   temporary_usage_tracker_->GetCachedOrigins(origins);
   // This will call the StartEviction() when initial origin registration
   // is completed.
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&InitializeTemporaryOriginsInfoOnDBThread,
@@ skipping 121 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::SingleThreadTaskRunner* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota