Add Dump{Quota,LastAccessTime}Table to QuotaManager

BUG=61676
TEST='QuotaManagerTest.*'


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

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

5 files changed, 227 insertions, 1 deletions

diff --git a/webkit/quota/quota_database.cc b/webkit/quota/quota_database.cc
index 6ba506f..9aa9f3e 100644
--- a/webkit/quota/quota_database.cc
+++ b/webkit/quota/quota_database.cc
@@ -180,7 +180,7 @@ bool QuotaDatabase::SetOriginLastAccessTime(
 
   sql::Statement statement;
 
-  int used_count = 0;
+  int used_count = 1;
   if (FindOriginUsedCount(origin, type, &used_count)) {
     ++used_count;
     const char* kSql =
diff --git a/webkit/quota/quota_database.h b/webkit/quota/quota_database.h
index 8017e8d..dc433d6 100644
--- a/webkit/quota/quota_database.h
+++ b/webkit/quota/quota_database.h
@@ -121,6 +121,7 @@ class QuotaDatabase {
   base::OneShotTimer<QuotaDatabase> timer_;
 
   friend class QuotaDatabaseTest;
+  friend class QuotaManager;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaDatabase);
 };
diff --git a/webkit/quota/quota_manager.cc b/webkit/quota/quota_manager.cc
index 39700ba..c8f1d63 100644
--- a/webkit/quota/quota_manager.cc
+++ b/webkit/quota/quota_manager.cc
@@ -8,6 +8,7 @@
 #include <deque>
 #include <set>
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
@@ -637,6 +638,94 @@ class QuotaManager::OriginAccessRecordDatabaseTask
   StorageType type_;
 };
 
+class QuotaManager::DumpQuotaTableTask
+    : public QuotaManager::DatabaseTaskBase {
+ private:
+  typedef QuotaManager::DumpQuotaTableTask self_type;
+  typedef QuotaManager::DumpQuotaTableCallback Callback;
+  typedef QuotaManager::QuotaTableEntry TableEntry;
+  typedef QuotaManager::QuotaTableEntries TableEntries;
+  typedef QuotaDatabase::QuotaTableCallback TableCallback;
+
+ public:
+  DumpQuotaTableTask(
+      QuotaManager* manager,
+      QuotaDatabase* database,
+      scoped_refptr<base::MessageLoopProxy> db_message_loop,
+      Callback* callback)
+      : DatabaseTaskBase(manager, database, db_message_loop),
+        callback_(callback) {
+  }
+ protected:
+  virtual void RunOnTargetThread() OVERRIDE {
+    if (!database()->DumpQuotaTable(
+            new TableCallback(
+                base::Bind(&self_type::AppendEntry, this))))
+      set_db_disabled(true);
+  }
+
+  virtual void Aborted() OVERRIDE {
+    callback_->Run(entries_);
+  }
+
+  virtual void DatabaseTaskCompleted() OVERRIDE {
+    callback_->Run(entries_);
+  }
+
+ private:
+  bool AppendEntry(const TableEntry& entry) {
+    entries_.push_back(entry);
+    return true;
+  }
+
+  scoped_ptr<Callback> callback_;
+  TableEntries entries_;
+};
+
+class QuotaManager::DumpLastAccessTimeTableTask
+    : public QuotaManager::DatabaseTaskBase {
+ private:
+  typedef QuotaManager::DumpLastAccessTimeTableTask self_type;
+  typedef QuotaManager::DumpLastAccessTimeTableCallback Callback;
+  typedef QuotaManager::LastAccessTimeTableEntry TableEntry;
+  typedef QuotaManager::LastAccessTimeTableEntries TableEntries;
+  typedef QuotaDatabase::LastAccessTimeTableCallback TableCallback;
+
+ public:
+  DumpLastAccessTimeTableTask(
+      QuotaManager* manager,
+      QuotaDatabase* database,
+      scoped_refptr<base::MessageLoopProxy> db_message_loop,
+      Callback* callback)
+      : DatabaseTaskBase(manager, database, db_message_loop),
+        callback_(callback) {
+  }
+ protected:
+  virtual void RunOnTargetThread() OVERRIDE {
+    if (!database()->DumpLastAccessTimeTable(
+            new TableCallback(
+                base::Bind(&self_type::AppendEntry, this))))
+      set_db_disabled(true);
+  }
+
+  virtual void Aborted() OVERRIDE {
+    callback_->Run(entries_);
+  }
+
+  virtual void DatabaseTaskCompleted() OVERRIDE {
+    callback_->Run(entries_);
+  }
+
+ private:
+  bool AppendEntry(const TableEntry& entry) {
+    entries_.push_back(entry);
+    return true;
+  }
+
+  scoped_ptr<Callback> callback_;
+  TableEntries entries_;
+};
+
 // QuotaManager ---------------------------------------------------------------
 
 QuotaManager::QuotaManager(bool is_incognito,
@@ -882,6 +971,18 @@ void QuotaManager::GetCachedOrigins(
   }
 }
 
+void QuotaManager::DumpQuotaTable(DumpQuotaTableCallback* callback) {
+  make_scoped_refptr(new DumpQuotaTableTask(
+      this, database_.get(), db_thread_.get(), callback))->Start();
+}
+
+void QuotaManager::DumpLastAccessTimeTable(
+    DumpLastAccessTimeTableCallback* callback) {
+  make_scoped_refptr(new DumpLastAccessTimeTableTask(
+      this, database_.get(), db_thread_.get(), callback))->Start();
+}
+
+
 void QuotaManager::DeleteOriginFromDatabase(
     const GURL& origin, StorageType type) {
   LazyInitialize();
diff --git a/webkit/quota/quota_manager.h b/webkit/quota/quota_manager.h
index 6d5f6d2..7d0cd66 100644
--- a/webkit/quota/quota_manager.h
+++ b/webkit/quota/quota_manager.h
@@ -11,6 +11,7 @@
 #include <map>
 #include <set>
 #include <string>
+#include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
@@ -18,6 +19,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
+#include "webkit/quota/quota_database.h"
 #include "webkit/quota/quota_client.h"
 #include "webkit/quota/quota_task.h"
 #include "webkit/quota/quota_types.h"
@@ -159,6 +161,17 @@ class QuotaManager : public QuotaTaskObserver,
   class UsageAndQuotaDispatcherTaskForPersistent;
 
   class AvailableSpaceQueryTask;
+  class DumpQuotaTableTask;
+  class DumpLastAccessTimeTableTask;
+
+  typedef QuotaDatabase::QuotaTableEntry QuotaTableEntry;
+  typedef QuotaDatabase::LastAccessTimeTableEntry LastAccessTimeTableEntry;
+  typedef std::vector<QuotaTableEntry> QuotaTableEntries;
+  typedef std::vector<LastAccessTimeTableEntry> LastAccessTimeTableEntries;
+
+  typedef Callback1<const QuotaTableEntries&>::Type DumpQuotaTableCallback;
+  typedef Callback1<const LastAccessTimeTableEntries&>::Type
+      DumpLastAccessTimeTableCallback;
 
   struct EvictionContext {
     EvictionContext()
@@ -205,6 +218,9 @@ class QuotaManager : public QuotaTaskObserver,
   // (Might return empty list if no origin is tracked by the tracker.)
   void GetCachedOrigins(StorageType type, std::set<GURL>* origins);
 
+  void DumpQuotaTable(DumpQuotaTableCallback* callback);
+  void DumpLastAccessTimeTable(DumpLastAccessTimeTableCallback* callback);
+
   // Methods for eviction logic.
   void StartEviction();
   void DeleteOriginFromDatabase(const GURL& origin, StorageType type);
diff --git a/webkit/quota/quota_manager_unittest.cc b/webkit/quota/quota_manager_unittest.cc
index 536b060..0aa91188 100644
--- a/webkit/quota/quota_manager_unittest.cc
+++ b/webkit/quota/quota_manager_unittest.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <sstream>
 #include <vector>
 
 #include "base/file_util.h"
@@ -35,6 +36,12 @@ struct MockOriginData {
 }  // anonymous namespace
 
 class QuotaManagerTest : public testing::Test {
+ protected:
+  typedef QuotaManager::QuotaTableEntry QuotaTableEntry;
+  typedef QuotaManager::QuotaTableEntries QuotaTableEntries;
+  typedef QuotaManager::LastAccessTimeTableEntry LastAccessTimeTableEntry;
+  typedef QuotaManager::LastAccessTimeTableEntries LastAccessTimeTableEntries;
+
  public:
   QuotaManagerTest()
       : callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
@@ -207,6 +214,20 @@ class QuotaManagerTest : public testing::Test {
     quota_manager_->NotifyOriginNoLongerInUse(origin);
   }
 
+  void DumpQuotaTable() {
+    quota_table_.clear();
+    quota_manager_->DumpQuotaTable(
+        callback_factory_.NewCallback(
+            &QuotaManagerTest::DidDumpQuotaTable));
+  }
+
+  void DumpLastAccessTimeTable() {
+    last_access_time_table_.clear();
+    quota_manager_->DumpLastAccessTimeTable(
+        callback_factory_.NewCallback(
+            &QuotaManagerTest::DidDumpLastAccessTimeTable));
+  }
+
   void DidGetUsageAndQuota(QuotaStatusCode status, int64 usage, int64 quota) {
     quota_status_ = status;
     usage_ = usage;
@@ -269,6 +290,14 @@ class QuotaManagerTest : public testing::Test {
     lru_origin_ = origin;
   }
 
+  void DidDumpQuotaTable(const QuotaTableEntries& entries) {
+    quota_table_ = entries;
+  }
+
+  void DidDumpLastAccessTimeTable(const LastAccessTimeTableEntries& entries) {
+    last_access_time_table_ = entries;
+  }
+
   void set_additional_callback_count(int c) { additional_callback_count_ = c; }
   int additional_callback_count() const { return additional_callback_count_; }
   void DidGetUsageAndQuotaAdditional(
@@ -288,6 +317,10 @@ class QuotaManagerTest : public testing::Test {
   int64 quota() const { return quota_; }
   int64 available_space() const { return available_space_; }
   const GURL& lru_origin() const { return lru_origin_; }
+  const QuotaTableEntries& quota_table() const { return quota_table_; }
+  const LastAccessTimeTableEntries& last_access_time_table() const {
+    return last_access_time_table_;
+  }
   FilePath profile_path() const { return data_dir_.path(); }
 
  private:
@@ -303,6 +336,8 @@ class QuotaManagerTest : public testing::Test {
   int64 quota_;
   int64 available_space_;
   GURL lru_origin_;
+  QuotaTableEntries quota_table_;
+  LastAccessTimeTableEntries last_access_time_table_;
 
   int additional_callback_count_;
 
@@ -1052,4 +1087,77 @@ TEST_F(QuotaManagerTest, MAYBE_GetLRUOriginWithOriginInUse) {
   EXPECT_EQ("http://a.com/", lru_origin().spec());
 }
 
+TEST_F(QuotaManagerTest, DumpQuotaTable) {
+  SetPersistentHostQuota("example1.com", 1);
+  SetPersistentHostQuota("example2.com", 20);
+  SetPersistentHostQuota("example3.com", 300);
+  MessageLoop::current()->RunAllPending();
+
+  DumpQuotaTable();
+  MessageLoop::current()->RunAllPending();
+
+  const QuotaTableEntry kEntries[] = {
+    {"example1.com", kStorageTypePersistent, 1},
+    {"example2.com", kStorageTypePersistent, 20},
+    {"example3.com", kStorageTypePersistent, 300},
+  };
+  std::set<QuotaTableEntry> entries
+      (kEntries, kEntries + ARRAYSIZE_UNSAFE(kEntries));
+
+  typedef QuotaTableEntries::const_iterator iterator;
+  for (iterator itr(quota_table().begin()), end(quota_table().end());
+       itr != end; ++itr) {
+    SCOPED_TRACE(testing::Message()
+                 << "host = " << itr->host << ", "
+                 << "quota = " << itr->quota);
+    EXPECT_EQ(1u, entries.erase(*itr));
+  }
+  EXPECT_TRUE(entries.empty());
+}
+
+TEST_F(QuotaManagerTest, DumpLastAccessTimeTable) {
+  using std::make_pair;
+
+  quota_manager()->NotifyStorageAccessed(
+      QuotaClient::kMockStart,
+      GURL("http://example.com/"),
+      kStorageTypeTemporary);
+  quota_manager()->NotifyStorageAccessed(
+      QuotaClient::kMockStart,
+      GURL("http://example.com/"),
+      kStorageTypePersistent);
+  quota_manager()->NotifyStorageAccessed(
+      QuotaClient::kMockStart,
+      GURL("http://example.com/"),
+      kStorageTypePersistent);
+  MessageLoop::current()->RunAllPending();
+
+  DumpLastAccessTimeTable();
+  MessageLoop::current()->RunAllPending();
+
+  typedef std::pair<GURL, StorageType> TypedOrigin;
+  typedef std::pair<TypedOrigin, int> Entry;
+  const Entry kEntries[] = {
+    make_pair(make_pair(GURL("http://example.com/"),
+                        kStorageTypeTemporary), 1),
+    make_pair(make_pair(GURL("http://example.com/"),
+                        kStorageTypePersistent), 2),
+  };
+  std::set<Entry> entries
+      (kEntries, kEntries + ARRAYSIZE_UNSAFE(kEntries));
+
+  typedef LastAccessTimeTableEntries::const_iterator iterator;
+  for (iterator itr(last_access_time_table().begin()),
+                end(last_access_time_table().end());
+       itr != end; ++itr) {
+    SCOPED_TRACE(testing::Message()
+                 << "host = " << itr->origin << ", "
+                 << "type = " << itr->type << ", "
+                 << "used_count = " << itr->used_count);
+    EXPECT_EQ(1u, entries.erase(
+        make_pair(make_pair(itr->origin, itr->type),
+                  itr->used_count)));
+  }
+  EXPECT_TRUE(entries.empty());
+}
 }  // namespace quota