First patch in making destructors of refcounted objects private.

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 58 matching lines @@
 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.
   //
   // |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 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 177 matching lines @@
   // indicate that the statement hasn't been created yet, has an error, or has
   // been destroyed.
   //
   // The Connection may revoke a StatementRef in some error cases, so callers
   // should always check validity before using.
   class StatementRef : public base::RefCounted<StatementRef> {
    public:
     // Default constructor initializes to an invalid statement.
     StatementRef();
     StatementRef(Connection* connection, sqlite3_stmt* stmt);
-    ~StatementRef();
 
     // When true, the statement can be used.
     bool is_valid() const { return !!stmt_; }
 
     // If we've not been linked to a connection, this will be NULL. Guaranteed
     // non-NULL when is_valid().
     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();
 
    private:
+    friend class base::RefCounted<StatementRef>;
+
+    ~StatementRef();
+
     Connection* connection_;
     sqlite3_stmt* stmt_;
 
     DISALLOW_COPY_AND_ASSIGN(StatementRef);
   };
   friend class StatementRef;
 
   // Executes a rollback statement, ignoring all transaction state. Used
   // internally in the transaction management code.
   void DoRollback();
@@ skipping 43 matching lines @@
   // 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_