[Quota] Add UsageTracker::GetGlobalLimitedUsage

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 <functional>
 #include <set>
@@ skipping 173 matching lines @@
 
 int64 CallSystemGetAmountOfFreeDiskSpace(const base::FilePath& profile_path) {
   // Ensure the profile path exists.
   if(!file_util::CreateDirectory(profile_path)) {
     LOG(WARNING) << "Create directory failed for path" << profile_path.value();
     return 0;
   }
   return base::SysInfo::AmountOfFreeDiskSpace(profile_path);
 }
 
-int64 CalculateTemporaryGlobalQuota(int64 global_usage,
-                                    int64 global_unlimited_usage,
+int64 CalculateTemporaryGlobalQuota(int64 global_limited_usage,
                                     int64 available_space) {
-    DCHECK_GE(global_usage, global_unlimited_usage);
-    int64 limited_usage = global_usage - global_unlimited_usage;
-    int64 avail_space = available_space;
-    if (avail_space < kint64max - limited_usage) {
-      // We basically calculate the temporary quota by
-      // [available_space + space_used_for_temp] * kTempQuotaRatio,
-      // but make sure we'll have no overflow.
-      avail_space += limited_usage;
-    }
-    return avail_space * kTemporaryQuotaRatioToAvail;
+  DCHECK_GE(global_limited_usage, 0);
+  int64 avail_space = available_space;
+  if (avail_space < kint64max - global_limited_usage) {
+    // We basically calculate the temporary quota by
+    // [available_space + space_used_for_temp] * kTempQuotaRatio,
+    // but make sure we'll have no overflow.
+    avail_space += global_limited_usage;
+  }
+  return avail_space * kTemporaryQuotaRatioToAvail;
 }
 
 void DispatchTemporaryGlobalQuotaCallback(
     const QuotaCallback& callback,
     QuotaStatusCode status,
     const UsageAndQuota& usage_and_quota) {
   if (status != kQuotaStatusOk) {
     callback.Run(status, 0);
     return;
   }
 
   callback.Run(status, CalculateTemporaryGlobalQuota(
-      usage_and_quota.global_usage,
-      usage_and_quota.global_unlimited_usage,
+      usage_and_quota.global_limited_usage,
       usage_and_quota.available_disk_space));
 }
 
 int64 CalculateQuotaWithDiskSpace(
     int64 available_disk_space, int64 usage, int64 quota) {
   if (available_disk_space < QuotaManager::kMinimumPreserveForSystem ||
       quota < usage) {
     // No more space; cap the quota to the current usage.
     return usage;
   }
 
   available_disk_space -= QuotaManager::kMinimumPreserveForSystem;
   if (available_disk_space < quota - usage)
     return available_disk_space + usage;
 
   return quota;
 }
 
 int64 CalculateTemporaryHostQuota(int64 host_usage,
                                   int64 global_quota,
-                                  int64 global_usage,
-                                  int64 global_unlimited_usage) {
-  DCHECK_GE(global_usage, global_unlimited_usage);
-    int64 limited_global_usage = global_usage - global_unlimited_usage;
-    int64 host_quota = global_quota / QuotaManager::kPerHostTemporaryPortion;
-    if (limited_global_usage > global_quota)
-      host_quota = std::min(host_quota, host_usage);
-    return host_quota;
+                                  int64 global_limited_usage) {
+  DCHECK_GE(global_limited_usage, 0);
+  int64 host_quota = global_quota / QuotaManager::kPerHostTemporaryPortion;
+  if (global_limited_usage > global_quota)
+    host_quota = std::min(host_quota, host_usage);
+  return host_quota;
 }
 
 void DispatchUsageAndQuotaForWebApps(
     StorageType type,
     bool is_incognito,
     bool is_unlimited,
     bool can_query_disk_size,
     const QuotaManager::GetUsageAndQuotaCallback& callback,
     QuotaStatusCode status,
     const UsageAndQuota& usage_and_quota) {
   if (status != kQuotaStatusOk) {
     callback.Run(status, 0, 0);
     return;
   }
 
   int64 usage = usage_and_quota.usage;
   int64 quota = usage_and_quota.quota;
 
-  if (type == kStorageTypeTemporary) {
+  if (type == kStorageTypeTemporary && !is_unlimited) {
     quota = CalculateTemporaryHostQuota(
-        usage, quota,
-        usage_and_quota.global_usage,
-        usage_and_quota.global_unlimited_usage);
+        usage, quota, usage_and_quota.global_limited_usage);
   }
 
   if (is_incognito) {
     quota = std::min(quota, QuotaManager::kIncognitoDefaultQuotaLimit);
     callback.Run(status, usage, quota);
     return;
   }
 
   // For apps with unlimited permission or can_query_disk_size is true (and not
   // in incognito mode).
   // We assume we can expose the actual disk size for them and cap the quota by
   // the available disk space.
   if (is_unlimited || can_query_disk_size) {
     callback.Run(
         status, usage,
         CalculateQuotaWithDiskSpace(
             usage_and_quota.available_disk_space,
             usage, quota));
     return;
   }
 
   callback.Run(status, usage, quota);
 }
 
 }  // namespace
 
 UsageAndQuota::UsageAndQuota()
     : usage(0),
-      global_usage(0),
-      global_unlimited_usage(0),
+      global_limited_usage(0),
       quota(0),
       available_disk_space(0) {
 }
 
 UsageAndQuota::UsageAndQuota(
     int64 usage,
-    int64 global_usage,
-    int64 global_unlimited_usage,
+    int64 global_limited_usage,
     int64 quota,
     int64 available_disk_space)
     : usage(usage),
-      global_usage(global_usage),
-      global_unlimited_usage(global_unlimited_usage),
+      global_limited_usage(global_limited_usage),
       quota(quota),
       available_disk_space(available_disk_space) {
 }
 
 class UsageAndQuotaCallbackDispatcher
     : public QuotaTask,
       public base::SupportsWeakPtr<UsageAndQuotaCallbackDispatcher> {
  public:
   UsageAndQuotaCallbackDispatcher(QuotaManager* manager)
       : QuotaTask(manager),
         has_usage_(false),
-        has_global_usage_(false),
+        has_global_limited_usage_(false),
         has_quota_(false),
         has_available_disk_space_(false),
         status_(kQuotaStatusUnknown),
-        usage_and_quota_(-1, -1, -1, -1, -1),
+        usage_and_quota_(-1, -1, -1, -1),
         waiting_callbacks_(1) {}
 
   virtual ~UsageAndQuotaCallbackDispatcher() {}
 
   void WaitForResults(const QuotaManager::UsageAndQuotaCallback& callback) {
     callback_ = callback;
     Start();
   }
 
   void set_usage(int64 usage) {
     usage_and_quota_.usage = usage;
     has_usage_ = true;
   }
 
-  void set_global_usage(int64 global_usage) {
-    usage_and_quota_.global_usage = global_usage;
-    has_global_usage_ = true;
-  }
-
-  void set_global_unlimited_usage(int64 global_unlimited_usage) {
-    usage_and_quota_.global_unlimited_usage = global_unlimited_usage;
-    has_global_usage_ = true;
+  void set_global_limited_usage(int64 global_limited_usage) {
+    usage_and_quota_.global_limited_usage = global_limited_usage;
+    has_global_limited_usage_ = true;
   }
 
   void set_quota(int64 quota) {
     usage_and_quota_.quota = quota;
     has_quota_ = true;
   }
 
   void set_available_disk_space(int64 available_disk_space) {
     usage_and_quota_.available_disk_space = available_disk_space;
     has_available_disk_space_ = true;
   }
 
   UsageCallback GetHostUsageCallback() {
     ++waiting_callbacks_;
     has_usage_ = true;
     return base::Bind(&UsageAndQuotaCallbackDispatcher::DidGetHostUsage,
                       AsWeakPtr());
   }
 
-  GlobalUsageCallback GetGlobalUsageCallback() {
+  UsageCallback GetGlobalLimitedUsageCallback() {
     ++waiting_callbacks_;
-    has_global_usage_ = true;
-    return base::Bind(&UsageAndQuotaCallbackDispatcher::DidGetGlobalUsage,
-                      AsWeakPtr());
+    has_global_limited_usage_ = true;
+    return base::Bind(
+        &UsageAndQuotaCallbackDispatcher::DidGetGlobalLimitedUsage,
+        AsWeakPtr());
   }
 
   QuotaCallback GetQuotaCallback() {
     ++waiting_callbacks_;
     has_quota_ = true;
     return base::Bind(&UsageAndQuotaCallbackDispatcher::DidGetQuota,
                       AsWeakPtr());
   }
 
   QuotaCallback GetAvailableSpaceCallback() {
     ++waiting_callbacks_;
     has_available_disk_space_ = true;
     return base::Bind(&UsageAndQuotaCallbackDispatcher::DidGetAvailableSpace,
                       AsWeakPtr());
   }
 
  private:
   void DidGetHostUsage(int64 usage) {
     if (status_ == kQuotaStatusUnknown)
       status_ = kQuotaStatusOk;
     usage_and_quota_.usage = usage;
     CheckCompleted();
   }
 
-  void DidGetGlobalUsage(int64 usage,
-                         int64 unlimited_usage) {
+  void DidGetGlobalLimitedUsage(int64 limited_usage) {
     if (status_ == kQuotaStatusUnknown)
       status_ = kQuotaStatusOk;
-    usage_and_quota_.global_usage = usage;
-    usage_and_quota_.global_unlimited_usage = unlimited_usage;
+    usage_and_quota_.global_limited_usage = limited_usage;
     CheckCompleted();
   }
 
   void DidGetQuota(QuotaStatusCode status, int64 quota) {
     if (status_ == kQuotaStatusUnknown || status_ == kQuotaStatusOk)
       status_ = status;
     usage_and_quota_.quota = quota;
     CheckCompleted();
   }
 
@@ skipping 12 matching lines @@
     CheckCompleted();
   }
 
   virtual void Aborted() OVERRIDE {
     callback_.Run(kQuotaErrorAbort, UsageAndQuota());
     DeleteSoon();
   }
 
   virtual void Completed() OVERRIDE {
     DCHECK(!has_usage_ || usage_and_quota_.usage >= 0);
-    DCHECK_LE(usage_and_quota_.global_unlimited_usage,
-              usage_and_quota_.global_usage);
-    DCHECK(!has_global_usage_ ||
-           usage_and_quota_.global_unlimited_usage >= 0);
+    DCHECK(!has_global_limited_usage_ ||
+           usage_and_quota_.global_limited_usage >= 0);
     DCHECK(!has_quota_ || usage_and_quota_.quota >= 0);
     DCHECK(!has_available_disk_space_ ||
            usage_and_quota_.available_disk_space >= 0);
 
     callback_.Run(status_, usage_and_quota_);
     DeleteSoon();
   }
 
   void CheckCompleted() {
     if (--waiting_callbacks_ <= 0)
       CallCompleted();
   }
 
   // For sanity checks, they're checked only when DCHECK is on.
   bool has_usage_;
-  bool has_global_usage_;
+  bool has_global_limited_usage_;
   bool has_quota_;
   bool has_available_disk_space_;
 
   QuotaStatusCode status_;
   UsageAndQuota usage_and_quota_;
   QuotaManager::UsageAndQuotaCallback callback_;
   int waiting_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(UsageAndQuotaCallbackDispatcher);
 };
@@ skipping 382 matching lines @@
   bool can_query_disk_size = CanQueryDiskSize(origin);
 
   UsageAndQuotaCallbackDispatcher* dispatcher =
       new UsageAndQuotaCallbackDispatcher(this);
 
   UsageAndQuota usage_and_quota;
   if (unlimited) {
     dispatcher->set_quota(kNoLimit);
   } else {
     if (type == kStorageTypeTemporary) {
-      GetUsageTracker(type)->GetGlobalUsage(
-          dispatcher->GetGlobalUsageCallback());
+      GetUsageTracker(type)->GetGlobalLimitedUsage(
+          dispatcher->GetGlobalLimitedUsageCallback());
       GetTemporaryGlobalQuota(dispatcher->GetQuotaCallback());
     } else if (type == kStorageTypePersistent) {
       GetPersistentHostQuota(net::GetHostOrSpecFromURL(origin),
                              dispatcher->GetQuotaCallback());
     } else {
       dispatcher->set_quota(kSyncableStorageDefaultHostQuota);
     }
   }
 
   GetUsageTracker(type)->GetHostUsage(net::GetHostOrSpecFromURL(origin),
@@ skipping 110 matching lines @@
     return;
   }
 
   if (temporary_quota_override_ > 0) {
     callback.Run(kQuotaStatusOk, temporary_quota_override_);
     return;
   }
 
   UsageAndQuotaCallbackDispatcher* dispatcher =
       new UsageAndQuotaCallbackDispatcher(this);
-  GetGlobalUsage(kStorageTypeTemporary,
-                 dispatcher->GetGlobalUsageCallback());
+  GetUsageTracker(kStorageTypeTemporary)->
+      GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
   GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
   dispatcher->WaitForResults(
       base::Bind(&DispatchTemporaryGlobalQuotaCallback, callback));
 }
 
 void QuotaManager::SetTemporaryGlobalOverrideQuota(
     int64 new_quota, const QuotaCallback& callback) {
   LazyInitialize();
 
   if (new_quota < 0) {
@@ skipping 438 matching lines @@
   eviction_context_.evict_origin_data_callback = callback;
 
   DeleteOriginData(origin, type, QuotaClient::kAllClientsMask,
       base::Bind(&QuotaManager::DidOriginDataEvicted,
                  weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::GetUsageAndQuotaForEviction(
     const UsageAndQuotaCallback& callback) {
   DCHECK(io_thread_->BelongsToCurrentThread());
+  LazyInitialize();
 
   UsageAndQuotaCallbackDispatcher* dispatcher =
       new UsageAndQuotaCallbackDispatcher(this);
-  GetGlobalUsage(kStorageTypeTemporary,
-                 dispatcher->GetGlobalUsageCallback());
+  GetUsageTracker(kStorageTypeTemporary)->
+      GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
   GetTemporaryGlobalQuota(dispatcher->GetQuotaCallback());
   GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
   dispatcher->WaitForResults(callback);
 }
 
 void QuotaManager::DidSetTemporaryGlobalOverrideQuota(
     const QuotaCallback& callback,
     const int64* new_quota,
     bool success) {
   QuotaStatusCode status = kQuotaErrorInvalidAccess;
@@ skipping 208 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::SingleThreadTaskRunner* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota