Database usage adjustment for .../webkit

webkit/appcache/appcache_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/appcache/appcache_database.h"
 
 #include "base/auto_reset.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
@@ skipping 222 matching lines @@
 }
 
 bool AppCacheDatabase::FindOriginsWithGroups(std::set<GURL>* origins) {
   DCHECK(origins && origins->empty());
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT DISTINCT(origin) FROM Groups";
 
-  sql::Statement statement;
-  if (!PrepareUniqueStatement(kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetUniqueStatement(kSql));
 
   while (statement.Step())
     origins->insert(GURL(statement.ColumnString(0)));
 
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::FindLastStorageIds(
     int64* last_group_id, int64* last_cache_id, int64* last_response_id,
     int64* last_deletable_response_rowid) {
@@ skipping 43 matching lines @@
 bool AppCacheDatabase::FindGroup(int64 group_id, GroupRecord* record) {
   DCHECK(record);
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT group_id, origin, manifest_url,"
       "       creation_time, last_access_time"
       "  FROM Groups WHERE group_id = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
 
   statement.BindInt64(0, group_id);
   if (!statement.Step() || !statement.Succeeded())

[Scott Hess - ex-Googler, 2012/01/18 21:24:03]

I think that statement.Succeeded() implies !statement.Step(), so this can be
reduced to just check statement.Step().  Please hit the many other locations in
this file while there.

[I agree that this isn't directly your problem :-).  But your changes imply
inspecting the flow-of-control to return values, so it's probably an opportune
time to do it.]

[Greg Billock, 2012/01/18 21:54:33]

No, that's fair. One goal is to regularize usage so that it hopefully stays that
way when code gets copy-pasted down into new areas.

     return false;
 
   ReadGroupRecord(statement, record);
   DCHECK(record->group_id == group_id);
   return true;
 }
 
 bool AppCacheDatabase::FindGroupForManifestUrl(
     const GURL& manifest_url, GroupRecord* record) {
   DCHECK(record);
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT group_id, origin, manifest_url,"
       "       creation_time, last_access_time"
       "  FROM Groups WHERE manifest_url = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindString(0, manifest_url.spec());
 
-  statement.BindString(0, manifest_url.spec());
   if (!statement.Step() || !statement.Succeeded())
     return false;
 
   ReadGroupRecord(statement, record);
   DCHECK(record->manifest_url == manifest_url);
   return true;
 }
 
 bool AppCacheDatabase::FindGroupsForOrigin(
     const GURL& origin, std::vector<GroupRecord>* records) {
   DCHECK(records && records->empty());
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT group_id, origin, manifest_url,"
       "       creation_time, last_access_time"
       "   FROM Groups WHERE origin = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindString(0, origin.spec());
 
-  statement.BindString(0, origin.spec());
   while (statement.Step()) {
     records->push_back(GroupRecord());
     ReadGroupRecord(statement, &records->back());
     DCHECK(records->back().origin == origin);
   }
 
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::FindGroupForCache(int64 cache_id, GroupRecord* record) {
   DCHECK(record);
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT g.group_id, g.origin, g.manifest_url,"
       "       g.creation_time, g.last_access_time"
       "  FROM Groups g, Caches c"
       "  WHERE c.cache_id = ? AND c.group_id = g.group_id";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, cache_id);
 
-  statement.BindInt64(0, cache_id);
   if (!statement.Step() || !statement.Succeeded())
     return false;
 
   ReadGroupRecord(statement, record);
   return true;
 }
 
 bool AppCacheDatabase::UpdateGroupLastAccessTime(
     int64 group_id, base::Time time) {
   if (!LazyOpen(true))
     return false;
 
   const char* kSql =
       "UPDATE Groups SET last_access_time = ? WHERE group_id = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
-
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, time.ToInternalValue());
   statement.BindInt64(1, group_id);
+
   return statement.Run() && db_->GetLastChangeCount();
 }
 
 bool AppCacheDatabase::InsertGroup(const GroupRecord* record) {
   if (!LazyOpen(true))
     return false;
 
   const char* kSql =
       "INSERT INTO Groups"
       "  (group_id, origin, manifest_url, creation_time, last_access_time)"
       "  VALUES(?, ?, ?, ?, ?)";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
-
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, record->group_id);
   statement.BindString(1, record->origin.spec());
   statement.BindString(2, record->manifest_url.spec());
   statement.BindInt64(3, record->creation_time.ToInternalValue());
   statement.BindInt64(4, record->last_access_time.ToInternalValue());
+
   return statement.Run();
 }
 
 bool AppCacheDatabase::DeleteGroup(int64 group_id) {
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "DELETE FROM Groups WHERE group_id = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, group_id);
 
-  statement.BindInt64(0, group_id);
   return statement.Run();
 }
 
 bool AppCacheDatabase::FindCache(int64 cache_id, CacheRecord* record) {
   DCHECK(record);
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT cache_id, group_id, online_wildcard, update_time, cache_size"
       " FROM Caches WHERE cache_id = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, cache_id);
 
-  statement.BindInt64(0, cache_id);
   if (!statement.Step() || !statement.Succeeded())
     return false;
 
   ReadCacheRecord(statement, record);
   return true;
 }
 
 bool AppCacheDatabase::FindCacheForGroup(int64 group_id, CacheRecord* record) {
   DCHECK(record);
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT cache_id, group_id, online_wildcard, update_time, cache_size"
       "  FROM Caches WHERE group_id = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, group_id);
 
-  statement.BindInt64(0, group_id);
   if (!statement.Step() || !statement.Succeeded())
     return false;
 
   ReadCacheRecord(statement, record);
   return true;
 }
 
 bool AppCacheDatabase::FindCachesForOrigin(
     const GURL& origin, std::vector<CacheRecord>* records) {
   DCHECK(records);
@@ skipping 13 matching lines @@
 
 bool AppCacheDatabase::InsertCache(const CacheRecord* record) {
   if (!LazyOpen(true))
     return false;
 
   const char* kSql =
       "INSERT INTO Caches (cache_id, group_id, online_wildcard,"
       "                    update_time, cache_size)"
       "  VALUES(?, ?, ?, ?, ?)";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
-
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, record->cache_id);
   statement.BindInt64(1, record->group_id);
   statement.BindBool(2, record->online_wildcard);
   statement.BindInt64(3, record->update_time.ToInternalValue());
   statement.BindInt64(4, record->cache_size);
+
   return statement.Run();
 }
 
 bool AppCacheDatabase::DeleteCache(int64 cache_id) {
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "DELETE FROM Caches WHERE cache_id = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, cache_id);
 
-  statement.BindInt64(0, cache_id);
   return statement.Run();
 }
 
 bool AppCacheDatabase::FindEntriesForCache(
     int64 cache_id, std::vector<EntryRecord>* records) {
   DCHECK(records && records->empty());
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT cache_id, url, flags, response_id, response_size FROM Entries"
       "  WHERE cache_id = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, cache_id);
 
-  statement.BindInt64(0, cache_id);
   while (statement.Step()) {
     records->push_back(EntryRecord());
     ReadEntryRecord(statement, &records->back());
     DCHECK(records->back().cache_id == cache_id);
   }
 
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::FindEntriesForUrl(
     const GURL& url, std::vector<EntryRecord>* records) {
   DCHECK(records && records->empty());
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT cache_id, url, flags, response_id, response_size FROM Entries"
       "  WHERE url = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindString(0, url.spec());
 
-  statement.BindString(0, url.spec());
   while (statement.Step()) {
     records->push_back(EntryRecord());
     ReadEntryRecord(statement, &records->back());
     DCHECK(records->back().url == url);
   }
 
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::FindEntry(
     int64 cache_id, const GURL& url, EntryRecord* record) {
   DCHECK(record);
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT cache_id, url, flags, response_id, response_size FROM Entries"
       "  WHERE cache_id = ? AND url = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
-
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
   statement.BindString(1, url.spec());
+
   if (!statement.Step() || !statement.Succeeded())
     return false;
 
   ReadEntryRecord(statement, record);
   DCHECK(record->cache_id == cache_id);
   DCHECK(record->url == url);
   return true;
 }
 
 bool AppCacheDatabase::InsertEntry(const EntryRecord* record) {
   if (!LazyOpen(true))
     return false;
 
   const char* kSql =
       "INSERT INTO Entries (cache_id, url, flags, response_id, response_size)"
       "  VALUES(?, ?, ?, ?, ?)";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
-
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, record->cache_id);
   statement.BindString(1, record->url.spec());
   statement.BindInt(2, record->flags);
   statement.BindInt64(3, record->response_id);
   statement.BindInt64(4, record->response_size);
+
   return statement.Run();
 }
 
 bool AppCacheDatabase::InsertEntryRecords(
     const std::vector<EntryRecord>& records) {
   if (records.empty())
     return true;
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
   std::vector<EntryRecord>::const_iterator iter = records.begin();
   while (iter != records.end()) {
     if (!InsertEntry(&(*iter)))
       return false;
     ++iter;
   }
   return transaction.Commit();
 }
 
 bool AppCacheDatabase::DeleteEntriesForCache(int64 cache_id) {
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "DELETE FROM Entries WHERE cache_id = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, cache_id);
 
-  statement.BindInt64(0, cache_id);
   return statement.Run();

[Scott Hess - ex-Googler, 2012/01/18 21:24:03]

Aside: These are the cases which make me ponder revising the API to allow
something like:
  return db_->Prepare(kSql).BindInt64(cache_id).Run();

 }
 
 bool AppCacheDatabase::AddEntryFlags(
     const GURL& entry_url, int64 cache_id, int additional_flags) {
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "UPDATE Entries SET flags = flags | ? WHERE cache_id = ? AND url = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
-
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt(0, additional_flags);
   statement.BindInt64(1, cache_id);
   statement.BindString(2, entry_url.spec());
+
   return statement.Run() && db_->GetLastChangeCount();
 }
 
 bool AppCacheDatabase::FindNamespacesForOrigin(
     const GURL& origin,
     std::vector<NamespaceRecord>* intercepts,
     std::vector<NamespaceRecord>* fallbacks) {
   DCHECK(intercepts && intercepts->empty());
   DCHECK(fallbacks && fallbacks->empty());
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT cache_id, origin, type, namespace_url, target_url"
       "  FROM Namespaces WHERE origin = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindString(0, origin.spec());
 
-  statement.BindString(0, origin.spec());
   ReadNamespaceRecords(&statement, intercepts, fallbacks);
+
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::FindNamespacesForCache(
     int64 cache_id,
     std::vector<NamespaceRecord>* intercepts,
     std::vector<NamespaceRecord>* fallbacks) {
   DCHECK(intercepts && intercepts->empty());
   DCHECK(fallbacks && fallbacks->empty());
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT cache_id, origin, type, namespace_url, target_url"
       "  FROM Namespaces WHERE cache_id = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, cache_id);
 
-  statement.BindInt64(0, cache_id);
   ReadNamespaceRecords(&statement, intercepts, fallbacks);
+
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::InsertNamespace(
     const NamespaceRecord* record) {
   if (!LazyOpen(true))
     return false;
 
   const char* kSql =
       "INSERT INTO Namespaces"
       "  (cache_id, origin, type, namespace_url, target_url)"
       "  VALUES (?, ?, ?, ?, ?)";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
-
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, record->cache_id);
   statement.BindString(1, record->origin.spec());
   statement.BindInt(2, record->type);
   statement.BindString(3, record->namespace_url.spec());
   statement.BindString(4, record->target_url.spec());
+
   return statement.Run();
 }
 
 bool AppCacheDatabase::InsertNamespaceRecords(
     const std::vector<NamespaceRecord>& records) {
   if (records.empty())
     return true;
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
   std::vector<NamespaceRecord>::const_iterator iter = records.begin();
   while (iter != records.end()) {
     if (!InsertNamespace(&(*iter)))
       return false;
     ++iter;
   }
   return transaction.Commit();
 }
 
 bool AppCacheDatabase::DeleteNamespacesForCache(int64 cache_id) {
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "DELETE FROM Namespaces WHERE cache_id = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, cache_id);
 
-  statement.BindInt64(0, cache_id);
   return statement.Run();
 }
 
 bool AppCacheDatabase::FindOnlineWhiteListForCache(
     int64 cache_id, std::vector<OnlineWhiteListRecord>* records) {
   DCHECK(records && records->empty());
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT cache_id, namespace_url FROM OnlineWhiteLists"
       "  WHERE cache_id = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, cache_id);
 
-  statement.BindInt64(0, cache_id);
   while (statement.Step()) {
     records->push_back(OnlineWhiteListRecord());
     this->ReadOnlineWhiteListRecord(statement, &records->back());
     DCHECK(records->back().cache_id == cache_id);
   }
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::InsertOnlineWhiteList(
     const OnlineWhiteListRecord* record) {
   if (!LazyOpen(true))
     return false;
 
   const char* kSql =
       "INSERT INTO OnlineWhiteLists (cache_id, namespace_url) VALUES (?, ?)";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
-
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, record->cache_id);
   statement.BindString(1, record->namespace_url.spec());
+
   return statement.Run();
 }
 
 bool AppCacheDatabase::InsertOnlineWhiteListRecords(
     const std::vector<OnlineWhiteListRecord>& records) {
   if (records.empty())
     return true;
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
   std::vector<OnlineWhiteListRecord>::const_iterator iter = records.begin();
   while (iter != records.end()) {
     if (!InsertOnlineWhiteList(&(*iter)))
       return false;
     ++iter;
   }
   return transaction.Commit();
 }
 
 bool AppCacheDatabase::DeleteOnlineWhiteListForCache(int64 cache_id) {
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "DELETE FROM OnlineWhiteLists WHERE cache_id = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, cache_id);
 
-  statement.BindInt64(0, cache_id);
   return statement.Run();
 }
 
 bool AppCacheDatabase::GetDeletableResponseIds(
     std::vector<int64>* response_ids, int64 max_rowid, int limit) {
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT response_id FROM DeletableResponseIds "
       "  WHERE rowid <= ?"
       "  LIMIT ?";
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
 
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, max_rowid);
   statement.BindInt64(1, limit);
+
   while (statement.Step())
     response_ids->push_back(statement.ColumnInt64(0));
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::InsertDeletableResponseIds(
     const std::vector<int64>& response_ids) {
   const char* kSql =
       "INSERT INTO DeletableResponseIds (response_id) VALUES (?)";
   return RunCachedStatementWithIds(SQL_FROM_HERE, kSql, response_ids);
 }
 
 bool AppCacheDatabase::DeleteDeletableResponseIds(
     const std::vector<int64>& response_ids) {
   const char* kSql =
       "DELETE FROM DeletableResponseIds WHERE response_id = ?";
   return RunCachedStatementWithIds(SQL_FROM_HERE, kSql, response_ids);
 }
 
 bool AppCacheDatabase::RunCachedStatementWithIds(
     const sql::StatementID& statement_id, const char* sql,
     const std::vector<int64>& ids) {
+  DCHECK(sql);
   if (!LazyOpen(true))
     return false;
 
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(statement_id, sql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(statement_id, sql));
 
   std::vector<int64>::const_iterator iter = ids.begin();
   while (iter != ids.end()) {
     statement.BindInt64(0, *iter);
     if (!statement.Run())
       return false;
     statement.Reset();
     ++iter;
   }
 
   return transaction.Commit();
 }
 
 bool AppCacheDatabase::RunUniqueStatementWithInt64Result(
     const char* sql, int64* result) {
-  sql::Statement statement;
-  if (!PrepareUniqueStatement(sql, &statement) ||
-      !statement.Step()) {
+  DCHECK(sql);
+  sql::Statement statement(db_->GetUniqueStatement(sql));
+  if (!statement.Step()) {
     return false;
   }
   *result = statement.ColumnInt64(0);
   return true;
 }
 
-bool AppCacheDatabase::PrepareUniqueStatement(
-    const char* sql, sql::Statement* statement) {
-  DCHECK(sql && statement);
-  statement->Assign(db_->GetUniqueStatement(sql));
-  if (!statement->is_valid()) {
-    NOTREACHED() << db_->GetErrorMessage();
-    return false;
-  }
-  return true;
-}
-
-bool AppCacheDatabase::PrepareCachedStatement(
-    const sql::StatementID& id, const char* sql, sql::Statement* statement) {
-  DCHECK(sql && statement);
-  statement->Assign(db_->GetCachedStatement(id, sql));
-  if (!statement->is_valid()) {
-    NOTREACHED() << db_->GetErrorMessage();
-    return false;
-  }
-  return true;
-}
-
 bool AppCacheDatabase::FindResponseIdsForCacheHelper(
     int64 cache_id, std::vector<int64>* ids_vector,
     std::set<int64>* ids_set) {
   DCHECK(ids_vector || ids_set);
   DCHECK(!(ids_vector && ids_set));
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT response_id FROM Entries WHERE cache_id = ?";
 
-  sql::Statement statement;
-  if (!PrepareCachedStatement(SQL_FROM_HERE, kSql, &statement))
-    return false;
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
 
   statement.BindInt64(0, cache_id);
   while (statement.Step()) {
     int64 id = statement.ColumnInt64(0);
     if (ids_set)
       ids_set->insert(id);
     else
       ids_vector->push_back(id);
   }
 
@@ skipping 230 matching lines @@
 
   // So we can't go recursive.
   if (is_recreating_)
     return false;
 
   AutoReset<bool> auto_reset(&is_recreating_, true);
   return LazyOpen(true);
 }
 
 }  // namespace appcache