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

sql/connection.h

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
 #ifndef SQL_CONNECTION_H_
 #define SQL_CONNECTION_H_
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
+#include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "sql/sql_export.h"
 
 class FilePath;
 struct sqlite3;
 struct sqlite3_stmt;
 
 namespace sql {
 
 class Statement;
@@ skipping 288 matching lines @@
  private:
   // Statement accesses StatementRef which we don't want to expose to everybody
   // (they should go through Statement).
   friend class Statement;
 
   // Internal initialize function used by both Init and InitInMemory. The file
   // name is always 8 bits since we want to use the 8-bit version of
   // sqlite3_open. The string can also be sqlite's special ":memory:" string.
   bool OpenInternal(const std::string& file_name);
 
+  // Check whether the current thread is allowed to make IO calls, but only
+  // if database wasn't open in memory. Function is inlined to be a no-op in
+  // official build.
+  void AssertIOAllowed() {
+    if (!in_memory_)
+      base::ThreadRestrictions::AssertIOAllowed();
+  }
+
   // Internal helper for DoesTableExist and DoesIndexExist.
   bool DoesTableOrIndexExist(const char* name, const char* type) const;
 
   // A StatementRef is a refcounted wrapper around a sqlite statement pointer.
   // Refcounting allows us to give these statements out to sql::Statement
   // objects while also optionally maintaining a cache of compiled statements
   // by just keeping a refptr to these objects.
   //
   // A statement ref can be valid, in which case it can be used, or invalid to
   // indicate that the statement hasn't been created yet, has an error, or has
@@ skipping 15 matching lines @@
     Connection* connection() const { return connection_; }
 
     // Returns the sqlite statement if any. If the statement is not active,
     // this will return NULL.
     sqlite3_stmt* stmt() const { return stmt_; }
 
     // Destroys the compiled statement and marks it NULL. The statement will
     // no longer be active.
     void Close();
 
+    // Check whether the current thread is allowed to make IO calls, but only
+    // if database wasn't open in memory.
+    void AssertIOAllowed() { if (connection_) connection_->AssertIOAllowed(); }
+
    private:
     friend class base::RefCounted<StatementRef>;
 
     ~StatementRef();
 
     Connection* connection_;
     sqlite3_stmt* stmt_;
 
     DISALLOW_COPY_AND_ASSIGN(StatementRef);
   };
@@ skipping 42 matching lines @@
   StatementRefSet open_statements_;
 
   // Number of currently-nested transactions.
   int transaction_nesting_;
 
   // True if any of the currently nested transactions have been rolled back.
   // When we get to the outermost transaction, this will determine if we do
   // a rollback instead of a commit.
   bool needs_rollback_;
 
+  // True if database is open with OpenInMemory(), False if database is open
+  // with Open().
+  bool in_memory_;
+
   // This object handles errors resulting from all forms of executing sqlite
   // commands or statements. It can be null which means default handling.
   scoped_refptr<ErrorDelegate> error_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(Connection);
 };
 
 }  // namespace sql
 
 #endif  // SQL_CONNECTION_H_