QuotaManager: Return the remaining free disk space as quota.

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 59 matching lines @@
 
 const int QuotaManager::kThresholdOfErrorsToBeBlacklisted = 3;
 
 const int QuotaManager::kEvictionIntervalInMilliSeconds =
     30 * kMinutesInMilliSeconds;
 
 // Callback translators.
 void CallGetUsageAndQuotaCallback(
     const QuotaManager::GetUsageAndQuotaCallback& callback,
     bool unlimited,
+    bool is_installed_app,
     QuotaStatusCode status,
     const QuotaAndUsage& quota_and_usage) {
-  int64 usage =
-      unlimited ? quota_and_usage.unlimited_usage : quota_and_usage.usage;
-  int64 quota = unlimited ? QuotaManager::kNoLimit : quota_and_usage.quota;
+  int64 usage;
+  int64 quota;
+
+  if (unlimited) {
+    usage = quota_and_usage.unlimited_usage;
+    quota = is_installed_app ? quota_and_usage.available_disk_space :
+        kint64max;

[kinuko, 2012/08/20 04:04:44]

nit: kint64max -> kNoLimit since that's what we check against in the unittest?

[James Hawkins, 2012/08/22 18:51:36]

Done.

+  } 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);
 }
@@ skipping 304 matching lines @@
   UsageAndQuotaDispatcherTaskForPersistent(
       QuotaManager* manager, const HostAndType& host_and_type)
       : UsageAndQuotaDispatcherTask(manager, host_and_type) {}
 
  protected:
   virtual void RunBody() OVERRIDE {
     manager()->persistent_usage_tracker_->GetHostUsage(
         host(), NewWaitableHostUsageCallback());
     manager()->GetPersistentHostQuota(
         host(), NewWaitableHostQuotaCallback());
+    manager()->GetAvailableSpace(NewWaitableAvailableSpaceCallback());
   }
 
   virtual void DispatchCallbacks() OVERRIDE {
     CallCallbacksAndClear(quota_status(),
                           host_usage(), host_usage(), host_quota(),
                           available_space());
   }
 };
 
 class QuotaManager::UsageAndQuotaDispatcherTaskForTemporaryGlobal
@@ skipping 531 matching lines @@
 };
 
 class QuotaManager::AvailableSpaceQueryTask : public QuotaThreadTask {
  public:
   AvailableSpaceQueryTask(
       QuotaManager* manager,
       const AvailableSpaceCallback& callback)
       : QuotaThreadTask(manager, manager->db_thread_),
         profile_path_(manager->profile_path_),
         space_(-1),
+        get_disk_space_fn_(manager->get_disk_space_fn_),
         callback_(callback) {

[kinuko, 2012/08/20 04:04:44]

nit: maybe DCHECK(get_disk_space_fn) here?

[James Hawkins, 2012/08/22 18:51:36]

Done.

   }
 
  protected:
   virtual ~AvailableSpaceQueryTask() {}
 
   // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
-    space_ = base::SysInfo::AmountOfFreeDiskSpace(profile_path_);
+    space_ = get_disk_space_fn_(profile_path_);
   }
 
   virtual void Aborted() OVERRIDE {
     callback_.Reset();
   }
 
   virtual void Completed() OVERRIDE {
     callback_.Run(kQuotaStatusOk, space_);
   }
 
  private:
   FilePath profile_path_;
   int64 space_;
+  GetAvailableDiskSpaceFn get_disk_space_fn_;
   AvailableSpaceCallback callback_;
 };
 
 class QuotaManager::UpdateAccessTimeTask
     : public QuotaManager::DatabaseTaskBase {
  public:
   UpdateAccessTimeTask(
       QuotaManager* manager,
       const GURL& origin,
       StorageType type,
@@ skipping 201 matching lines @@
     proxy_(new QuotaManagerProxy(
         ALLOW_THIS_IN_INITIALIZER_LIST(this), io_thread)),
     db_disabled_(false),
     eviction_disabled_(false),
     io_thread_(io_thread),
     db_thread_(db_thread),
     temporary_quota_initialized_(false),
     temporary_quota_override_(-1),
     desired_available_space_(-1),
     special_storage_policy_(special_storage_policy),
-    weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+    weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+    get_disk_space_fn_(&base::SysInfo::AmountOfFreeDiskSpace) {
 }
 
 void QuotaManager::GetUsageInfo(const GetUsageInfoCallback& callback) {
   LazyInitialize();
   GetUsageInfoTask* get_usage_info = new GetUsageInfoTask(this, callback);
   get_usage_info->Start();
 }
 
 void QuotaManager::GetUsageAndQuota(
     const GURL& origin, StorageType type,
     const GetUsageAndQuotaCallback& callback) {
-  GetUsageAndQuotaInternal(origin, type, false /* global */,
-                           base::Bind(&CallGetUsageAndQuotaCallback,
-                                      callback, IsStorageUnlimited(origin)));
+  GetUsageAndQuotaInternal(
+      origin, type, false /* global */,
+      base::Bind(&CallGetUsageAndQuotaCallback, callback,
+                 IsStorageUnlimited(origin), IsInstalledApp(origin)));
 }
 
 void QuotaManager::GetAvailableSpace(const AvailableSpaceCallback& callback) {
   if (is_incognito_) {
     callback.Run(kQuotaStatusOk, kIncognitoDefaultTemporaryQuota);
     return;
   }
   make_scoped_refptr(new AvailableSpaceQueryTask(this, callback))->Start();
 }
 
@@ skipping 606 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::SingleThreadTaskRunner* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota