Add Dump{Quota,LastAccessTime}Table

webkit/quota/quota_database.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_database.h"
 
 #include <string>
 
 #include "app/sql/connection.h"
 #include "app/sql/diagnostic_error_delegate.h"
@@ skipping 201 matching lines @@
 bool QuotaDatabase::RegisterOrigins(const std::set<GURL>& origins,
                                     StorageType type,
                                     base::Time last_access_time) {
   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) {
     const char* kSql =
         "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;
 
     statement.BindInt(0, 0);  // used_count
     statement.BindInt64(1, last_access_time.ToInternalValue());
     statement.BindString(2, itr->spec());
     statement.BindInt(3, static_cast<int>(type));
     if (!statement.Run())
       return false;
   }
@@ skipping 237 matching lines @@
     return false;
 
   // So we can't go recursive.
   if (is_recreating_)
     return false;
 
   AutoReset<bool> auto_reset(&is_recreating_, true);
   return LazyOpen(true);
 }
 
+bool QuotaDatabase::DumpQuotaTable(QuotaTableCallback* 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::DumpAccessTable(AccessTableCallback* callback) {

[kinuko, 2011/05/20 13:19:54]

Can we rename s/AccessTable/LastAccessTimeTable/

[tzik, 2011/05/23 05:24:15]

Done.

+  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()) {
+    AccessTableEntry 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 QuotaDatabase::AssignQuotaTable(
+    const std::set<QuotaTableEntry>& entries) {

[kinuko, 2011/05/20 13:19:54]

As we chatted locally, as long as it is labeled 'for test and debug' I may feel
using set here is a bit overkill.

+  if (!LazyOpen(true))
+    return false;
+
+  sql::Transaction transaction(db_.get());
+  if (!transaction.Begin())
+    return false;
+
+  {
+    const char* kSql = "DELETE FROM HostQuotaTable";
+    sql::Statement statement;
+    if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
+      return false;
+    if (!statement.Run())
+      return false;
+  }
+
+  typedef std::set<QuotaTableEntry>::const_iterator itr_type;
+  for (itr_type itr = entries.begin(), end = entries.end();
+       itr != end; ++itr) {
+    const char* kSql =
+        "INSERT INTO HostQuotaTable"
+        " (host, type, quota)"
+        " VALUES (?, ?, ?)";
+    sql::Statement statement;
+    if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
+      return false;
+
+    statement.BindString(0, itr->host);
+    statement.BindInt(1, static_cast<int>(itr->type));
+    statement.BindInt64(2, itr->quota);
+    if (!statement.Run())
+      return false;
+  }
+
+  return transaction.Commit();
+}
+
+bool QuotaDatabase::AssignAccessTable(
+    const std::set<AccessTableEntry>& entries) {
+  if (!LazyOpen(true))
+    return false;
+
+  sql::Transaction transaction(db_.get());
+  if (!transaction.Begin())
+    return false;
+
+  {
+    const char* kSql = "DELETE FROM OriginLastAccessTable";
+    sql::Statement statement;
+    if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
+      return false;
+    if (!statement.Run())
+      return false;
+  }
+
+  typedef std::set<AccessTableEntry>::const_iterator itr_type;
+  for (itr_type itr = entries.begin(), end = entries.end();
+       itr != end; ++itr) {
+    const char* kSql =
+        "INSERT INTO OriginLastAccessTable"
+        " (origin, type, used_count, last_access_time)"
+        " VALUES (?, ?, ?, ?)";
+    sql::Statement statement;
+    if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
+      return false;
+
+    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;
+  }
+
+  return transaction.Commit();
+}
+
+
+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::AccessTableEntry& lhs,
+               const QuotaDatabase::AccessTableEntry& 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