Correct sqlite wrapper behavior on systems where wchar_t is UTF-32,

chrome/common/sqlite_utils.h

 // Copyright (c) 2006-2008 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 CHROME_COMMON_SQLITEUTILS_H_
 #define CHROME_COMMON_SQLITEUTILS_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/string16.h"
+#include "base/string_util.h"
 
 #include "third_party/sqlite/preprocessed/sqlite3.h"
 
 // forward declarations of classes defined here
 class FilePath;
 class SQLTransaction;
 class SQLNestedTransaction;
 class SQLNestedTransactionSite;
 class scoped_sqlite3_stmt_ptr;
 class SQLStatement;
@@ skipping 181 matching lines @@
  public:
   SQLStatement() {
   }
 
   int prepare(sqlite3* db, const char* sql) {
     return prepare(db, sql, -1);
   }
 
   int prepare(sqlite3* db, const char* sql, int sql_len);
 
-  int prepare16(sqlite3* db, const wchar_t* sql) {
-    return prepare16(db, sql, -1);
-  }
-
-  // sql_len is number of characters or may be negative
-  // a for null-terminated sql string
-  int prepare16(sqlite3* db, const wchar_t* sql, int sql_len);
   int step();
   int reset();
   sqlite_int64 last_insert_rowid();
   sqlite3* db_handle();
 
   //
   // Parameter binding helpers (NOTE: index is 0-based)
   //
 
   int bind_parameter_count();
@@ skipping 12 matching lines @@
   int bind_string(int index, const std::string& value) {
     // don't use c_str so it doesn't have to fix up the null terminator
     // (sqlite just uses the length)
     return bind_text(index, value.data(),
                      static_cast<int>(value.length()), SQLITE_TRANSIENT);
   }
 
   int bind_wstring(int index, const std::wstring& value) {
     // don't use c_str so it doesn't have to fix up the null terminator
     // (sqlite just uses the length)
-    return bind_text16(index, value.data(),
-                       static_cast<int>(value.length()), SQLITE_TRANSIENT);
+    std::string value_utf8(WideToUTF8(value));
+    return bind_text(index, value_utf8.data(),
+                     static_cast<int>(value_utf8.length()), SQLITE_TRANSIENT);
   }
 
   int bind_text(int index, const char* value) {
     return bind_text(index, value, -1, SQLITE_TRANSIENT);
   }
 
   // value_len is number of characters or may be negative
   // a for null-terminated value string
   int bind_text(int index, const char* value, int value_len) {
     return bind_text(index, value, value_len, SQLITE_TRANSIENT);
   }
 
   // value_len is number of characters or may be negative
   // a for null-terminated value string
   int bind_text(int index, const char* value, int value_len,
                 Function dtor);
 
-  int bind_text16(int index, const wchar_t* value) {
+  int bind_text16(int index, const char16* value) {
     return bind_text16(index, value, -1, SQLITE_TRANSIENT);
   }
 
   // value_len is number of characters or may be negative
   // a for null-terminated value string
-  int bind_text16(int index, const wchar_t* value, int value_len) {
+  int bind_text16(int index, const char16* value, int value_len) {
     return bind_text16(index, value, value_len, SQLITE_TRANSIENT);
   }
 
   // value_len is number of characters or may be negative
   // a for null-terminated value string
-  int bind_text16(int index, const wchar_t* value, int value_len,
+  int bind_text16(int index, const char16* value, int value_len,
                   Function dtor);
 
   int bind_value(int index, const sqlite3_value* value);
 
   //
   // Column helpers (NOTE: index is 0-based)
   //
 
   int column_count();
   int column_type(int index);
-  const wchar_t* column_name16(int index);
   const void* column_blob(int index);
   bool column_blob_as_vector(int index, std::vector<unsigned char>* blob);
   bool column_blob_as_string(int index, std::string* blob);
   int column_bytes(int index);
   int column_bytes16(int index);
   double column_double(int index);
   bool column_bool(int index);
   int column_int(int index);
   sqlite_int64 column_int64(int index);
   const char* column_text(int index);
   bool column_string(int index, std::string* str);
   std::string column_string(int index);
-  const wchar_t* column_text16(int index);
-  bool column_string16(int index, std::wstring* str);
-  std::wstring column_string16(int index);
+  const char16* column_text16(int index);
+  bool column_wstring(int index, std::wstring* str);
+  std::wstring column_wstring(int index);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SQLStatement);
 };
 
 // TODO(estade): wrap the following static functions in a namespace.
 
 // Opens the DB in the file pointed to by |filepath|.
 // See http://www.sqlite.org/capi3ref.html#sqlite3_open for an explanation
 // of the return value.
@@ skipping 27 matching lines @@
                            const char* column_type) {
   return DoesSqliteColumnExist(db, NULL, table_name, column_name, column_type);
 }
 
 // Test whether a table has one or more rows. Returns true if the table
 // has one or more rows and false if the table is empty or doesn't exist.
 bool DoesSqliteTableHaveRow(sqlite3* db, const char* table_name);
 
 #endif  // CHROME_COMMON_SQLITEUTILS_H_