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,
+    const FilePath& path,
     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;
+  printf("unlimited: %d\n", unlimited);
+  int64 quota = unlimited ? quota_and_usage.available_disk_space :

[kinuko, 2012/08/13 14:07:52]

(You might be changing this but to make sure) I think we should return the
available disk space if and ONLY if the quota is requested by installed apps
(i.e. for the apps ExtensionService::IsInstalledApp() returns true)

[James Hawkins, 2012/08/17 21:33:22]

I'm attempting to add support for this check now, but I haven't yet figured out
how to query the ExtensionService from content/.  Any clues?

+      quota_and_usage.quota;
+  printf("quota: %ld\n", 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 529 matching lines @@
   std::set<GURL> origins_;
   bool has_registered_origins_;
 };
 
 class QuotaManager::AvailableSpaceQueryTask : public QuotaThreadTask {
  public:
   AvailableSpaceQueryTask(
       QuotaManager* manager,
       const AvailableSpaceCallback& callback)
       : QuotaThreadTask(manager, manager->db_thread_),
-        profile_path_(manager->profile_path_),
+        quota_manager_(manager),
         space_(-1),
         callback_(callback) {
   }
 
  protected:
   virtual ~AvailableSpaceQueryTask() {}
 
   // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
-    space_ = base::SysInfo::AmountOfFreeDiskSpace(profile_path_);
+    space_ = quota_manager_->GetAvailableDiskSpace();
   }
 
   virtual void Aborted() OVERRIDE {
     callback_.Reset();
   }
 
   virtual void Completed() OVERRIDE {
     callback_.Run(kQuotaStatusOk, space_);
   }
 
  private:
-  FilePath profile_path_;
+  scoped_refptr<QuotaManager> quota_manager_;
   int64 space_;
   AvailableSpaceCallback callback_;
 };
 
 class QuotaManager::UpdateAccessTimeTask
     : public QuotaManager::DatabaseTaskBase {
  public:
   UpdateAccessTimeTask(
       QuotaManager* manager,
       const GURL& origin,
@@ skipping 214 matching lines @@
 
 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), profile_path_));
 }
 
 void QuotaManager::GetAvailableSpace(const AvailableSpaceCallback& callback) {
   if (is_incognito_) {
     callback.Run(kQuotaStatusOk, kIncognitoDefaultTemporaryQuota);
     return;
   }
   make_scoped_refptr(new AvailableSpaceQueryTask(this, callback))->Start();
 }
 
@@ skipping 99 matching lines @@
 
 void QuotaManager::GetOriginsModifiedSince(StorageType type,
                                            base::Time modified_since,
                                            const GetOriginsCallback& callback) {
   LazyInitialize();
   make_scoped_refptr(new GetModifiedSinceTask(
       this, type, modified_since, callback))->Start();
 }
 
 QuotaManager::~QuotaManager() {
+  printf("~QuotaManager\n");
   proxy_->manager_ = NULL;
   std::for_each(clients_.begin(), clients_.end(),
                 std::mem_fun(&QuotaClient::OnQuotaManagerDestroyed));
   if (database_.get())
     db_thread_->DeleteSoon(FROM_HERE, database_.release());
 }
 
+int64 QuotaManager::GetAvailableDiskSpace() const {
+  return base::SysInfo::AmountOfFreeDiskSpace(profile_path_);

[kinuko, 2012/08/13 14:07:52]

Hmm.  How about using a static function pointer (which is safely guarded for
thread safety) instead of having this virtual method?  We can override only in
the tests and if it's not set we can use the base::SysInfo one.

+}
+
 void QuotaManager::LazyInitialize() {
   DCHECK(io_thread_->BelongsToCurrentThread());
   if (database_.get()) {
     // Initialization seems to be done already.
     return;
   }
 
   // Use an empty path to open an in-memory only databse for incognito.
   database_.reset(new QuotaDatabase(is_incognito_ ? FilePath() :
       profile_path_.AppendASCII(kDatabaseName)));
@@ skipping 473 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::SingleThreadTaskRunner* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota