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.

[kinuko, 2011/05/18 14:10:51]

might want to record the # of errors in the eviction context?  (At least we
could show the values via quota-internals)

[Dai Mikurube (NOT FULLTIME), 2011/05/19 02:28:03]

Done.  Added a TODO: "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) {

[kinuko, 2011/05/18 14:10:51]

Nit: Looking at this code again (with longer variable names) I wonder (as
michael did) if we could do this with single variable.  clients_.size() is
quasi-constant and won't change throughout the almost entire life of the quota
manager.  Keeping these two variables and 
re-assigning requested_clients = clients_.size() every time we call EvictOrigin
looks a bit verbose.

[Dai Mikurube (NOT FULLTIME), 2011/05/19 02:28:03]

Is that so impressive?  As I replied to Michael, I know it's a little redundant,
but it is useful for debugging (and testing with some additional interface).

If we think that clients_.size() every time looks a bit verbose, I believe we
should replace QuotaClientList with std::vector, not std::list, unless the
number of clients is a solid constant.  std::vector::push_back() doesn't cost so
much if clients_.size() is quasi-constant.

I addition, even if we do it with a single variable, I guess we have to
initialize the variable with clients_.size().

[kinuko, 2011/05/19 02:48:42]

Mikurube-san, as you can see this comment is prefixed by 'nit', which wouldn't
mean to express something impressive.
I wouldn't oppose if you have a strong reason.
This part I didn't get very well, but since this is really a tiny bit I'd just
trust you.
vector::push_back is in general very efficient, often more efficient than list
even if it changes its size if the efficiency is the point.  You can put TODO at
QuotaClientList if you want or can just go ahead changing it.
That's true, I should have said initializing two vars looked a bit verbose to
me.

[Dai Mikurube (NOT FULLTIME), 2011/05/19 03:20:09]

FYI, what I thought was tracking both of the total number and the evicted number
helps us debugging, for example, when some of clients don't callback.  We could
see the total number immediately when it happens.
Added TODO.

+    eviction_context_.num_eviction_requested_clients = 0;
+    eviction_context_.num_evicted_clients = 0;
 
-    evict_origin_data_callback_->Run(kQuotaStatusOk);
-    evict_origin_data_callback_.reset();
+    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