Annotate calls to SQLite functions - they have to be executed on a thread allowing IO access.

sql/connection.cc

 // Copyright (c) 2012 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 "sql/connection.h"
 
 #include <string.h>
 
 #include "base/file_path.h"
 #include "base/logging.h"
@@ skipping 58 matching lines @@
 }
 
 Connection::StatementRef::~StatementRef() {
   if (connection_)
     connection_->StatementRefDeleted(this);
   Close();
 }
 
 void Connection::StatementRef::Close() {
   if (stmt_) {
+    AssertIOAllowed();

[Scott Hess - ex-Googler, 2012/06/26 16:39:47]

In cases like this, I would prefer the assert move to the top of the function,
so that it's part of the API contract.  Otherwise there is a chance that
unrelated code changes remove a duplicate Close(), and we'll find out that one
caller was calling Close() on the right thread, and the other on the wrong
thread.  Better to knock those all out up front.  Let me know if this didn't
make sense to you and I can elaborate.

Unfortunately, this makes the bright line of "AssertIOAllowed() before any
sqlite3_*() function call" less bright.

     sqlite3_finalize(stmt_);
     stmt_ = NULL;
   }
   connection_ = NULL;  // The connection may be getting deleted.
 }
 
 Connection::Connection()
     : db_(NULL),
       page_size_(0),
       cache_size_(0),
       exclusive_locking_(false),
       transaction_nesting_(0),
-      needs_rollback_(false) {
+      needs_rollback_(false),
+      in_memory_(false) {
 }
 
 Connection::~Connection() {
   Close();
 }
 
 bool Connection::Open(const FilePath& path) {
 #if defined(OS_WIN)
   return OpenInternal(WideToUTF8(path.value()));
 #elif defined(OS_POSIX)
   return OpenInternal(path.value());
 #endif
 }
 
 bool Connection::OpenInMemory() {
+  in_memory_ = true;
   return OpenInternal(":memory:");
 }
 
 void Connection::Close() {
   // TODO(shess): Calling "PRAGMA journal_mode = DELETE" at this point
   // will delete the -journal file.  For ChromiumOS or other more
   // embedded systems, this is probably not appropriate, whereas on
   // desktop it might make some sense.
 
   // sqlite3_close() needs all prepared statements to be finalized.
   // Release all cached statements, then assert that the client has
   // released all statements.
   statement_cache_.clear();
   DCHECK(open_statements_.empty());
 
   // Additionally clear the prepared statements, because they contain
   // weak references to this connection.  This case has come up when
   // error-handling code is hit in production.
   ClearCache();
 
   if (db_) {
+    AssertIOAllowed();
     // TODO(shess): Histogram for failure.
     sqlite3_close(db_);
     db_ = NULL;
   }
 }
 
 void Connection::Preload() {
   if (!db_) {
     DLOG(FATAL) << "Cannot preload null db";
     return;
   }
 
   // A statement must be open for the preload command to work. If the meta
   // table doesn't exist, it probably means this is a new database and there
   // is nothing to preload (so it's OK we do nothing).
   if (!DoesTableExist("meta"))
     return;
   Statement dummy(GetUniqueStatement("SELECT * FROM meta"));
   if (!dummy.Step())
     return;
 
 #if !defined(USE_SYSTEM_SQLITE)
+  AssertIOAllowed();
   // This function is only defined in Chromium's version of sqlite.
   // Do not call it when using system sqlite.
   sqlite3_preload(db_);
 #endif
 }
 
 // Create an in-memory database with the existing database's page
 // size, then backup that database over the existing database.
 bool Connection::Raze() {
   if (!db_) {
@@ skipping 24 matching lines @@
   // The page size doesn't take effect until a database has pages, and
   // at this point the null database has none.  Changing the schema
   // version will create the first page.  This will not affect the
   // schema version in the resulting database, as SQLite's backup
   // implementation propagates the schema version from the original
   // connection to the new version of the database, incremented by one
   // so that other readers see the schema change and act accordingly.
   if (!null_db.Execute("PRAGMA schema_version = 1"))
     return false;
 
+  AssertIOAllowed();
   sqlite3_backup* backup = sqlite3_backup_init(db_, "main",
                                                null_db.db_, "main");
   if (!backup) {
     DLOG(FATAL) << "Unable to start sqlite3_backup().";
     return false;
   }
 
   // -1 backs up the entire database.
   int rc = sqlite3_backup_step(backup, -1);
   int pages = sqlite3_backup_pagecount(backup);
@@ skipping 83 matching lines @@
     return false;
   }
 
   Statement commit(GetCachedStatement(SQL_FROM_HERE, "COMMIT"));
   return commit.Run();
 }
 
 int Connection::ExecuteAndReturnErrorCode(const char* sql) {
   if (!db_)
     return false;
+  AssertIOAllowed();
   return sqlite3_exec(db_, sql, NULL, NULL, NULL);
 }
 
 bool Connection::Execute(const char* sql) {
   int error = ExecuteAndReturnErrorCode(sql);
   // This needs to be a FATAL log because the error case of arriving here is
   // that there's a malformed SQL statement. This can arise in development if
   // a change alters the schema but not all queries adjust.
   if (error == SQLITE_ERROR)
     DLOG(FATAL) << "SQL Error in " << sql << ", " << GetErrorMessage();
@@ skipping 31 matching lines @@
   if (statement->is_valid())
     statement_cache_[id] = statement;  // Only cache valid statements.
   return statement;
 }
 
 scoped_refptr<Connection::StatementRef> Connection::GetUniqueStatement(
     const char* sql) {
   if (!db_)
     return new StatementRef(this, NULL);  // Return inactive statement.
 
+  AssertIOAllowed();
   sqlite3_stmt* stmt = NULL;
   if (sqlite3_prepare_v2(db_, sql, -1, &stmt, NULL) != SQLITE_OK) {
     // This is evidence of a syntax error in the incoming SQL.
     DLOG(FATAL) << "SQL compile error " << GetErrorMessage();
     return new StatementRef(this, NULL);
   }
   return new StatementRef(this, stmt);
 }
 
 bool Connection::IsSQLValid(const char* sql) {
+  AssertIOAllowed();
   sqlite3_stmt* stmt = NULL;
   if (sqlite3_prepare_v2(db_, sql, -1, &stmt, NULL) != SQLITE_OK)
     return false;
 
   sqlite3_finalize(stmt);
   return true;
 }
 
 bool Connection::DoesTableExist(const char* table_name) const {
   return DoesTableOrIndexExist(table_name, "table");
@@ skipping 71 matching lines @@
     return "sql::Connection has no connection.";
   return sqlite3_errmsg(db_);
 }
 
 bool Connection::OpenInternal(const std::string& file_name) {
   if (db_) {
     DLOG(FATAL) << "sql::Connection is already open.";
     return false;
   }
 
+  AssertIOAllowed();
   int err = sqlite3_open(file_name.c_str(), &db_);
   if (err != SQLITE_OK) {
     OnSqliteError(err, NULL);
     Close();
     db_ = NULL;
     return false;
   }
 
   // Enable extended result codes to provide more color on I/O errors.
   // Not having extended result codes is not a fatal problem, as
@@ skipping 90 matching lines @@
 
 int Connection::OnSqliteError(int err, sql::Statement *stmt) {
   if (error_delegate_.get())
     return error_delegate_->OnError(err, this, stmt);
   // The default handling is to assert on debug and to ignore on release.
   DLOG(FATAL) << GetErrorMessage();
   return err;
 }
 
 }  // namespace sql