Implement QuotaTemporaryStorageEvictor.

webkit/quota/quota_task.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_task.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/message_loop_proxy.h"
@@ skipping 49 matching lines @@
       this, &QuotaThreadTask::CallRunOnTargetThread));
 }
 
 void QuotaThreadTask::CallRunOnTargetThread() {
   DCHECK(target_message_loop_->BelongsToCurrentThread());
   RunOnTargetThread();
   original_message_loop()->PostTask(
       FROM_HERE, NewRunnableMethod(this, &QuotaThreadTask::CallCompleted));
 }
 
+// QuotaDelayedThreadTask --------------------------------------------------
+
+QuotaDelayedThreadTask::QuotaDelayedThreadTask(
+    QuotaTaskObserver* observer,
+    scoped_refptr<base::MessageLoopProxy> target_message_loop
+    int64 delay_ms)
+    : QuotaThreadTask(observer, target_message_loop),
+      delay_ms_(delay_ms) {
+}
+
+void QuotaDelayedThreadTask::Run() {
+  target_message_loop_->PostDelayedTask(FROM_HERE, NewRunnableMethod(
+      this, &QuotaThreadTask::CallRunOnTargetThread), delay_ms_);

[kinuko, 2011/05/11 07:49:30]

On the second thought I guess for Evictor's main job we can simply/directly call
this PostDelayedTask in the Evictor code using ScopedRunnableMethodFactory?  It
doesn't need to carry around per-task / per-invocation info but will need to
continuously work using the evictor's shared status.  (while in the main method
we may still need to post some quota thread tasks)

[Dai Mikurube (NOT FULLTIME), 2011/05/11 11:23:50]

Changed it and removed QuotaDelayedThreadTask.  BTW, what is the need to post
quota thread tasks?

[Dai Mikurube (NOT FULLTIME), 2011/05/11 11:31:31]

Ah, failed to remove it.  Removed in the patch set 3.

+}
+
 // QuotaTaskObserver -------------------------------------------------------
 
 QuotaTaskObserver::~QuotaTaskObserver() {
   std::for_each(running_quota_tasks_.begin(),
                 running_quota_tasks_.end(),
                 std::mem_fun(&QuotaTask::Abort));
 }
 
 QuotaTaskObserver::QuotaTaskObserver() {
 }
 
 void QuotaTaskObserver::RegisterTask(QuotaTask* task) {
   running_quota_tasks_.insert(task);
 }
 
 void QuotaTaskObserver::UnregisterTask(QuotaTask* task) {
   DCHECK(running_quota_tasks_.find(task) != running_quota_tasks_.end());
   running_quota_tasks_.erase(task);
 }
 
 }  // namespace quota