Implement QuotaTemporaryStorageEvictor.

webkit/quota/quota_temporary_storage_evictor.cc

Index: webkit/quota/quota_temporary_storage_evictor.cc
diff --git a/webkit/quota/quota_temporary_storage_evictor.cc b/webkit/quota/quota_temporary_storage_evictor.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d84711b6d9b2c630ed8ae367aa104ab3224d752b
--- /dev/null
+++ b/webkit/quota/quota_temporary_storage_evictor.cc
@@ -0,0 +1,101 @@
+// 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_temporary_storage_evictor.h"
+
+#include "googleurl/src/gurl.h"
+
+namespace quota {
+
+const double QuotaTemporaryStorageEvictor::kUsageRatioToBeEvicted = 0.7;
+
+QuotaTemporaryStorageEvictor::QuotaTemporaryStorageEvictor(
+    QuotaEvictionHandler* quota_eviction_handler,
+    int64 target_available_space,
+    int64 delay_ms,
+    scoped_refptr<base::MessageLoopProxy> io_thread)
+    : physical_available_space_to_be_evicted(1000 * 1000 * 500),

[kinuko, 2011/05/19 09:27:18]

nit: to be evicted -> to start eviction ? (from the viewpoint of evictor)

Can this simply be a const var like kUsageRatioToBeEvicted?

[Dai Mikurube (NOT FULLTIME), 2011/05/20 02:42:24]

Renamed them to:
  static const double kUsageRatioToStartEvictiony;
  const int64 kAvailableDiskSpaceToStartEviction;

+      quota_eviction_handler_(quota_eviction_handler),
+      target_available_space_(target_available_space),

[kinuko, 2011/05/19 09:27:18]

not used now?

[Dai Mikurube (NOT FULLTIME), 2011/05/20 02:42:24]

Done.

+      delay_ms_(delay_ms),

[kinuko, 2011/05/19 09:27:18]

interval_ms_? (since this is used for repeated eviction)

Could this be a const as well?

[Dai Mikurube (NOT FULLTIME), 2011/05/20 02:42:24]

My thought was that it might be changed at run-time with adding some interface
like set_interval_ms[_from_next_eviction]().

[kinuko, 2011/05/20 06:41:13]

Ok if we change the value it makes sense.

+      repeated_eviction_(false),
+      io_thread_(io_thread),
+      callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {

[kinuko, 2011/05/19 09:27:18]

I guess now we can DCHECK(quota_eviction_handler) here and remove all the "if
(quota_eviction_handler)" guards from the code?

[Dai Mikurube (NOT FULLTIME), 2011/05/20 02:42:24]

Done.

+}
+
+QuotaTemporaryStorageEvictor::~QuotaTemporaryStorageEvictor() {
+}
+
+void QuotaTemporaryStorageEvictor::OnQuotaManagerDestroyedOnIOThread() {

[kinuko, 2011/05/19 09:27:18]

Now we can happily get rid of this.

[Dai Mikurube (NOT FULLTIME), 2011/05/20 02:42:24]

Done.

+  DCHECK(io_thread_->BelongsToCurrentThread());
+  quota_eviction_handler_ = NULL;
+}
+
+void QuotaTemporaryStorageEvictor::OnEvictionCompleted(
+    QuotaStatusCode status) {
+  DCHECK(io_thread_->BelongsToCurrentThread());
+
+  // Check if more eviction is immediately required?
+  if (quota_eviction_handler_ != NULL) {
+    quota_eviction_handler_->GetUsageAndQuotaForEviction(callback_factory_.
+        NewCallback(&QuotaTemporaryStorageEvictor::EvictIfRequired));
+  }
+}
+
+void QuotaTemporaryStorageEvictor::DoEvict(const GURL& origin) {
+  DCHECK(io_thread_->BelongsToCurrentThread());
+
+  if (origin.is_empty()) {
+    if (repeated_eviction_)
+      repeated_eviction_ = false;

[kinuko, 2011/05/19 09:27:18]

why do we flip the flag here?

GetLRUOrigin may return false if all of the registered origins are in use.

[Dai Mikurube (NOT FULLTIME), 2011/05/20 02:42:24]

Oh, I wrongly edited this line.  MayStartEviction(...) correctly.

+    return;
+  }
+
+  if (quota_eviction_handler_ != NULL) {
+    quota_eviction_handler_->EvictOriginData(
+        origin, kStorageTypeTemporary, callback_factory_.NewCallback(
+            &QuotaTemporaryStorageEvictor::OnEvictionCompleted));
+  }
+}
+
+void QuotaTemporaryStorageEvictor::EvictIfRequired(
+    QuotaStatusCode status,
+    int64 usage,
+    int64 quota,
+    int64 physical_available_space) {
+  DCHECK(io_thread_->BelongsToCurrentThread());
+
+  if (status == kQuotaStatusOk &&
+      (usage > quota * kUsageRatioToBeEvicted ||
+       physical_available_space_to_be_evicted > physical_available_space)) {
+    if (quota_eviction_handler_ != NULL) {
+      quota_eviction_handler_->GetLRUOrigin(kStorageTypeTemporary,
+          callback_factory_.NewCallback(
+              &QuotaTemporaryStorageEvictor::DoEvict));
+    }
+  } else if (repeated_eviction_) {

[kinuko, 2011/05/19 09:27:18]

Maybe if we get status != kQuotaStatusOk more than a certain number we should
stop eviction?

[Dai Mikurube (NOT FULLTIME), 2011/05/20 02:42:24]

We should discuss error handling for the entire eviction.

My current thought is:
* Error in getting usage&quota => stop if many errors?
* Error in eviction => ignore the origin in the next time?

[kinuko, 2011/05/20 06:41:13]

sgtm.
For the latter case we may also want to remove it from the eviction candidates
if we get too many errors for a particular origin.  If it's the oldest one we
might be trying to evict the origin forever. (E.g. Like keeping set<GURL>
error_origins_ in the QM and adding them to the exceptions when we call
GetLRUOrigin)  Wdyt?

+    MayStartEviction(delay_ms_);
+  }
+}
+
+void QuotaTemporaryStorageEvictor::GetUsageAndQuotaThenEvict() {
+  if (quota_eviction_handler_ != NULL) {
+    quota_eviction_handler_->GetUsageAndQuotaForEviction(callback_factory_.
+        NewCallback(&QuotaTemporaryStorageEvictor::EvictIfRequired));
+  }
+}
+
+void QuotaTemporaryStorageEvictor::MayStartEviction(int delay_ms) {
+  if (timer_.IsRunning())
+    return;
+  timer_.Start(base::TimeDelta::FromMilliseconds(delay_ms), this,
+               &QuotaTemporaryStorageEvictor::GetUsageAndQuotaThenEvict);
+}
+
+void QuotaTemporaryStorageEvictor::Start() {

[kinuko, 2011/05/19 09:27:18]

Do we need this func? (I guess we could either call MayStartEviction or
GetUsageAndQuotaThenEvict)

[Dai Mikurube (NOT FULLTIME), 2011/05/20 02:42:24]

Hmm, MayStartEviction and GetUsageAndQuotaThenEvict looked not so good name for
public interface.  Thinking about another name.

[kinuko, 2011/05/20 06:43:49]

First I thought GetUsageAndQuotaThenEvict could be just called Evict but it
might be confusing as we also have DoEvict.

Simply MayStartEviction() and StartEviction()?

[Dai Mikurube (NOT FULLTIME), 2011/05/20 07:36:54]

Finally, you say which should be MayStartEviction(), which should be
StartEviction()?

GetUsageAndQuotaThenEvict() => StartEviction() and
Start() => removed?

+  DCHECK(io_thread_->BelongsToCurrentThread());
+  MayStartEviction(0);
+}
+
+}  // namespace quota