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),
-    num_eviction_requested_clients_(0),
-    num_evicted_clients_(0),
     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())
@@ skipping 235 matching lines @@
   scoped_refptr<GetLRUOriginTask> task(new GetLRUOriginTask(
       this, database_.get(), db_thread_, type, origins_in_use_, callback));
   task->Start();
 }
 
 void QuotaManager::DidOriginDataEvicted(
     QuotaStatusCode status) {
   DCHECK(io_thread_->BelongsToCurrentThread());
 
   if (status != kQuotaStatusOk) {
-    // TODO(dmikurube): Handle error.
+    ++eviction_context_.num_eviction_error;
+    // TODO(dmikurube): The origin with some error should have lower priority in
+    // the next eviction?
   }
 
-  ++num_evicted_clients_;
-  DCHECK(num_evicted_clients_ <= num_eviction_requested_clients_);
-  if (num_evicted_clients_ == num_eviction_requested_clients_) {
-    num_eviction_requested_clients_ = 0;
-    num_evicted_clients_ = 0;
+  ++eviction_context_.num_evicted_clients;
+  DCHECK(eviction_context_.num_evicted_clients <=
+      eviction_context_.num_eviction_requested_clients);
+  if (eviction_context_.num_evicted_clients ==
+      eviction_context_.num_eviction_requested_clients) {
+    eviction_context_.num_eviction_requested_clients = 0;
+    eviction_context_.num_evicted_clients = 0;
 
-    evict_origin_data_callback_->Run(kQuotaStatusOk);
-    evict_origin_data_callback_.reset();
+    // TODO(dmikurube): Call DeleteOriginFromDatabase here.
+    eviction_context_.evict_origin_data_callback->Run(kQuotaStatusOk);
+    eviction_context_.evict_origin_data_callback.reset();
   }
 }
 
 void QuotaManager::EvictOriginData(
     const GURL& origin,
     StorageType type,
     EvictOriginDataCallback* callback) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   DCHECK(database_.get());
-  DCHECK(num_eviction_requested_clients_ == 0);
+  DCHECK(eviction_context_.num_eviction_requested_clients == 0);
   DCHECK(type == kStorageTypeTemporary);
 
   int num_clients = clients_.size();
 
   if (origin.is_empty() || num_clients == 0) {
     callback->Run(kQuotaStatusOk);
     delete callback;
     return;
   }
 
-  num_eviction_requested_clients_ = num_clients;
-  num_evicted_clients_ = 0;
+  eviction_context_.num_eviction_requested_clients = num_clients;
+  eviction_context_.num_evicted_clients = 0;
 
-  evict_origin_data_callback_.reset(callback);
+  eviction_context_.evict_origin_data_callback.reset(callback);
   for (QuotaClientList::iterator p = clients_.begin();
        p != clients_.end();
        ++p) {
     (*p)->DeleteOriginData(origin, type, callback_factory_.
         NewCallback(&QuotaManager::DidOriginDataEvicted));
   }
 }
 
+void QuotaManager::DidGetAvailableSpaceForEviction(
+    QuotaStatusCode status,
+    int64 available_space) {
+  eviction_context_.get_usage_and_quota_callback->Run(status,
+      eviction_context_.usage, eviction_context_.quota, available_space);
+  eviction_context_.get_usage_and_quota_callback.reset();
+}
+
+void QuotaManager::DidGetGlobalQuotaForEviction(
+    QuotaStatusCode status,
+    int64 quota) {
+  if (status != kQuotaStatusOk) {
+    eviction_context_.get_usage_and_quota_callback->Run(status,
+        eviction_context_.usage, quota, 0);
+    eviction_context_.get_usage_and_quota_callback.reset();
+    return;
+  }
+
+  eviction_context_.quota = quota;
+  GetAvailableSpace(callback_factory_.
+      NewCallback(&QuotaManager::DidGetAvailableSpaceForEviction));
+}
+
+void QuotaManager::DidGetGlobalUsageForEviction(int64 usage) {
+  eviction_context_.usage = usage;
+  GetTemporaryGlobalQuota(callback_factory_.
+      NewCallback(&QuotaManager::DidGetGlobalQuotaForEviction));
+}
+
 void QuotaManager::GetUsageAndQuotaForEviction(
     GetUsageAndQuotaForEvictionCallback* callback) {
-  // TODO(dmikurube): Implement it.
+  DCHECK(io_thread_->BelongsToCurrentThread());
+  DCHECK(!eviction_context_.get_usage_and_quota_callback.get());
+
+  eviction_context_.get_usage_and_quota_callback.reset(callback);
+  // TODO(dmikurube): Make kStorageTypeTemporary an argument.
+  GetGlobalUsage(kStorageTypeTemporary, callback_factory_.
+      NewCallback(&QuotaManager::DidGetGlobalUsageForEviction));
 }
 
 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