[sql] Refactor to remove use of const_cast<>.

sql/connection.h

 // Copyright (c) 2011 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_
 #pragma once
 
 #include <map>
 #include <set>
@@ skipping 321 matching lines @@
   // 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
   // been destroyed.
   //
   // The Connection may revoke a StatementRef in some error cases, so callers
   // should always check validity before using.
   class SQL_EXPORT StatementRef : public base::RefCounted<StatementRef> {
    public:
     // Default constructor initializes to an invalid statement.
     StatementRef();
+    explicit StatementRef(sqlite3_stmt* stmt);
     StatementRef(Connection* connection, sqlite3_stmt* stmt);
 
     // 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,
@@ skipping 29 matching lines @@
   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);
 
   // Like |Execute()|, but retries if the database is locked.
   bool ExecuteWithTimeout(const char* sql, base::TimeDelta ms_timeout)
       WARN_UNUSED_RESULT;
 
+  // Like GetUniqueStatement(), except the statement is not entered
+  // into open_statements_, allowing this to be const.  Open
+  // statements can block closing the database, so only use in cases
+  // where the last ref is released before close could be called.
+  scoped_refptr<StatementRef> GetUntrackedStatement(const char* sql) const;

[Greg Billock, 2012/07/12 21:08:17]

I am reading this as being private, right? It looks like a bug magnet if not. Is
there anyway to keep it fully in the .cc file?

[Scott Hess - ex-Googler, 2012/07/12 21:53:08]

Yeah, it's private.  Looks to me like pulling it into the anonymous namespace is
pretty trivial.  Then I noticed that StatementRef is private to Connection.

I've elaborated on the usage comment a bit.

+
   // 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 20 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  // SQL_CONNECTION_H_