Implement GetUsageAndQuotaForEviction in QuotaManager.

webkit/quota/quota_manager.cc

 // Copyright (c) 2011 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 506 matching lines @@
                            const FilePath& profile_path,
                            base::MessageLoopProxy* io_thread,
                            base::MessageLoopProxy* db_thread)
   : is_incognito_(is_incognito),
     profile_path_(profile_path),
     proxy_(new QuotaManagerProxy(
         ALLOW_THIS_IN_INITIALIZER_LIST(this), io_thread)),
     db_disabled_(false),
     io_thread_(io_thread),
     db_thread_(db_thread),
-    temporary_global_quota_(-1) {
+    usage_for_eviction_(0),
+    quota_for_eviction_(0),

[kinuko, 2011/05/18 06:26:55]

Now I seriously started wondering if we could have all those eviction-related
state/callback variables in a separate inner struct or class.

[Dai Mikurube (NOT FULLTIME), 2011/05/18 06:37:20]

I agree with that, but how about doing that later as a refactoring?

+    temporary_global_quota_(-1),
+    callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 QuotaManager::~QuotaManager() {
   DCHECK(io_thread_->BelongsToCurrentThread());
   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());
 }
@@ skipping 235 matching lines @@
   task->Start();
 }
 
 void QuotaManager::EvictOriginData(
     const GURL& origin,
     StorageType type,
     EvictOriginDataCallback* callback) {
   // TODO(dmikurube): Implement it.
 }
 
+void QuotaManager::OnGetAvailableSpaceForEviction(
+    QuotaStatusCode status,
+    int64 available_space) {
+  get_usage_and_quota_for_eviction_callback_->Run(status,
+      usage_for_eviction_, quota_for_eviction_, available_space);
+  get_usage_and_quota_for_eviction_callback_.reset();
+}
+
+void QuotaManager::OnGetGlobalQuotaForEviction(
+    QuotaStatusCode status,
+    int64 quota) {
+  if (status != kQuotaStatusOk) {
+    get_usage_and_quota_for_eviction_callback_->Run(status,
+        usage_for_eviction_, quota, 0);
+    get_usage_and_quota_for_eviction_callback_.reset();
+    return;
+  }
+
+  quota_for_eviction_ = quota;
+  GetAvailableSpace(callback_factory_.
+      NewCallback(&QuotaManager::OnGetAvailableSpaceForEviction));

[kinuko, 2011/05/18 06:26:55]

We could call all those async methods at once and collect results.

[Dai Mikurube (NOT FULLTIME), 2011/05/18 06:37:20]

Is that a serious requirement?  Calling them async and collecting the results on
these callbacks looks complicated.

+}
+
+void QuotaManager::OnGetGlobalUsageForEviction(int64 usage) {
+  usage_for_eviction_ = usage;
+  GetTemporaryGlobalQuota(callback_factory_.
+      NewCallback(&QuotaManager::OnGetGlobalQuotaForEviction));
+}
+
 void QuotaManager::GetUsageAndQuotaForEviction(
     GetUsageAndQuotaForEvictionCallback* callback) {
-  // TODO(dmikurube): Implement it.
+  DCHECK(io_thread_->BelongsToCurrentThread());
+
+  get_usage_and_quota_for_eviction_callback_.reset(callback);
+  // TODO(dmikurube): Make kStorageTypeTemporary an argument?

[kinuko, 2011/05/18 06:26:55]

I think we should either add or drop the type parameter to/from all the
eviction-related methods.

[Dai Mikurube (NOT FULLTIME), 2011/05/18 06:37:20]

I think we might want to do that as a refactoring since the change lists on
eviction are now separated...

+  GetGlobalUsage(kStorageTypeTemporary, callback_factory_.
+      NewCallback(&QuotaManager::OnGetGlobalUsageForEviction));
 }
 
 void QuotaManager::DeleteOnCorrectThread() const {
   if (!io_thread_->BelongsToCurrentThread()) {
     io_thread_->DeleteSoon(FROM_HERE, this);
     return;
   }
   delete this;
 }
 
@@ skipping 82 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::MessageLoopProxy* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota