Allow multiple sql::Connection error delegates.

sql/connection.h

 // 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 <vector>
 
 #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;
@@ skipping 111 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 Open() 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 Open(). If not set, the default is to ignore errors on
-  // release and assert on debug builds.
+  // Setup objects to handle errors.  SQLite errors can occur as early
+  // as Open() and as late as Close().  If no handlers are set, errors
+  // are ignored in release builds and crash in debug builds (in
+  // development, SQLite errors almost always mean an error in code).
+  // Returning SQLITE_OK from a delegate terminates error delegation.
+  void add_error_delegate(ErrorDelegate* delegate) {
+    error_delegates_.push_back(delegate);
+  }
+  void remove_error_delegate(ErrorDelegate* delegate) {
+    std::vector<scoped_refptr<ErrorDelegate> >::iterator iter =
+        error_delegates_.begin();
+    while (iter != error_delegates_.end()) {
+      if (*iter == delegate) {
+        iter = error_delegates_.erase(iter);
+      } else {
+        ++iter;
+      }
+    }
+  }
+  void clear_error_delegates() {
+    error_delegates_.clear();
+  }
+
+  // Previously there could only be one delegate.  Retain this for
+  // compatibility.
   void set_error_delegate(ErrorDelegate* delegate) {
-    error_delegate_ = delegate;
+    clear_error_delegates();
+    add_error_delegate(delegate);
   }
 
   // Initialization ------------------------------------------------------------
 
   // Initializes the SQL connection for the given file, returning true if the
   // file could be opened. You can call this or OpenInMemory.
   bool Open(const FilePath& path) WARN_UNUSED_RESULT;
 
   // Initializes the SQL connection for a temporary in-memory database. There
   // will be no associated file on disk, and the initial database will be
@@ skipping 279 matching lines @@
 
   // 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_;
+  // These objects handle errors resulting from all forms of executing sqlite
+  // commands or statements. It can be empty which means default handling.
+  std::vector<scoped_refptr<ErrorDelegate> > error_delegates_;
 
   DISALLOW_COPY_AND_ASSIGN(Connection);
 };
 
 }  // namespace sql
 
 #endif  // SQL_CONNECTION_H_