Implement QuotaTemporaryStorageEvictor.

webkit/quota/quota_temporary_storage_evictor.h

+// 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/ref_counted.h"
+#include "base/memory/scoped_callback_factory.h"
+#include "webkit/quota/quota_database.h"
+#include "webkit/quota/quota_manager.h"
+#include "webkit/quota/quota_task.h"
+#include "webkit/quota/quota_types.h"
+
+class GURL;
+
+namespace quota {
+
+struct QuotaTemporaryStorageEvictorDeleter;
+
+class QuotaTemporaryStorageEvictor
+    : public base::RefCountedThreadSafe<QuotaTemporaryStorageEvictor,
+                                        QuotaTemporaryStorageEvictorDeleter> {

[michaeln, 2011/05/17 00:19:03]

I don't understand why this is refcounted much less refcounted thread safe?
Doesn't the QM live on the IO thread and this just interacts with the QM. So how
do other threads come into play at all?

Have you seen base/timer.h... the OneShotTimer<> and RepeatingTimer<> classes?
What if the QM had a MaybeEvict method that got called on a timer.

[Dai Mikurube (NOT FULLTIME), 2011/05/17 05:02:13]

In the previous version, it was running on the db_thread and io_thread.  This
patch set currently runs only on the io_thread, but the patch set doesn't change
it.  The set was just for separating out QuotaTemporaryStorageEvictor.
Hmm, thanks! I'll be taking a look at them.

+ public:
+  // Constructed on the io_thread.
+  QuotaTemporaryStorageEvictor(
+      int64 target_available_space,
+      int64 delay_ms,
+      scoped_refptr<base::MessageLoopProxy> io_message_loop);
+  virtual ~QuotaTemporaryStorageEvictor();
+
+  // TODO(dmikurube): Make it a private friend of QuotaManager ?
+  void RegisterQuotaManagerOnIOThread(QuotaEvictionHandler* quota_manager);
+
+  // It can be called from any thread.
+  // It posts a task to the io_thread internally.
+  void Start();
+
+  // It must be called on the io_thread.
+  void OnQuotaManagerDestroyedOnIOThread();
+
+  bool repeated_eviction() const { return repeated_eviction_; }
+  void set_repeated_eviction(bool repeated_eviction) {
+    repeated_eviction_ = repeated_eviction;
+  }
+
+  static const double kUsageRatioToBeEvicted;
+  const int64 physical_available_space_to_be_evicted;
+
+ private:
+  friend struct QuotaTemporaryStorageEvictorDeleter;
+  friend class QuotaTemporaryStorageEvictorTest;
+
+  void Evict(bool delete_immediately);
+
+  // It must be called-back from the io_thread.
+  void OnDeletionCompletedOnIOThread(
+      QuotaStatusCode status,
+      int64 usage,
+      int64 quota,
+      int64 physical_available_space);
+
+  // They must be called on the io_thread.
+  void CallDeleteOriginOnIOThread(const GURL& origin);
+  void CallGetUsageAndQuotaOnIOThread();
+
+  void DeleteOnCorrectThread() const;
+
+  // This pointer must be accessed in the io_thread.
+  QuotaEvictionHandler* quota_manager_;
+
+  int64 target_available_space_;
+  int64 delay_ms_;
+  bool repeated_eviction_;
+  scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+
+  base::ScopedCallbackFactory<QuotaTemporaryStorageEvictor> callback_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(QuotaTemporaryStorageEvictor);
+};
+
+struct QuotaTemporaryStorageEvictorDeleter {
+  static void Destruct(const QuotaTemporaryStorageEvictor* evictor) {
+    LOG(ERROR) << "Deleter::Destruct";
+    evictor->DeleteOnCorrectThread();
+  }
+};
+
+}  // namespace quota
+
+#endif  // WEBKIT_QUOTA_QUOTA_TEMPORARY_STORAGE_EVICTOR_H_