Add Dump{Quota,LastAccessTime}Table to QuotaDatabase

BUG=61676
TEST='QuotaDatabaseTest.*'


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

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

3 files changed, 243 insertions, 8 deletions

diff --git a/webkit/quota/quota_database.cc b/webkit/quota/quota_database.cc
index 52caf2e..6ba506f 100644
--- a/webkit/quota/quota_database.cc
+++ b/webkit/quota/quota_database.cc
@@ -215,12 +215,6 @@ bool QuotaDatabase::RegisterOrigins(const std::set<GURL>& origins,
   if (!LazyOpen(true))
     return false;
 
-  sql::Transaction transaction(db_.get());
-  if (!transaction.Begin())
-    return false;
-
-  sql::Statement statement;
-
   typedef std::set<GURL>::const_iterator itr_type;
   for (itr_type itr = origins.begin(), end = origins.end();
        itr != end; ++itr) {
@@ -228,6 +222,7 @@ bool QuotaDatabase::RegisterOrigins(const std::set<GURL>& origins,
         "INSERT OR IGNORE INTO OriginLastAccessTable"
         " (used_count, last_access_time, origin, type)"
         " VALUES (?, ?, ?, ?)";
+    sql::Statement statement;
     if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
       return false;
 
@@ -239,7 +234,8 @@ bool QuotaDatabase::RegisterOrigins(const std::set<GURL>& origins,
       return false;
   }
 
-  return transaction.Commit();
+  ScheduleCommit();
+  return true;
 }
 
 bool QuotaDatabase::DeleteHostQuota(
@@ -515,4 +511,74 @@ bool QuotaDatabase::ResetSchema() {
   return LazyOpen(true);
 }
 
+bool QuotaDatabase::DumpQuotaTable(QuotaTableCallback* callback) {
+  scoped_ptr<QuotaTableCallback> callback_deleter(callback);
+  if (!LazyOpen(true))
+    return false;
+
+  const char* kSql = "SELECT * FROM HostQuotaTable";
+  sql::Statement statement;
+  if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
+    return false;
+
+  while (statement.Step()) {
+    QuotaTableEntry entry = {
+      statement.ColumnString(0),
+      static_cast<StorageType>(statement.ColumnInt(1)),
+      statement.ColumnInt64(2)
+    };
+
+    if (!callback->Run(entry))
+      return true;
+  }
+
+  return statement.Succeeded();
+}
+
+bool QuotaDatabase::DumpLastAccessTimeTable(
+    LastAccessTimeTableCallback* callback) {
+  scoped_ptr<LastAccessTimeTableCallback> callback_deleter(callback);
+
+  if (!LazyOpen(true))
+    return false;
+
+  const char* kSql = "SELECT * FROM OriginLastAccessTable";
+  sql::Statement statement;
+  if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
+    return false;
+
+  while (statement.Step()) {
+    LastAccessTimeTableEntry entry = {
+      GURL(statement.ColumnString(0)),
+      static_cast<StorageType>(statement.ColumnInt(1)),
+      statement.ColumnInt(2),
+      base::Time::FromInternalValue(statement.ColumnInt64(3))
+    };
+
+    if (!callback->Run(entry))
+      return true;
+  }
+
+  return statement.Succeeded();
+}
+
+bool operator<(const QuotaDatabase::QuotaTableEntry& lhs,
+               const QuotaDatabase::QuotaTableEntry& rhs) {
+  if (lhs.host < rhs.host) return true;
+  if (rhs.host < lhs.host) return false;
+  if (lhs.type < rhs.type) return true;
+  if (rhs.type < lhs.type) return false;
+  return lhs.quota < rhs.quota;
+}
+
+bool operator<(const QuotaDatabase::LastAccessTimeTableEntry& lhs,
+               const QuotaDatabase::LastAccessTimeTableEntry& rhs) {
+  if (lhs.origin < rhs.origin) return true;
+  if (rhs.origin < lhs.origin) return false;
+  if (lhs.type < rhs.type) return true;
+  if (rhs.type < lhs.type) return false;
+  if (lhs.used_count < rhs.used_count) return true;
+  if (rhs.used_count < lhs.used_count) return false;
+  return lhs.last_access_time < rhs.last_access_time;
+}
 }  // quota namespace
diff --git a/webkit/quota/quota_database.h b/webkit/quota/quota_database.h
index 32560b5..8017e8d 100644
--- a/webkit/quota/quota_database.h
+++ b/webkit/quota/quota_database.h
@@ -9,10 +9,13 @@
 #include <string>
 
 #include "base/basictypes.h"
+#include "base/callback.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/time.h"
 #include "base/timer.h"
+#include "googleurl/src/gurl.h"
 #include "webkit/quota/quota_types.h"
 
 namespace sql {
@@ -66,6 +69,27 @@ class QuotaDatabase {
   bool SetOriginDatabaseBootstrapped(bool bootstrap_flag);
 
  private:
+  struct QuotaTableEntry {
+    std::string host;
+    StorageType type;
+    int64 quota;
+  };
+  friend bool operator <(const QuotaTableEntry& lhs,
+                         const QuotaTableEntry& rhs);
+
+  struct LastAccessTimeTableEntry {
+    GURL origin;
+    StorageType type;
+    int used_count;
+    base::Time last_access_time;
+  };
+  friend bool operator <(const LastAccessTimeTableEntry& lhs,
+                         const LastAccessTimeTableEntry& rhs);
+
+  typedef base::Callback<bool (const QuotaTableEntry&)> QuotaTableCallback;
+  typedef base::Callback<bool (const LastAccessTimeTableEntry&)>
+      LastAccessTimeTableCallback;
+
   // For long-running transactions support.  We always keep a transaction open
   // so that multiple transactions can be batched.  They are flushed
   // with a delay after a modification has been made.  We support neither
@@ -82,6 +106,11 @@ class QuotaDatabase {
   bool CreateSchema();
   bool ResetSchema();
 
+  // |callback| may return false to stop reading data
+  bool DumpQuotaTable(QuotaTableCallback* callback);
+  bool DumpLastAccessTimeTable(LastAccessTimeTableCallback* callback);
+
+
   FilePath db_file_path_;
 
   scoped_ptr<sql::Connection> db_;
diff --git a/webkit/quota/quota_database_unittest.cc b/webkit/quota/quota_database_unittest.cc
index 6e80c85..bbb0006 100644
--- a/webkit/quota/quota_database_unittest.cc
+++ b/webkit/quota/quota_database_unittest.cc
@@ -7,6 +7,10 @@
 #include <set>
 
 #include "app/sql/connection.h"
+#include "app/sql/statement.h"
+#include "app/sql/transaction.h"
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/file_util.h"
 #include "base/scoped_temp_dir.h"
 #include "googleurl/src/gurl.h"
@@ -25,13 +29,75 @@ class TestErrorDelegate : public sql::ErrorDelegate {
     return error;
   }
 };
-
 }  // namespace
 
 namespace quota {
 
 class QuotaDatabaseTest : public testing::Test {
  protected:
+  typedef QuotaDatabase::QuotaTableEntry QuotaTableEntry;
+  typedef QuotaDatabase::QuotaTableCallback QuotaTableCallback;
+  typedef QuotaDatabase::LastAccessTimeTableEntry LastAccessTimeTableEntry;
+  typedef QuotaDatabase::LastAccessTimeTableCallback
+      LastAccessTimeTableCallback;
+
+  template <typename Iterator>
+  bool AssignQuotaTable(
+      QuotaDatabase* quota_database, Iterator itr, Iterator end) {
+    if (!quota_database->LazyOpen(true))
+      return false;
+
+    for (; itr != end; ++itr) {
+      const char* kSql =
+          "INSERT INTO HostQuotaTable"
+          " (host, type, quota)"
+          " VALUES (?, ?, ?)";
+      sql::Statement statement;
+      statement.Assign(
+          quota_database->db_->GetCachedStatement(
+              SQL_FROM_HERE, kSql));
+      EXPECT_TRUE(statement.is_valid());
+
+      statement.BindString(0, itr->host);
+      statement.BindInt(1, static_cast<int>(itr->type));
+      statement.BindInt64(2, itr->quota);
+      if (!statement.Run())
+        return false;
+    }
+
+    quota_database->Commit();
+    return true;
+  }
+
+  template <typename Iterator>
+  bool AssignLastAccessTimeTable(
+      QuotaDatabase* quota_database, Iterator itr, Iterator end) {
+    if (!quota_database->LazyOpen(true))
+      return false;
+
+    for (; itr != end; ++itr) {
+      const char* kSql =
+          "INSERT INTO OriginLastAccessTable"
+          " (origin, type, used_count, last_access_time)"
+          " VALUES (?, ?, ?, ?)";
+      sql::Statement statement;
+      statement.Assign(
+          quota_database->db_->GetCachedStatement(
+              SQL_FROM_HERE, kSql));
+      EXPECT_TRUE(statement.is_valid());
+
+      statement.BindString(0, itr->origin.spec());
+      statement.BindInt(1, static_cast<int>(itr->type));
+      statement.BindInt(2, itr->used_count);
+      statement.BindInt64(3, itr->last_access_time.ToInternalValue());
+      if (!statement.Run())
+        return false;
+    }
+
+    quota_database->Commit();
+    return true;
+  }
+
   void LazyOpen(const FilePath& kDbFile) {
     QuotaDatabase db(kDbFile);
     EXPECT_FALSE(db.LazyOpen(false));
@@ -192,6 +258,64 @@ class QuotaDatabaseTest : public testing::Test {
                                        &used_count));
     EXPECT_EQ(1, used_count);
   }
+
+  template <typename EntryType>
+  struct EntryVerifier {
+    std::set<EntryType> table;
+
+    template <typename Iterator>
+    EntryVerifier(Iterator itr, Iterator end)
+        : table(itr, end) {}
+
+    bool Run(const EntryType& entry) {
+      EXPECT_EQ(1u, table.erase(entry));
+      return true;
+    }
+  };
+
+  void DumpQuotaTable(const FilePath& kDbFile) {
+    QuotaTableEntry kTableEntries[] = {
+      {"http://go/", kStorageTypeTemporary, 1},
+      {"http://oo/", kStorageTypeTemporary, 2},
+      {"http://gle/", kStorageTypePersistent, 3}
+    };
+    QuotaTableEntry* begin = kTableEntries;
+    QuotaTableEntry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries);
+
+    QuotaDatabase db(kDbFile);
+    EXPECT_TRUE(AssignQuotaTable(&db, begin, end));
+
+    typedef EntryVerifier<QuotaTableEntry> Verifier;
+    Verifier verifier(begin, end);
+    EXPECT_TRUE(db.DumpQuotaTable(
+        new QuotaTableCallback(
+            base::Bind(&Verifier::Run,
+                       base::Unretained(&verifier)))));
+    EXPECT_TRUE(verifier.table.empty());
+  }
+
+  void DumpLastAccessTimeTable(const FilePath& kDbFile) {
+    base::Time now(base::Time::Now());
+    LastAccessTimeTableEntry kTableEntries[] = {
+      {GURL("http://go/"), kStorageTypeTemporary, 2147483647, now},
+      {GURL("http://oo/"), kStorageTypeTemporary, 0, now},
+      {GURL("http://gle/"), kStorageTypeTemporary, 1, now},
+    };
+    LastAccessTimeTableEntry* begin = kTableEntries;
+    LastAccessTimeTableEntry* end = kTableEntries +
+        ARRAYSIZE_UNSAFE(kTableEntries);
+
+    QuotaDatabase db(kDbFile);
+    EXPECT_TRUE(AssignLastAccessTimeTable(&db, begin, end));
+
+    typedef EntryVerifier<LastAccessTimeTableEntry> Verifier;
+    Verifier verifier(begin, end);
+    EXPECT_TRUE(db.DumpLastAccessTimeTable(
+        new LastAccessTimeTableCallback(
+            base::Bind(&Verifier::Run,
+                       base::Unretained(&verifier)))));
+    EXPECT_TRUE(verifier.table.empty());
+  }
 };
 
 TEST_F(QuotaDatabaseTest, LazyOpen) {
@@ -247,4 +371,20 @@ TEST_F(QuotaDatabaseTest, RegisterOrigins) {
   RegisterOrigins(kDbFile);
   RegisterOrigins(FilePath());
 }
+
+TEST_F(QuotaDatabaseTest, DumpQuotaTable) {
+  ScopedTempDir data_dir;
+  ASSERT_TRUE(data_dir.CreateUniqueTempDir());
+  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  DumpQuotaTable(kDbFile);
+  DumpQuotaTable(FilePath());
+}
+
+TEST_F(QuotaDatabaseTest, DumpLastAccessTimeTable) {
+  ScopedTempDir data_dir;
+  ASSERT_TRUE(data_dir.CreateUniqueTempDir());
+  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  DumpLastAccessTimeTable(kDbFile);
+  DumpLastAccessTimeTable(FilePath());
+}
 }  // namespace quota