Add basic sqlite error handling to the new sqlite handlers...

app/sql/connection.h

 // Copyright (c) 2009 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 APP_SQL_CONNECTION_H_
 #define APP_SQL_CONNECTION_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 48 matching lines @@
   // We need this to insert into our map.
   bool operator<(const StatementID& other) const;
 
  private:
   int number_;
   const char* str_;
 };
 
 #define SQL_FROM_HERE sql::StatementID(__FILE__, __LINE__)
 
+class Connection;
+
+// ErrorDelegate defines the interface to implement error handling and recovery
+// for sqlite operations. This allows the rest of the classes to return true or
+// false while the actual error code and causing statement are delivered using
+// the OnError() callback.
+// The tipical usage is to centralize the code designed to handle database
+// corruption, low-level IO errors or locking violations.
+class ErrorDelegate : public base::RefCounted<ErrorDelegate> {
+ public:
+  virtual ~ErrorDelegate() {}
+  // |error| is an sqlite result code as seen in sqlite\preprocessed\sqlite3.h
+  // |connection| is db connection where the error happened and |stmt| is
+  // our best guess at the statement that triggered the error. Do not store
+  // these pointers.
+  // If the error condition has been fixed an the original statement succesfuly
+  // re-tried then returning SQLITE_OK is appropiate; otherwise is recomended
+  // that you return the original |error| or the appropiae error code.
+  virtual int OnError(int error, Connection* connection, Statement* stmt) = 0;
+};
+
 class Connection {
  private:
   class StatementRef;  // Forward declaration, see real one below.
 
  public:
   // The database is opened by calling Init(). Any uncommitted transactions
   // will be rolled back when this object is deleted.
   Connection();
   ~Connection();
 
@@ skipping 18 matching lines @@
   // transaition (requires another access to the DB) and because we don't
   // actually need it.
   //
   // Exclusive mode means that the database is not unlocked at the end of each
   // transaction, which means there may be less time spent initializing the
   // next transaction because it doesn't have to re-aquire locks.
   //
   // This must be called before Init() to have an effect.
   void set_exclusive_locking() { exclusive_locking_ = true; }
 
+  // Sets the object that will handle errors. Recomended that it should be set
+  // before calling Init(). If not set, the default is to ignore errors on
+  // release and assert on debug builds.
+  void set_error_delegate(ErrorDelegate* delegate) {
+    error_delegate_ = delegate;
+  }
+
   // Initialization ------------------------------------------------------------
 
   // Initializes the SQL connection for the given file, returning true if the
   // file could be opened.
   bool Init(const FilePath& path);
 
   // Closes the database. This is automatically performed on destruction for
   // you, but this allows you to close the database early. You must not call
   // any other functions after closing it. It is permissable to call Close on
   // an uninitialized or already-closed database.
@@ skipping 154 matching lines @@
   void DoRollback();
 
   // Called by a StatementRef when it's being created or destroyed. See
   // open_statements_ below.
   void StatementRefCreated(StatementRef* ref);
   void StatementRefDeleted(StatementRef* ref);
 
   // Frees all cached statements from statement_cache_.
   void ClearCache();
 
+  // Called by Statement objects when an sqlite function returns an error.
+  // The return value is the error code reflected back to client code.
+  int OnSqliteError(int err, Statement* stmt);
+
   // The actual sqlite database. Will be NULL before Init has been called or if
   // Init resulted in an error.
   sqlite3* db_;
 
   // Parameters we'll configure in sqlite before doing anything else. Zero means
   // use the default value.
   int page_size_;
   int cache_size_;
   bool exclusive_locking_;
 
@@ skipping 10 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_;
 
+  // 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  // APP_SQL_CONNECTION_H_