Implement QuotaTemporaryStorageEvictor.

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 <deque>
 #include <algorithm>
 
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop_proxy.h"
 #include "base/stl_util-inl.h"
 #include "base/sys_info.h"
 #include "net/base/net_util.h"
 #include "webkit/quota/quota_database.h"
+#include "webkit/quota/quota_temporary_storage_evictor.h"
 #include "webkit/quota/quota_types.h"
 #include "webkit/quota/usage_tracker.h"
 
 using base::ScopedCallbackFactory;
 
 namespace quota {
 
 namespace {
 // Returns the initial size of the temporary storage quota.
 // (This just gives a default initial size; once its initial size is determined
@@ skipping 419 matching lines @@
     temporary_global_quota_(-1) {
 }
 
 QuotaManager::~QuotaManager() {
   DCHECK(io_thread_->BelongsToCurrentThread());
   proxy_->manager_ = NULL;
   std::for_each(clients_.begin(), clients_.end(),
                 std::mem_fun(&QuotaClient::OnQuotaManagerDestroyed));
   if (database_.get())
     db_thread_->DeleteSoon(FROM_HERE, database_.release());
+// TODO(dmikurube): Evictor::OnQuotaManagerDestroyedOnIOThread() appropriately.
 }
 
 void QuotaManager::GetUsageAndQuota(
     const GURL& origin, StorageType type,
     GetUsageAndQuotaCallback* callback_ptr) {
   scoped_ptr<GetUsageAndQuotaCallback> callback(callback_ptr);
   LazyInitialize();
   if (is_incognito_) {
     int64 quota = 0;
     if (type == kStorageTypeTemporary)
@@ skipping 106 matching lines @@
 
   if (is_incognito_)
     return;
 
   database_.reset(new QuotaDatabase(profile_path_.AppendASCII(kDatabaseName)));
 
   temporary_usage_tracker_.reset(
       new UsageTracker(clients_, kStorageTypeTemporary));
   persistent_usage_tracker_.reset(
       new UsageTracker(clients_, kStorageTypePersistent));
+  // TODO(dmikurube): Change this hard-coded 3 seconds.
+  // TODO(dmikurube): This init. could be delayed until InitializeTask finishes.
+  temporary_storage_evictor_ = new QuotaTemporaryStorageEvictor(
+      this, database_.get(), 3000, io_thread_, db_thread_);
 
   scoped_refptr<InitializeTask> task(
       new InitializeTask(this, database_.get(), db_thread_, profile_path_));
   task->Start();
+
+  temporary_storage_evictor_->Start();
 }
 
 void QuotaManager::RegisterClient(QuotaClient* client) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   DCHECK(!database_.get());
   clients_.push_back(client);
 }
 
 void QuotaManager::NotifyStorageModified(
     QuotaClient::ID client_id,
     const GURL& origin, StorageType type, int64 delta) {
   LazyInitialize();
   UsageTracker* tracker = GetUsageTracker(type);
   DCHECK(tracker);
   tracker->UpdateUsageCache(client_id, origin, delta);
 }
 
+void QuotaManager::DeleteOriginDataOnIOThread(
+    const GURL& origin,
+    StorageType type,
+    DeleteOriginDataCallback* callback) {
+  LazyInitialize();
+  LOG(ERROR) << "QM::DeleteOriginDataOnIOThread";
+  // TODO(dmikurube): Delete data of the |origin|.
+  /*
+  ++num_deleted_clients_;
+  DCHECK(num_deleted_clients_ <= num_clients_);
+  if (num_deleted_clients_ == num_clients_) {
+    if (is_deletion_failed_) {
+      // TODO(dmikurube): Should try ignoring the failed origin?
+    }
+
+    if (false ) { // More deletion required?
+      // Delete another origin.
+      db_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+          this, &QuotaTemporaryStorageEvictor::Evict));
+    } else {
+      // Post the next task.
+      db_message_loop_->PostDelayedTask(FROM_HERE, NewRunnableMethod(
+          this, &QuotaTemporaryStorageEvictor::Evict), delay_ms_);
+    }
+    num_clients_ = 0;
+    num_deleted_clients_ = 0;
+    is_deletion_failed_ = false;
+  }
+  */
+  callback->Run(kQuotaStatusOk);
+  delete callback;
+}
+
 UsageTracker* QuotaManager::GetUsageTracker(StorageType type) const {
   switch (type) {
     case kStorageTypeTemporary:
       return temporary_usage_tracker_.get();
     case kStorageTypePersistent:
       return persistent_usage_tracker_.get();
     default:
       NOTREACHED();
   }
   return NULL;
@@ skipping 179 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::MessageLoopProxy* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota