Rename SpecialStoragePolicy::IsInstalledApp() to CanQueryDiskSize()

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 167 matching lines @@
 const int QuotaManager::kThresholdOfErrorsToBeBlacklisted = 3;
 
 const int QuotaManager::kEvictionIntervalInMilliSeconds =
     30 * kMinutesInMilliSeconds;
 
 // Heuristics: assuming average cloud server allows a few Gigs storage
 // on the server side and the storage needs to be shared for user data
 // and by multiple apps.
 int64 QuotaManager::kSyncableStorageDefaultHostQuota = 500 * kMBytes;
 
 int64 CalculateQuotaForInstalledApp(

[michaeln, 2013/04/16 21:21:04]

maybe change the name of this method too, not sure to what exactly but you
picked a real good name for CanQueryDiskSize :)

[kinuko, 2013/04/17 04:33:38]

Good catch, renamed this to CalculateQuotaWithDiskSize.

     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;
 }
 
 // Callback translators.
 void CallGetUsageAndQuotaCallback(
     const QuotaManager::GetUsageAndQuotaCallback& callback,
     bool unlimited,
-    bool is_installed_app,
+    bool can_query_disk_size,
     QuotaStatusCode status,
     const QuotaAndUsage& quota_and_usage) {
   // Regular limited case.
   if (!unlimited) {
-    if (is_installed_app) {
+    if (can_query_disk_size) {
       // Cap the quota by the available disk space.
       callback.Run(status, quota_and_usage.usage,
                    CalculateQuotaForInstalledApp(
                        quota_and_usage.available_disk_space,
                        quota_and_usage.usage,
                        quota_and_usage.quota));
       return;
     }
     callback.Run(status, quota_and_usage.usage, quota_and_usage.quota);
     return;
   }
 
   int64 usage = quota_and_usage.unlimited_usage;
 
-  // Unlimited case: this must be only for installed-app and extensions,
+  // Unlimited case: this must be only for apps with unlimitedStorage permission
   // or only when --unlimited-storage flag is given.
-  // We return the available disk space (minus kMinimumPreserveForSystem).
+  // We assume we can expose the disk size for them and return the available
+  // disk space (minus kMinimumPreserveForSystem).
   callback.Run(status, usage,
                CalculateQuotaForInstalledApp(
                    quota_and_usage.available_disk_space,
                    usage, QuotaManager::kNoLimit));
 }
 
 void CallQuotaCallback(
     const QuotaCallback& callback,
     QuotaStatusCode status,
     const QuotaAndUsage& quota_and_usage) {
@@ skipping 720 matching lines @@
 }
 
 void QuotaManager::GetUsageAndQuotaForWebApps(
     const GURL& origin,
     StorageType type,
     const GetUsageAndQuotaCallback& callback) {
   DCHECK(origin == origin.GetOrigin());
   GetUsageAndQuotaInternal(
       origin, type, false /* global */,
       base::Bind(&CallGetUsageAndQuotaCallback, callback,
-                 IsStorageUnlimited(origin, type), IsInstalledApp(origin)));
+                 IsStorageUnlimited(origin, type), CanQueryDiskSize(origin)));
 }
 
 void QuotaManager::GetUsageAndQuota(
     const GURL& origin, StorageType type,
     const GetUsageAndQuotaCallback& callback) {
   DCHECK(origin == origin.GetOrigin());
 
   if (IsStorageUnlimited(origin, type)) {
     CallGetUsageAndQuotaCallback(
-        callback, false, IsInstalledApp(origin),
+        callback, false, CanQueryDiskSize(origin),
         kQuotaStatusOk, QuotaAndUsage::CreateForUnlimitedStorage());
     return;
   }
 
   GetUsageAndQuotaForWebApps(origin, type, callback);
 }
 
 void QuotaManager::NotifyStorageAccessed(
     QuotaClient::ID client_id,
     const GURL& origin, StorageType type) {
@@ skipping 790 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::SingleThreadTaskRunner* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota