Remove ref counting on sql::ErrorDelegate

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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.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 {
 
@@ skipping 46 matching lines @@
 #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 SQL_EXPORT ErrorDelegate : public base::RefCounted<ErrorDelegate> {
+class SQL_EXPORT ErrorDelegate {
  public:
-  ErrorDelegate();
+  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.
   //
   // |stmt| MAY BE NULL if there is no statement causing the problem (i.e. on
   // initialization).
   //
   // 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;
-
- protected:
-  friend class base::RefCounted<ErrorDelegate>;
-
-  virtual ~ErrorDelegate();
 };
 
 class SQL_EXPORT Connection {
  private:
   class StatementRef;  // Forward declaration, see real one below.
 
  public:
   // The database is opened by calling Open[InMemory](). Any uncommitted
   // transactions will be rolled back when this object is deleted.
   Connection();
@@ skipping 23 matching lines @@
   // 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.
+  // Takes ownership of |delegate|.
   void set_error_delegate(ErrorDelegate* delegate) {
-    error_delegate_ = delegate;
+    error_delegate_.reset(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 281 matching lines @@
   // 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_;
+  scoped_ptr<ErrorDelegate> error_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(Connection);
 };
 
 }  // namespace sql
 
 #endif  // SQL_CONNECTION_H_