Add GetLRUOrigin into QuotaManager.

BUG=61676
TEST=QuotaDatabaseTest.*, (no tests for QuotaManagerTest.*).


Review URL: http://codereview.chromium.org/7033006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@85480 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 116 insertions, 68 deletions

diff --git a/webkit/quota/quota_database.cc b/webkit/quota/quota_database.cc
index 6d61853..23e4bab 100644
--- a/webkit/quota/quota_database.cc
+++ b/webkit/quota/quota_database.cc
@@ -252,46 +252,32 @@ bool QuotaDatabase::SetGlobalQuota(StorageType type, int64 quota) {
   return meta_table_->SetValue(GetGlobalQuotaKey(type).c_str(), quota);
 }
 
-bool QuotaDatabase::GetLRUOrigins(
-    StorageType type, std::vector<GURL>* origins,
-    int max_used_count, int num_origins_limit) {
-  DCHECK(origins);
-  DCHECK(num_origins_limit > 0);
+bool QuotaDatabase::GetLRUOrigin(
+    StorageType type,
+    const std::set<GURL>& exceptions,
+    GURL* origin) {
+  DCHECK(origin);
   if (!LazyOpen(false))
     return false;
 
-  const char* kSqlBase =
-      "SELECT origin FROM OriginLastAccessTable"
-      " WHERE type = ?";
-
-  const char* kSqlSuffix =
-      " ORDER BY last_access_time ASC "
-      " LIMIT ?";
-
-  std::string sql(kSqlBase);
-  sql::StatementID id = SQL_FROM_HERE;
-  if (max_used_count >= 0) {
-    sql += " AND used_count <= ?";
-    id = SQL_FROM_HERE;
-  }
-  sql += kSqlSuffix;
+  const char* kSql = "SELECT origin FROM OriginLastAccessTable"
+                     " WHERE type = ?"
+                     " ORDER BY last_access_time ASC";
 
   sql::Statement statement;
-  if (!PrepareCachedStatement(db_.get(), id, sql.c_str(), &statement))
+  if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
     return false;
+  statement.BindInt(0, static_cast<int>(type));
 
-  int column = 0;
-  statement.BindInt(column++, static_cast<int>(type));
-  if (max_used_count >= 0)
-    statement.BindInt(column++, max_used_count);
-  statement.BindInt(column++, num_origins_limit);
-
-  origins->clear();
-  while (statement.Step())
-    origins->push_back(GURL(statement.ColumnString(0)));
-
-  DCHECK(origins->size() <= static_cast<size_t>(num_origins_limit));
+  while (statement.Step()) {
+    GURL url(statement.ColumnString(0));
+    if (exceptions.find(url) == exceptions.end()) {
+      *origin = url;
+      return true;
+    }
+  }
 
+  *origin = GURL();
   return statement.Succeeded();
 }
 
diff --git a/webkit/quota/quota_database.h b/webkit/quota/quota_database.h
index 98aced9..001f473 100644
--- a/webkit/quota/quota_database.h
+++ b/webkit/quota/quota_database.h
@@ -5,7 +5,7 @@
 #ifndef WEBKIT_QUOTA_QUOTA_DATABASE_H_
 #define WEBKIT_QUOTA_QUOTA_DATABASE_H_
 
-#include <map>
+#include <set>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
@@ -44,12 +44,12 @@ class QuotaDatabase {
   bool GetGlobalQuota(StorageType type, int64* quota);
   bool SetGlobalQuota(StorageType type, int64 quota);
 
-  // Return least recently used origins whose used_count is <=
-  // |max_used_count| up to |num_origins_limit|.  If |max_used_count| is -1,
-  // it just returns LRU storages regardless of the used_count value.
-  // |num_origins_limit| must be > 0.
-  bool GetLRUOrigins(StorageType type, std::vector<GURL>* origins,
-                     int max_used_count, int num_origins_limit);
+  // Sets |origin| the least recently used origin of origins not included in
+  // |exceptions|.  It returns false when it failed in accessing the database.
+  // |origin| is set to empty when there is no matching origin.
+  bool GetLRUOrigin(StorageType type,
+                    const std::set<GURL>& exceptions,
+                    GURL* origin);
 
  private:
   bool FindOriginUsedCount(const GURL& origin,
diff --git a/webkit/quota/quota_database_unittest.cc b/webkit/quota/quota_database_unittest.cc
index ccbe74f..369ac3b0 100644
--- a/webkit/quota/quota_database_unittest.cc
+++ b/webkit/quota/quota_database_unittest.cc
@@ -110,9 +110,10 @@ TEST(QuotaDatabaseTest, OriginLastAccessTimeLRU) {
   QuotaDatabase db(kDbFile);
   ASSERT_TRUE(db.LazyOpen(true));
 
-  std::vector<GURL> origins;
-  EXPECT_TRUE(db.GetLRUOrigins(kStorageTypeTemporary, &origins, -1, 10));
-  EXPECT_EQ(0U, origins.size());
+  std::set<GURL> exceptions;
+  GURL origin;
+  EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions, &origin));
+  EXPECT_TRUE(origin.is_empty());
 
   const GURL kOrigin1("http://a/");
   const GURL kOrigin2("http://b/");
@@ -131,41 +132,36 @@ TEST(QuotaDatabaseTest, OriginLastAccessTimeLRU) {
   EXPECT_TRUE(db.SetOriginLastAccessTime(
       kOrigin4, kStorageTypePersistent, base::Time::FromInternalValue(40)));
 
-  EXPECT_TRUE(db.GetLRUOrigins(kStorageTypeTemporary, &origins, 0, 10));
+  EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions, &origin));
+  EXPECT_EQ(kOrigin1.spec(), origin.spec());
 
-  ASSERT_EQ(3U, origins.size());
-  EXPECT_EQ(kOrigin1.spec(), origins[0].spec());
-  EXPECT_EQ(kOrigin2.spec(), origins[1].spec());
-  EXPECT_EQ(kOrigin3.spec(), origins[2].spec());
+  exceptions.insert(kOrigin1);
+  EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions, &origin));
+  EXPECT_EQ(kOrigin2.spec(), origin.spec());
 
-  EXPECT_TRUE(db.SetOriginLastAccessTime(
-      kOrigin1, kStorageTypeTemporary, base::Time::Now()));
-
-  EXPECT_TRUE(db.GetLRUOrigins(kStorageTypeTemporary, &origins, 0, 10));
-
-  // Now kOrigin1 has used_count=1, so it should not be in the returned list.
-  ASSERT_EQ(2U, origins.size());
-  EXPECT_EQ(kOrigin2.spec(), origins[0].spec());
-  EXPECT_EQ(kOrigin3.spec(), origins[1].spec());
+  exceptions.insert(kOrigin2);
+  EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions, &origin));
+  EXPECT_EQ(kOrigin3.spec(), origin.spec());
 
-  // Query again without used_count condition.
-  EXPECT_TRUE(db.GetLRUOrigins(kStorageTypeTemporary, &origins, -1, 10));
+  exceptions.insert(kOrigin3);
+  EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions, &origin));
+  EXPECT_TRUE(origin.is_empty());
 
-  // Now kOrigin1 must be returned as the newest one.
-  ASSERT_EQ(3U, origins.size());
-  EXPECT_EQ(kOrigin2.spec(), origins[0].spec());
-  EXPECT_EQ(kOrigin3.spec(), origins[1].spec());
-  EXPECT_EQ(kOrigin1.spec(), origins[2].spec());
+  EXPECT_TRUE(db.SetOriginLastAccessTime(
+      kOrigin1, kStorageTypeTemporary, base::Time::Now()));
 
   // Delete origin/type last access time information.
   EXPECT_TRUE(db.DeleteOriginLastAccessTime(kOrigin3, kStorageTypeTemporary));
 
   // Querying again to see if the deletion has worked.
-  EXPECT_TRUE(db.GetLRUOrigins(kStorageTypeTemporary, &origins, -1, 10));
-
-  ASSERT_EQ(2U, origins.size());
-  EXPECT_EQ(kOrigin2.spec(), origins[0].spec());
-  EXPECT_EQ(kOrigin1.spec(), origins[1].spec());
+  exceptions.clear();
+  EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions, &origin));
+  EXPECT_EQ(kOrigin2.spec(), origin.spec());
+
+  exceptions.insert(kOrigin1);
+  exceptions.insert(kOrigin2);
+  EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions, &origin));
+  EXPECT_TRUE(origin.is_empty());
 }
 
 }  // namespace quota
diff --git a/webkit/quota/quota_manager.cc b/webkit/quota/quota_manager.cc
index b9a787c..7da4480 100644
--- a/webkit/quota/quota_manager.cc
+++ b/webkit/quota/quota_manager.cc
@@ -434,6 +434,54 @@ class QuotaManager::PersistentHostQuotaUpdateTask : public QuotaThreadTask {
   bool db_disabled_;
 };
 
+class QuotaManager::GetLRUOriginTask : public QuotaThreadTask {
+ public:
+  GetLRUOriginTask(
+      QuotaManager* manager,
+      QuotaDatabase* database,
+      scoped_refptr<base::MessageLoopProxy> db_message_loop,
+      StorageType type,
+      const std::map<GURL, int>& origins_in_use,
+      GetLRUOriginCallback *callback)
+      : QuotaThreadTask(manager, db_message_loop),
+        manager_(manager),
+        database_(database),
+        db_disabled_(false),
+        type_(type),
+        callback_(callback) {
+    DCHECK(database_);
+    for (std::map<GURL, int>::const_iterator p = origins_in_use.begin();
+         p != origins_in_use.end();
+         ++p) {
+      if (p->second > 0)
+        exceptions_.insert(p->first);
+    }
+  }
+
+ protected:
+  virtual void RunOnTargetThread() OVERRIDE {
+    if (!database_->GetLRUOrigin(type_, exceptions_, &url_))
+      db_disabled_ = true;
+  }
+
+  virtual void Completed() OVERRIDE {
+    DCHECK(manager_);
+    manager_->db_disabled_ = db_disabled_;
+    callback_->Run(url_);
+  }
+
+ private:
+  QuotaManager* manager_;
+  QuotaDatabase* database_;
+  bool db_disabled_;
+
+  StorageType type_;
+  std::set<GURL> exceptions_;
+
+  GetLRUOriginCallback* callback_;
+  GURL url_;
+};
+
 QuotaManager::QuotaManager(bool is_incognito,
                            const FilePath& profile_path,
                            base::MessageLoopProxy* io_thread,
@@ -621,6 +669,17 @@ void QuotaManager::NotifyOriginNoLongerInUse(const GURL& origin) {
     origins_in_use_.erase(origin);
 }
 
+void QuotaManager::GetLRUOrigin(
+    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();
+  }
+}
+
 UsageTracker* QuotaManager::GetUsageTracker(StorageType type) const {
   switch (type) {
     case kStorageTypeTemporary:
diff --git a/webkit/quota/quota_manager.h b/webkit/quota/quota_manager.h
index c80d568..cc8bf6b 100644
--- a/webkit/quota/quota_manager.h
+++ b/webkit/quota/quota_manager.h
@@ -46,6 +46,7 @@ class QuotaManager : public QuotaTaskObserver,
                     int64 /* quota */>::Type GetUsageAndQuotaCallback;
   typedef Callback2<QuotaStatusCode,
                     int64 /* granted_quota */>::Type RequestQuotaCallback;
+  typedef Callback1<GURL>::Type GetLRUOriginCallback;
 
   QuotaManager(bool is_incognito,
                const FilePath& profile_path,
@@ -117,6 +118,7 @@ class QuotaManager : public QuotaTaskObserver,
   class TemporaryGlobalQuotaUpdateTask;
   class PersistentHostQuotaUpdateTask;
   class PersistentHostQuotaQueryTask;
+  class GetLRUOriginTask;
 
   class UsageAndQuotaDispatcherTask;
   class UsageAndQuotaDispatcherTaskForTemporary;
@@ -140,6 +142,11 @@ class QuotaManager : public QuotaTaskObserver,
   // The client must remain valid until OnQuotaManagerDestored is called.
   void RegisterClient(QuotaClient* client);
 
+  // TODO(dmikurube): Add a test for this method.
+  virtual void GetLRUOrigin(
+      StorageType type,
+      GetLRUOriginCallback* callback);
+
   UsageTracker* GetUsageTracker(StorageType type) const;
 
   void DidGetTemporaryGlobalQuota(int64 quota);