Database usage adjustment for .../webkit

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 "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 21 matching lines @@
 
 class HistogramUniquifier {
  public:
   static const char* name() { return "Sqlite.Quota.Error"; }
 };
 
 sql::ErrorDelegate* GetErrorHandlerForQuotaDb() {
   return new sql::DiagnosticErrorDelegate<HistogramUniquifier>();
 }
 
-bool PrepareCachedStatement(
-    sql::Connection* db, const sql::StatementID& id,
-    const char* sql, sql::Statement* statement) {
-  DCHECK(db && sql && statement);
-  statement->Assign(db->GetCachedStatement(id, sql));
-  if (!statement->is_valid()) {
-    NOTREACHED() << db->GetErrorMessage();
-    return false;
-  }
-  return true;
-}
-
 bool VerifyValidQuotaConfig(const char* key) {
   return (key != NULL &&
           (!strcmp(key, QuotaDatabase::kDesiredAvailableSpaceKey) ||
            !strcmp(key, QuotaDatabase::kTemporaryQuotaOverrideKey)));
 }
 
 const int kCommitIntervalMs = 30000;
 
 }  // anonymous namespace
 
@@ skipping 100 matching lines @@
     const std::string& host, StorageType type, int64* quota) {
   DCHECK(quota);
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT quota"
       " FROM HostQuotaTable"
       " WHERE host = ? AND type = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
-    return false;
-
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindString(0, host);
   statement.BindInt(1, static_cast<int>(type));
-  if (!statement.Step() || !statement.Succeeded())
+
+  if (!statement.Step())
     return false;
 
   *quota = statement.ColumnInt64(0);
   return true;
 }
 
 bool QuotaDatabase::SetHostQuota(
     const std::string& host, StorageType type, int64 quota) {
   DCHECK_GE(quota, 0);
   if (!LazyOpen(true))
     return false;
 
-  sql::Statement statement;
   const char* kSql =
       "INSERT OR REPLACE INTO HostQuotaTable"
       " (quota, host, type)"
       " VALUES (?, ?, ?)";
-  if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
-    return false;
-
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, quota);
   statement.BindString(1, host);
   statement.BindInt(2, static_cast<int>(type));
+
   if (!statement.Run())
     return false;
 
   ScheduleCommit();
   return true;
 }
 
 bool QuotaDatabase::SetOriginLastAccessTime(
     const GURL& origin, StorageType type, base::Time last_access_time) {
   if (!LazyOpen(true))
     return false;
 
   sql::Statement statement;
 
   int used_count = 1;
   if (FindOriginUsedCount(origin, type, &used_count)) {
     ++used_count;
     const char* kSql =
         "UPDATE OriginInfoTable"
         " SET used_count = ?, last_access_time = ?"
         " WHERE origin = ? AND type = ?";
-    if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
-      return false;
+    statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   } else  {
     const char* kSql =
         "INSERT INTO OriginInfoTable"
         " (used_count, last_access_time, origin, type)"
         " VALUES (?, ?, ?, ?)";
-    if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
-      return false;
+    statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   }
-
   statement.BindInt(0, used_count);
   statement.BindInt64(1, last_access_time.ToInternalValue());
   statement.BindString(2, origin.spec());
   statement.BindInt(3, static_cast<int>(type));
+
   if (!statement.Run())
     return false;
 
   ScheduleCommit();
   return true;
 }
 
 bool QuotaDatabase::SetOriginLastModifiedTime(
     const GURL& origin, StorageType type, base::Time last_modified_time) {
   if (!LazyOpen(true))
     return false;
 
   sql::Statement statement;
 
   int dummy;
   if (FindOriginUsedCount(origin, type, &dummy)) {
     const char* kSql =
         "UPDATE OriginInfoTable"
         " SET last_modified_time = ?"
         " WHERE origin = ? AND type = ?";
-    if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
-      return false;
+    statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   } else {
     const char* kSql =
         "INSERT INTO OriginInfoTable"
         " (last_modified_time, origin, type)  VALUES (?, ?, ?)";
-    if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
-      return false;
+    statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   }
-
   statement.BindInt64(0, last_modified_time.ToInternalValue());
   statement.BindString(1, origin.spec());
   statement.BindInt(2, static_cast<int>(type));
+
   if (!statement.Run())
     return false;
 
   ScheduleCommit();
   return true;
 }
 
 bool QuotaDatabase::RegisterInitialOriginInfo(
     const std::set<GURL>& origins, StorageType type) {
   if (!LazyOpen(true))
     return false;
 
   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 OriginInfoTable"
         " (origin, type) VALUES (?, ?)";
-    sql::Statement statement;
-    if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
-      return false;
-
+    sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
     statement.BindString(0, itr->spec());
     statement.BindInt(1, static_cast<int>(type));
+
     if (!statement.Run())
       return false;
   }
 
   ScheduleCommit();
   return true;
 }
 
 bool QuotaDatabase::DeleteHostQuota(
     const std::string& host, StorageType type) {
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "DELETE FROM HostQuotaTable"
       " WHERE host = ? AND type = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
-    return false;
-
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindString(0, host);
   statement.BindInt(1, static_cast<int>(type));
+
   if (!statement.Run())
     return false;
 
   ScheduleCommit();
   return true;
 }
 
 bool QuotaDatabase::DeleteOriginInfo(
     const GURL& origin, StorageType type) {
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "DELETE FROM OriginInfoTable"
       " WHERE origin = ? AND type = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
-    return false;
-
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindString(0, origin.spec());
   statement.BindInt(1, static_cast<int>(type));
+
   if (!statement.Run())
     return false;
 
   ScheduleCommit();
   return true;
 }
 
 bool QuotaDatabase::GetQuotaConfigValue(const char* key, int64* value) {
   if (!LazyOpen(false))
     return false;
@@ skipping 14 matching lines @@
     SpecialStoragePolicy* special_storage_policy,
     GURL* origin) {
   DCHECK(origin);
   if (!LazyOpen(false))
     return false;
 
   const char* kSql = "SELECT origin FROM OriginInfoTable"
                      " WHERE type = ?"
                      " ORDER BY last_access_time ASC";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt(0, static_cast<int>(type));
 
   while (statement.Step()) {
     GURL url(statement.ColumnString(0));
     if (exceptions.find(url) != exceptions.end())
       continue;
     if (special_storage_policy &&
         special_storage_policy->IsStorageUnlimited(url))
       continue;
     *origin = url;
     return true;
   }
 
   *origin = GURL();
   return statement.Succeeded();
 }
 
 bool QuotaDatabase::GetOriginsModifiedSince(
     StorageType type, std::set<GURL>* origins, base::Time modified_since) {
   DCHECK(origins);
   if (!LazyOpen(false))
     return false;
 
   const char* kSql = "SELECT origin FROM OriginInfoTable"
                      " WHERE type = ? AND last_modified_time > ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt(0, static_cast<int>(type));
   statement.BindInt64(1, modified_since.ToInternalValue());
 
   origins->clear();
   while (statement.Step())
     origins->insert(GURL(statement.ColumnString(0)));
 
   return statement.Succeeded();
 }
 
@@ skipping 33 matching lines @@
 bool QuotaDatabase::FindOriginUsedCount(
     const GURL& origin, StorageType type, int* used_count) {
   DCHECK(used_count);
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT used_count FROM OriginInfoTable"
       " WHERE origin = ? AND type = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
-    return false;
-
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindString(0, origin.spec());
   statement.BindInt(1, static_cast<int>(type));
-  if (!statement.Step() || !statement.Succeeded())
+
+  if (!statement.Step())
     return false;
 
   *used_count = statement.ColumnInt(0);
   return true;
 }
 
 bool QuotaDatabase::LazyOpen(bool create_if_needed) {
   if (db_.get())
     return true;
 
@@ skipping 155 matching lines @@
   }
   return false;
 }
 
 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;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
 
   while (statement.Step()) {
     QuotaTableEntry entry = QuotaTableEntry(
       statement.ColumnString(0),
       static_cast<StorageType>(statement.ColumnInt(1)),
       statement.ColumnInt64(2));
 
     if (!callback->Run(entry))
       return true;
   }
 
   return statement.Succeeded();
 }
 
 bool QuotaDatabase::DumpOriginInfoTable(
     OriginInfoTableCallback* callback) {
   scoped_ptr<OriginInfoTableCallback> callback_deleter(callback);
 
   if (!LazyOpen(true))
     return false;
 
   const char* kSql = "SELECT * FROM OriginInfoTable";
-  sql::Statement statement;
-  if (!PrepareCachedStatement(db_.get(), SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
 
   while (statement.Step()) {
     OriginInfoTableEntry entry(
       GURL(statement.ColumnString(0)),
       static_cast<StorageType>(statement.ColumnInt(1)),
       statement.ColumnInt(2),
       base::Time::FromInternalValue(statement.ColumnInt64(3)),
       base::Time::FromInternalValue(statement.ColumnInt64(4)));
 
     if (!callback->Run(entry))
@@ skipping 17 matching lines @@
   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