Implement EvictOriginData in QuotaManager.

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 459 matching lines @@
                            base::MessageLoopProxy* io_thread,
                            base::MessageLoopProxy* db_thread)
   : is_incognito_(is_incognito),
     profile_path_(profile_path),
     proxy_(new QuotaManagerProxy(
         ALLOW_THIS_IN_INITIALIZER_LIST(this), io_thread)),
     db_initialized_(false),
     db_disabled_(false),
     io_thread_(io_thread),
     db_thread_(db_thread),
+    temporary_storage_evictor_(NULL),
+    num_deletion_requested_clients_(0),
+    num_deleted_clients_(0),
     temporary_global_quota_(-1) {
 }
 
 QuotaManager::~QuotaManager() {
   DCHECK(io_thread_->BelongsToCurrentThread());
   proxy_->manager_ = NULL;
+  if (temporary_storage_evictor_ != NULL)
+    temporary_storage_evictor_->OnQuotaManagerDestroyedOnIOThread();
   std::for_each(clients_.begin(), clients_.end(),
                 std::mem_fun(&QuotaClient::OnQuotaManagerDestroyed));
   if (database_.get())
     db_thread_->DeleteSoon(FROM_HERE, database_.release());
 }
 
 void QuotaManager::GetUsageAndQuota(
     const GURL& origin, StorageType type,
     GetUsageAndQuotaCallback* callback_ptr) {
   scoped_ptr<GetUsageAndQuotaCallback> callback(callback_ptr);
@@ skipping 93 matching lines @@
     scoped_refptr<PersistentHostQuotaUpdateTask> task(
         new PersistentHostQuotaUpdateTask(
             this, database_.get(), db_thread_, host, new_quota, callback));
     task->Start();
   } else {
     callback->Run(kQuotaErrorInvalidAccess, host, -1);
     delete callback;
   }
 }
 
+void QuotaManager::RegisterTemporaryStorageEvictor(
+    scoped_refptr<QuotaTemporaryStorageEvictor> temporary_storage_evictor) {
+  /*
+  // TODO(dmikurube): Change this hard-coded 3 seconds.
+  temporary_storage_evictor_ = new QuotaTemporaryStorageEvictor(
+    this, database_.get(), 10000000, 3000, io_thread_, db_thread_);
+  */
+
+  temporary_storage_evictor_ = temporary_storage_evictor;
+  temporary_storage_evictor_->RegisterQuotaManagerOnIOThread(this);
+}
+
 void QuotaManager::LazyInitialize() {
   DCHECK(io_thread_->BelongsToCurrentThread());
   if (database_.get()) {
     // Initialization seems to be done already.
     return;
   }
 
   if (is_incognito_)
     return;
 
@@ skipping 47 matching lines @@
     StorageType type,
     GetLRUOriginCallback* callback) {
   LazyInitialize();
   if (!db_disabled_) {
     scoped_refptr<GetLRUOriginTask> task(new GetLRUOriginTask(
         this, database_.get(), db_thread_, type, origins_in_use_, callback));
     task->Start();
   }
 }
 
+void QuotaManager::StartEviction() {
+  LazyInitialize();
+  if (temporary_storage_evictor_ != NULL)
+    temporary_storage_evictor_->Start();
+}
+
+void QuotaManager::GetUsageAndQuotaForEviction(
+    DeleteOriginDataCallback* callback) {
+  const int64 USAGE = 30000;
+  const int64 QUOTA = 100000;
+  const int64 PHYSICAL_AVAILABLE = 1000000000;
+
+  LOG(ERROR) << "QM::GetUsageAndQuotaForEviction";
+  DCHECK(io_thread_->BelongsToCurrentThread());
+  // TODO(dmikurube): Get usage, quota and physical space and then callback.
+  callback->Run(kQuotaStatusOk, USAGE, QUOTA, PHYSICAL_AVAILABLE);
+  delete callback;
+}
+
+void QuotaManager::OnOriginDataDeleted(
+    QuotaStatusCode status,
+    DeleteOriginDataCallback* callback) {
+  LOG(ERROR) << "QM::OnOriginDataDeleted";
+  DCHECK(io_thread_->BelongsToCurrentThread());
+
+  if (status != kQuotaStatusOk) {
+    // TODO(dmikurube): Handle error.
+  }
+
+  ++num_deleted_clients_;
+  DCHECK(num_deleted_clients_ <= num_deletion_requested_clients_);
+  if (num_deleted_clients_ == num_deletion_requested_clients_) {
+    num_deletion_requested_clients_ = 0;
+    num_deleted_clients_ = 0;

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

you might be able to do this with one data member instead of two...

pending_deletion_requests_
++ prior to calling client->DeleteOriginData()
-- here

[Dai Mikurube (NOT FULLTIME), 2011/05/17 09:18:40]

We can do that, but I think these two variables help us debugging.

+
+    // TODO(dmikurube): Get usage, quota and physical space and then callback.
+    GetUsageAndQuotaForEviction(callback);
+  }
+}
+
+void QuotaManager::DeleteOriginData(
+    const GURL& origin,
+    StorageType type,
+    DeleteOriginDataCallback* callback) {
+  LOG(ERROR) << "QM::DeleteOriginData";
+  DCHECK(io_thread_->BelongsToCurrentThread());
+  LazyInitialize();
+
+  int num_clients = clients_.size();
+
+  if (origin.is_empty() || num_clients == 0 || num_deleted_clients_ > 0) {
+    GetUsageAndQuotaForEviction(callback);

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

Seems strange to call this method for the last condition... an origin is already
being evicted and you can't do more than one at a time.

It looks like the only caller you expect to have of this method is the Evictor
class and it won't issue a second call with the first still pending. If that's
the case maybe DCHECK() that last condition is hit.

Btw, it's not clear to me why we need a seperate Evictor class that is tightly
coupled with this class. Seems like the logic of the Evictor could be baked
straight into this class, assuming there's not a lot to that logic.

[Dai Mikurube (NOT FULLTIME), 2011/05/17 09:18:40]

I'm separating and re-constructing the change.  Let's discuss it later.

+    return;
+  }
+
+  num_deletion_requested_clients_ = num_clients;
+  num_deleted_clients_ = 0;
+
+  for (QuotaClientList::iterator p = clients_.begin();
+       p != clients_.end();
+       ++p) {
+    /*
+      p->DeleteOriginData(origin, kStorageTypeTemporary, NewRunnableMethod(
+          this, &QuotaManager::OnOriginDataDeleted));
+    */
+    OnOriginDataDeleted(kQuotaStatusOk, callback);  // test.
+  }
+}
+
 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 99 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::MessageLoopProxy* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota