Implement QuotaTemporaryStorageEvictor.

webkit/quota/quota_temporary_storage_evictor.h

Index: webkit/quota/quota_temporary_storage_evictor.h
diff --git a/webkit/quota/quota_temporary_storage_evictor.h b/webkit/quota/quota_temporary_storage_evictor.h
new file mode 100644
index 0000000000000000000000000000000000000000..6b1441aac04420af723298954cf7ca8665223120
--- /dev/null
+++ b/webkit/quota/quota_temporary_storage_evictor.h
@@ -0,0 +1,68 @@
+// 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.
+
+#ifndef WEBKIT_QUOTA_QUOTA_TEMPORARY_STORAGE_EVICTOR_H_
+#define WEBKIT_QUOTA_QUOTA_TEMPORARY_STORAGE_EVICTOR_H_
+#pragma once
+
+#include "base/message_loop_proxy.h"
+#include "base/memory/scoped_callback_factory.h"
+#include "base/timer.h"
+#include "webkit/quota/quota_manager.h"
+#include "webkit/quota/quota_types.h"
+
+class GURL;
+
+namespace quota {
+
+class QuotaTemporaryStorageEvictor {
+ public:
+  QuotaTemporaryStorageEvictor(
+      QuotaEvictionHandler* quota_eviction_handler,
+      int64 interval_ms,
+      scoped_refptr<base::MessageLoopProxy> io_thread);
+  virtual ~QuotaTemporaryStorageEvictor();
+
+  void Start();
+
+  bool repeated_eviction() const { return repeated_eviction_; }

[michaeln, 2011/05/23 19:53:47]

I understand what Start() means, but what does repeated_eviction mean? It
doesn't seem to mean the Evictor should repeatedly consider what to evict next
as that seems to be the case regardless of this flag.

When and why would this bool attribute be get/set by the QuotaManager?

[Dai Mikurube (NOT FULLTIME), 2011/05/24 05:59:04]

The Evictor is expected to run repeatedly by itself normally.  This flag is
prepared to
* make testing easy with repeated_eviction == false, and
* stop eviction safely if required.

When repeated_eviction is set to false, the Evictor stops itself after it runs
the next eviction.  When repeated_eviction is set to true, the Evictor runs
eviction repeatedly with intervals.

+  void set_repeated_eviction(bool repeated_eviction) {
+    repeated_eviction_ = repeated_eviction;
+  }
+
+  static const double kUsageRatioToStartEviction;
+  static const int64 kDefaultMinAvailableDiskSpaceToStartEviction;
+  const int64 min_available_disk_space_to_start_eviction_;

[michaeln, 2011/05/23 19:53:47]

Do these belong in the public interface?

[Dai Mikurube (NOT FULLTIME), 2011/05/24 05:59:04]

Ah, exactly.  Moved them to private.

+
+ private:
+  friend struct QuotaTemporaryStorageEvictorDeleter;
+  friend class QuotaTemporaryStorageEvictorTest;
+
+  void MayStartEviction(int interval_ms);
+  void GetUsageAndQuotaThenEvict();
+  void EvictIfRequired(
+      QuotaStatusCode status,
+      int64 usage,
+      int64 quota,
+      int64 available_disk_space);
+  void DoEvict(const GURL& origin);
+  void OnEvictionCompleted(QuotaStatusCode status);

[michaeln, 2011/05/23 19:53:47]

I found these method names to be difficult to follow. They're mostly used as
callbacks to QM methods and it's not clear which is called back from what. Are
these names an improvement?

void StartEvictionTimer() {
  timer_.Start(kEvictionInterval, &ConsiderEviction);
}

void ConsiderEviction() {
  // Get usage and disk space, then continue.
  mgr->GetUsageAndQuotaForEviction(callback_factory_.
      NewCallback(&OnGotUsageAndQuotaForEviction))

}

void OnGotUsageAndQuotaForEviction(
    QuotaStatusCode status, int64 usage, int64 quota, int64 free_disk_space) {
  const double kUsageRatioToStartEviction = 0.7;
  const int64 kDiskSpaceToKeepFree = 1000 * 1000 * 500;
  if (status == kQuotaStatusOk &&
      (usage > quota * kUsageRatioToStartEviction ||
       available_disk_space < kDiskSpaceToKeepFree )) {
    // Space is getting tight. Get the least recently used origin and continue.
    mgr->GetLRUOrigin(kStorageTypeTemporary, callback_factory_.NewCallback(
        &OnGotLRUOrigin));
    return;
  }
  // No action required, sleep for a while check again later.
  StartEvictionTimer();
}

void OnGotLRUOrigin(const GURL& origin) {
  if (origin.is_empty()) {
    StartEvictionTimer();
    return;
  }
  mgr->EvictOriginData(origin, kStorageTypeTemporary,
      callback_factory_.NewCallback(&OnEvictionComplete));
}

void OnEvictionComplete(QuotaStatusCode status) {
  if (status != OK) {
    StartEvictionTimer();
    return;
  }
  // We many need to get rid of more space so reconsider immediately.
  ConsiderEviction();
}

[Dai Mikurube (NOT FULLTIME), 2011/05/24 05:59:04]

Thank you for the suggestion.  I chose your method names and some comments. 
Then I reordered the methods.

+
+  // Not owned; quota_eviction_handler owns us.
+  QuotaEvictionHandler* quota_eviction_handler_;
+
+  int64 interval_ms_;
+  bool repeated_eviction_;
+  scoped_refptr<base::MessageLoopProxy> io_thread_;
+
+  base::OneShotTimer<QuotaTemporaryStorageEvictor> timer_;
+
+  base::ScopedCallbackFactory<QuotaTemporaryStorageEvictor> callback_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(QuotaTemporaryStorageEvictor);
+};
+
+}  // namespace quota
+
+#endif  // WEBKIT_QUOTA_QUOTA_TEMPORARY_STORAGE_EVICTOR_H_