Use sql::Statement::BindString16 in a bunch of places to get rid of UTF16ToUTF8 conversions.

chrome/browser/webdata/web_database.cc

 // Copyright (c) 2010 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.
 
 #include "chrome/browser/webdata/web_database.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 696 matching lines @@
       "VALUES "
       "(?,?,?,?,?,?,?,?,?,?,?,?,?)"));
   if (!s) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
   std::string encrypted_password;
   s.BindString(0, form.origin.spec());
   s.BindString(1, form.action.spec());
-  s.BindString(2, UTF16ToUTF8(form.username_element));
-  s.BindString(3, UTF16ToUTF8(form.username_value));
-  s.BindString(4, UTF16ToUTF8(form.password_element));
+  s.BindString16(2, form.username_element);
+  s.BindString16(3, form.username_value);
+  s.BindString16(4, form.password_element);
   Encryptor::EncryptString16(form.password_value, &encrypted_password);
   s.BindBlob(5, encrypted_password.data(),
              static_cast<int>(encrypted_password.length()));
-  s.BindString(6, UTF16ToUTF8(form.submit_element));
+  s.BindString16(6, form.submit_element);
   s.BindString(7, form.signon_realm);
   s.BindInt(8, form.ssl_valid);
   s.BindInt(9, form.preferred);
   s.BindInt64(10, form.date_created.ToTimeT());
   s.BindInt(11, form.blacklisted_by_user);
   s.BindInt(12, form.scheme);
   if (!s.Run()) {
     NOTREACHED();
     return false;
   }
@@ skipping 18 matching lines @@
   }
 
   s.BindString(0, form.action.spec());
   std::string encrypted_password;
   Encryptor::EncryptString16(form.password_value, &encrypted_password);
   s.BindBlob(1, encrypted_password.data(),
              static_cast<int>(encrypted_password.length()));
   s.BindInt(2, form.ssl_valid);
   s.BindInt(3, form.preferred);
   s.BindString(4, form.origin.spec());
-  s.BindString(5, UTF16ToUTF8(form.username_element));
-  s.BindString(6, UTF16ToUTF8(form.username_value));
-  s.BindString(7, UTF16ToUTF8(form.password_element));
+  s.BindString16(5, form.username_element);
+  s.BindString16(6, form.username_value);
+  s.BindString16(7, form.password_element);
   s.BindString(8, form.signon_realm);
 
   if (!s.Run()) {
     NOTREACHED();
     return false;
   }
   return true;
 }
 
 bool WebDatabase::RemoveLogin(const PasswordForm& form) {
   // Remove a login by UNIQUE-constrained fields.
   sql::Statement s(db_.GetUniqueStatement(
       "DELETE FROM logins WHERE "
       "origin_url = ? AND "
       "username_element = ? AND "
       "username_value = ? AND "
       "password_element = ? AND "
       "submit_element = ? AND "
       "signon_realm = ?"));
   if (!s) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
   s.BindString(0, form.origin.spec());
-  s.BindString(1, UTF16ToUTF8(form.username_element));
-  s.BindString(2, UTF16ToUTF8(form.username_value));
-  s.BindString(3, UTF16ToUTF8(form.password_element));
-  s.BindString(4, UTF16ToUTF8(form.submit_element));
+  s.BindString16(1, form.username_element);
+  s.BindString16(2, form.username_value);
+  s.BindString16(3, form.password_element);
+  s.BindString16(4, form.submit_element);
   s.BindString(5, form.signon_realm);
 
   if (!s.Run()) {
     NOTREACHED();
     return false;
   }
   return true;
 }
 
 bool WebDatabase::RemoveLoginsCreatedBetween(base::Time delete_begin,
@@ skipping 31 matching lines @@
 }
 
 static void InitPasswordFormFromStatement(PasswordForm* form,
                                           sql::Statement* s) {
   std::string tmp;
   string16 decrypted_password;
   tmp = s->ColumnString(0);
   form->origin = GURL(tmp);
   tmp = s->ColumnString(1);
   form->action = GURL(tmp);
-  form->username_element = UTF8ToUTF16(s->ColumnString(2));
-  form->username_value = UTF8ToUTF16(s->ColumnString(3));
-  form->password_element = UTF8ToUTF16(s->ColumnString(4));
+  form->username_element = s->ColumnString16(2);
+  form->username_value = s->ColumnString16(3);
+  form->password_element = s->ColumnString16(4);
 
   int encrypted_password_len = s->ColumnByteLength(5);
   std::string encrypted_password;
   if (encrypted_password_len) {
     encrypted_password.resize(encrypted_password_len);
     memcpy(&encrypted_password[0], s->ColumnBlob(5), encrypted_password_len);
     Encryptor::DecryptString16(encrypted_password, &decrypted_password);
   }
 
   form->password_value = decrypted_password;
-  form->submit_element = UTF8ToUTF16(s->ColumnString(6));
+  form->submit_element = s->ColumnString16(6);
   tmp = s->ColumnString(7);
   form->signon_realm = tmp;
   form->ssl_valid = (s->ColumnInt(8) > 0);
   form->preferred = (s->ColumnInt(9) > 0);
   form->date_created = Time::FromTimeT(s->ColumnInt64(10));
   form->blacklisted_by_user = (s->ColumnInt(11) > 0);
   int scheme_int = s->ColumnInt(12);
   DCHECK((scheme_int >= 0) && (scheme_int <= PasswordForm::SCHEME_OTHER));
   form->scheme = static_cast<PasswordForm::Scheme>(scheme_int);
 }
@@ skipping 97 matching lines @@
     int64* pair_id,
     int* count) {
   sql::Statement s(db_.GetUniqueStatement(
       "SELECT pair_id, count FROM autofill "
       "WHERE name = ? AND value = ?"));
   if (!s) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
-  s.BindString(0, UTF16ToUTF8(element.name()));
-  s.BindString(1, UTF16ToUTF8(element.value()));
+  s.BindString16(0, element.name());
+  s.BindString16(1, element.value());
 
   *count = 0;
 
   if (s.Step()) {
     *pair_id = s.ColumnInt64(0);
     *count = s.ColumnInt(1);
   }
 
   return true;
 }
@@ skipping 25 matching lines @@
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
   bool first_entry = true;
   AutofillKey* current_key_ptr = NULL;
   std::vector<base::Time>* timestamps_ptr = NULL;
   string16 name, value;
   base::Time time;
   while (s.Step()) {
-    name = UTF8ToUTF16(s.ColumnString(0));
-    value = UTF8ToUTF16(s.ColumnString(1));
+    name = s.ColumnString16(0);
+    value = s.ColumnString16(1);
     time = Time::FromTimeT(s.ColumnInt64(2));
 
     if (first_entry) {
       current_key_ptr = new AutofillKey(name, value);
 
       timestamps_ptr = new std::vector<base::Time>;
       timestamps_ptr->push_back(time);
 
       first_entry = false;
     } else {
@@ skipping 31 matching lines @@
   sql::Statement s(db_.GetUniqueStatement(
       "SELECT date_created FROM autofill a JOIN "
       "autofill_dates ad ON a.pair_id=ad.pair_id "
       "WHERE a.name = ? AND a.value = ?"));
 
   if (!s) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
-  s.BindString(0, UTF16ToUTF8(name));
-  s.BindString(1, UTF16ToUTF8(value));
+  s.BindString16(0, name);
+  s.BindString16(1, value);
   while (s.Step()) {
     timestamps->push_back(Time::FromTimeT(s.ColumnInt64(0)));
   }
 
   return s.Succeeded();
 }
 
 bool WebDatabase::UpdateAutofillEntries(
     const std::vector<AutofillEntry>& entries) {
   if (!entries.size())
     return true;
 
   // Remove all existing entries.
   for (size_t i = 0; i < entries.size(); i++) {
     std::string sql = "SELECT pair_id FROM autofill "
                       "WHERE name = ? AND value = ?";
     sql::Statement s(db_.GetUniqueStatement(sql.c_str()));
     if (!s.is_valid()) {
       NOTREACHED() << "Statement prepare failed";
       return false;
     }
 
-    s.BindString(0, UTF16ToUTF8(entries[i].key().name()));
-    s.BindString(1, UTF16ToUTF8(entries[i].key().value()));
+    s.BindString16(0, entries[i].key().name());
+    s.BindString16(1, entries[i].key().value());
     if (s.Step()) {
       if (!RemoveFormElementForID(s.ColumnInt64(0)))
         return false;
     }
   }
 
   // Insert all the supplied autofill entries.
   for (size_t i = 0; i < entries.size(); i++) {
     if (!InsertAutofillEntry(entries[i]))
       return false;
   }
 
   return true;
 }
 
 bool WebDatabase::InsertAutofillEntry(const AutofillEntry& entry) {
   std::string sql = "INSERT INTO autofill (name, value, value_lower, count) "
                     "VALUES (?, ?, ?, ?)";
   sql::Statement s(db_.GetUniqueStatement(sql.c_str()));
   if (!s.is_valid()) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
-  s.BindString(0, UTF16ToUTF8(entry.key().name()));
-  s.BindString(1, UTF16ToUTF8(entry.key().value()));
-  s.BindString(2, UTF16ToUTF8(l10n_util::ToLower(entry.key().value())));
+  s.BindString16(0, entry.key().name());
+  s.BindString16(1, entry.key().value());
+  s.BindString16(2, l10n_util::ToLower(entry.key().value()));
   s.BindInt(3, entry.timestamps().size());
 
   if (!s.Run()) {
     NOTREACHED();
     return false;
   }
 
   int64 pair_id = db_.GetLastInsertRowId();
   for (size_t i = 0; i < entry.timestamps().size(); i++) {
     if (!InsertPairIDAndDate(pair_id, entry.timestamps()[i]))
       return false;
   }
 
   return true;
 }
 
 bool WebDatabase::InsertFormElement(const FormField& element,
                                     int64* pair_id) {
   sql::Statement s(db_.GetUniqueStatement(
       "INSERT INTO autofill (name, value, value_lower) VALUES (?,?,?)"));
   if (!s) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
-  s.BindString(0, UTF16ToUTF8(element.name()));
-  s.BindString(1, UTF16ToUTF8(element.value()));
-  s.BindString(2, UTF16ToUTF8(l10n_util::ToLower(element.value())));
+  s.BindString16(0, element.name());
+  s.BindString16(1, element.value());
+  s.BindString16(2, l10n_util::ToLower(element.value()));
 
   if (!s.Run()) {
     NOTREACHED();
     return false;
   }
 
   *pair_id = db_.GetLastInsertRowId();
   return true;
 }
 
@@ skipping 78 matching lines @@
     s.Assign(db_.GetUniqueStatement(
         "SELECT value FROM autofill "
         "WHERE name = ? "
         "ORDER BY count DESC "
         "LIMIT ?"));
     if (!s) {
       NOTREACHED() << "Statement prepare failed";
       return false;
     }
 
-    s.BindString(0, UTF16ToUTF8(name));
+    s.BindString16(0, name);
     s.BindInt(1, limit);
   } else {
     string16 prefix_lower = l10n_util::ToLower(prefix);
     string16 next_prefix = prefix_lower;
     next_prefix[next_prefix.length() - 1]++;
 
     s.Assign(db_.GetUniqueStatement(
         "SELECT value FROM autofill "
         "WHERE name = ? AND "
         "value_lower >= ? AND "
         "value_lower < ? "
         "ORDER BY count DESC "
         "LIMIT ?"));
     if (!s) {
       NOTREACHED() << "Statement prepare failed";
       return false;
     }
 
-    s.BindString(0, UTF16ToUTF8(name));
-    s.BindString(1, UTF16ToUTF8(prefix_lower));
-    s.BindString(2, UTF16ToUTF8(next_prefix));
+    s.BindString16(0, name);
+    s.BindString16(1, prefix_lower);
+    s.BindString16(2, next_prefix);
     s.BindInt(3, limit);
   }
 
   values->clear();
   while (s.Step())
-    values->push_back(UTF8ToUTF16(s.ColumnString(0)));
+    values->push_back(s.ColumnString16(0));
   return s.Succeeded();
 }
 
 bool WebDatabase::RemoveFormElementsAddedBetween(
     base::Time delete_begin,
     base::Time delete_end,
     std::vector<AutofillChange>* changes) {
   DCHECK(changes);
   // Query for the pair_id, name, and value of all form elements that
   // were used between the given times.
   sql::Statement s(db_.GetUniqueStatement(
       "SELECT DISTINCT a.pair_id, a.name, a.value "
       "FROM autofill_dates ad JOIN autofill a ON ad.pair_id = a.pair_id "
       "WHERE ad.date_created >= ? AND ad.date_created < ?"));
   if (!s) {
     NOTREACHED() << "Statement 1 prepare failed";
     return false;
   }
   s.BindInt64(0, delete_begin.ToTimeT());
   s.BindInt64(1,
               delete_end.is_null() ?
                   std::numeric_limits<int64>::max() :
                   delete_end.ToTimeT());
 
   AutofillElementList elements;
-  while (s.Step())
+  while (s.Step()) {
     elements.push_back(MakeTuple(s.ColumnInt64(0),
-                                 UTF8ToUTF16(s.ColumnString(1)),
-                                 UTF8ToUTF16(s.ColumnString(2))));
+                                 s.ColumnString16(1),
+                                 s.ColumnString16(2)));
+  }
 
   if (!s.Succeeded()) {
     NOTREACHED();
     return false;
   }
 
   for (AutofillElementList::iterator itr = elements.begin();
-       itr != elements.end();
-       itr++) {
+       itr != elements.end(); itr++) {
     int how_many = 0;
     if (!RemoveFormElementForTimeRange(itr->a, delete_begin, delete_end,
                                        &how_many)) {
       return false;
     }
     bool was_removed = false;
     if (!AddToCountOfFormElement(itr->a, -how_many, &was_removed))
       return false;
     AutofillChange::Type change_type =
         was_removed ? AutofillChange::REMOVE : AutofillChange::UPDATE;
@@ skipping 29 matching lines @@
 
 bool WebDatabase::RemoveFormElement(const string16& name,
                                     const string16& value) {
   // Find the id for that pair.
   sql::Statement s(db_.GetUniqueStatement(
       "SELECT pair_id FROM autofill WHERE  name = ? AND value= ?"));
   if (!s) {
     NOTREACHED() << "Statement 1 prepare failed";
     return false;
   }
-  s.BindString(0, UTF16ToUTF8(name));
-  s.BindString(1, UTF16ToUTF8(value));
+  s.BindString16(0, name);
+  s.BindString16(1, value);
 
   if (s.Step())
     return RemoveFormElementForID(s.ColumnInt64(0));
   return false;
 }
 
 static void BindAutoFillProfileToStatement(const AutoFillProfile& profile,
                                            sql::Statement* s) {
-  s->BindString(0, UTF16ToUTF8(profile.Label()));
+  s->BindString16(0, profile.Label());
   s->BindInt(1, profile.unique_id());
 
   string16 text = profile.GetFieldText(AutoFillType(NAME_FIRST));
-  s->BindString(2, UTF16ToUTF8(text));
+  s->BindString16(2, text);
   text = profile.GetFieldText(AutoFillType(NAME_MIDDLE));
-  s->BindString(3, UTF16ToUTF8(text));
+  s->BindString16(3, text);
   text = profile.GetFieldText(AutoFillType(NAME_LAST));
-  s->BindString(4, UTF16ToUTF8(text));
+  s->BindString16(4, text);
   text = profile.GetFieldText(AutoFillType(EMAIL_ADDRESS));
-  s->BindString(5, UTF16ToUTF8(text));
+  s->BindString16(5, text);
   text = profile.GetFieldText(AutoFillType(COMPANY_NAME));
-  s->BindString(6, UTF16ToUTF8(text));
+  s->BindString16(6, text);
   text = profile.GetFieldText(AutoFillType(ADDRESS_HOME_LINE1));
-  s->BindString(7, UTF16ToUTF8(text));
+  s->BindString16(7, text);
   text = profile.GetFieldText(AutoFillType(ADDRESS_HOME_LINE2));
-  s->BindString(8, UTF16ToUTF8(text));
+  s->BindString16(8, text);
   text = profile.GetFieldText(AutoFillType(ADDRESS_HOME_CITY));
-  s->BindString(9, UTF16ToUTF8(text));
+  s->BindString16(9, text);
   text = profile.GetFieldText(AutoFillType(ADDRESS_HOME_STATE));
-  s->BindString(10, UTF16ToUTF8(text));
+  s->BindString16(10, text);
   text = profile.GetFieldText(AutoFillType(ADDRESS_HOME_ZIP));
-  s->BindString(11, UTF16ToUTF8(text));
+  s->BindString16(11, text);
   text = profile.GetFieldText(AutoFillType(ADDRESS_HOME_COUNTRY));
-  s->BindString(12, UTF16ToUTF8(text));
+  s->BindString16(12, text);
   text = profile.GetFieldText(AutoFillType(PHONE_HOME_WHOLE_NUMBER));
-  s->BindString(13, UTF16ToUTF8(text));
+  s->BindString16(13, text);
   text = profile.GetFieldText(AutoFillType(PHONE_FAX_WHOLE_NUMBER));
-  s->BindString(14, UTF16ToUTF8(text));
+  s->BindString16(14, text);
 }
 
 bool WebDatabase::AddAutoFillProfile(const AutoFillProfile& profile) {
   sql::Statement s(db_.GetUniqueStatement(
       "INSERT INTO autofill_profiles"
       "(label, unique_id, first_name, middle_name, last_name, email,"
       " company_name, address_line_1, address_line_2, city, state, zipcode,"
       " country, phone, fax)"
       "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"));
   if (!s) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
   BindAutoFillProfileToStatement(profile, &s);
 
   if (!s.Run()) {
     NOTREACHED();
     return false;
   }
 
   return s.Succeeded();
 }
 
 static AutoFillProfile* AutoFillProfileFromStatement(const sql::Statement& s) {
   AutoFillProfile* profile = new AutoFillProfile(
-      UTF8ToUTF16(s.ColumnString(0)), s.ColumnInt(1));
+      s.ColumnString16(0), s.ColumnInt(1));
   profile->SetInfo(AutoFillType(NAME_FIRST),
-                   UTF8ToUTF16(s.ColumnString(2)));
+                   s.ColumnString16(2));
   profile->SetInfo(AutoFillType(NAME_MIDDLE),
-                   UTF8ToUTF16(s.ColumnString(3)));
+                   s.ColumnString16(3));
   profile->SetInfo(AutoFillType(NAME_LAST),
-                   UTF8ToUTF16(s.ColumnString(4)));
+                   s.ColumnString16(4));
   profile->SetInfo(AutoFillType(EMAIL_ADDRESS),
-                   UTF8ToUTF16(s.ColumnString(5)));
+                   s.ColumnString16(5));
   profile->SetInfo(AutoFillType(COMPANY_NAME),
-                   UTF8ToUTF16(s.ColumnString(6)));
+                   s.ColumnString16(6));
   profile->SetInfo(AutoFillType(ADDRESS_HOME_LINE1),
-                   UTF8ToUTF16(s.ColumnString(7)));
+                   s.ColumnString16(7));
   profile->SetInfo(AutoFillType(ADDRESS_HOME_LINE2),
-                   UTF8ToUTF16(s.ColumnString(8)));
+                   s.ColumnString16(8));
   profile->SetInfo(AutoFillType(ADDRESS_HOME_CITY),
-                   UTF8ToUTF16(s.ColumnString(9)));
+                   s.ColumnString16(9));
   profile->SetInfo(AutoFillType(ADDRESS_HOME_STATE),
-                   UTF8ToUTF16(s.ColumnString(10)));
+                   s.ColumnString16(10));
   profile->SetInfo(AutoFillType(ADDRESS_HOME_ZIP),
-                   UTF8ToUTF16(s.ColumnString(11)));
+                   s.ColumnString16(11));
   profile->SetInfo(AutoFillType(ADDRESS_HOME_COUNTRY),
-                   UTF8ToUTF16(s.ColumnString(12)));
+                   s.ColumnString16(12));
   profile->SetInfo(AutoFillType(PHONE_HOME_WHOLE_NUMBER),
-                   UTF8ToUTF16(s.ColumnString(13)));
+                   s.ColumnString16(13));
   profile->SetInfo(AutoFillType(PHONE_FAX_WHOLE_NUMBER),
-                   UTF8ToUTF16(s.ColumnString(14)));
+                   s.ColumnString16(14));
 
   return profile;
 }
 
 bool WebDatabase::GetAutoFillProfileForLabel(const string16& label,
                                              AutoFillProfile** profile) {
   DCHECK(profile);
   sql::Statement s(db_.GetUniqueStatement(
       "SELECT * FROM autofill_profiles "
       "WHERE label = ?"));
   if (!s) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
-  s.BindString(0, UTF16ToUTF8(label));
+  s.BindString16(0, label);
   if (!s.Step())
     return false;
 
   *profile = AutoFillProfileFromStatement(s);
 
   return s.Succeeded();
 }
 
 bool WebDatabase::GetAutoFillProfiles(
     std::vector<AutoFillProfile*>* profiles) {
@@ skipping 57 matching lines @@
 
   s.BindInt(0, profile_id);
   if (s.Step())
     *profile = AutoFillProfileFromStatement(s);
 
   return s.Succeeded();
 }
 
 static void BindCreditCardToStatement(const CreditCard& credit_card,
                                       sql::Statement* s) {
-  s->BindString(0, UTF16ToUTF8(credit_card.Label()));
+  s->BindString16(0, credit_card.Label());
   s->BindInt(1, credit_card.unique_id());
 
   string16 text = credit_card.GetFieldText(AutoFillType(CREDIT_CARD_NAME));
-  s->BindString(2, UTF16ToUTF8(text));
+  s->BindString16(2, text);
   text = credit_card.GetFieldText(AutoFillType(CREDIT_CARD_TYPE));
-  s->BindString(3, UTF16ToUTF8(text));
+  s->BindString16(3, text);
   text.clear();  // No unencrypted cc info.
-  s->BindString(4, UTF16ToUTF8(text));
+  s->BindString16(4, text);
   text = credit_card.GetFieldText(AutoFillType(CREDIT_CARD_EXP_MONTH));
-  s->BindString(5, UTF16ToUTF8(text));
+  s->BindString16(5, text);
   text = credit_card.GetFieldText(AutoFillType(CREDIT_CARD_EXP_4_DIGIT_YEAR));
-  s->BindString(6, UTF16ToUTF8(text));
+  s->BindString16(6, text);
   text.clear();
-  s->BindString(7, UTF16ToUTF8(text));
-  s->BindString(8, UTF16ToUTF8(credit_card.billing_address()));
-  s->BindString(9, UTF16ToUTF8(credit_card.shipping_address()));
+  s->BindString16(7, text);
+  s->BindString16(8, credit_card.billing_address());
+  s->BindString16(9, credit_card.shipping_address());
   text = credit_card.GetFieldText(AutoFillType(CREDIT_CARD_NUMBER));
   std::string encrypted_data;
   Encryptor::EncryptString16(text, &encrypted_data);
   s->BindBlob(10, encrypted_data.data(),
               static_cast<int>(encrypted_data.length()));
   text = credit_card.GetFieldText(AutoFillType(CREDIT_CARD_VERIFICATION_CODE));
   Encryptor::EncryptString16(text, &encrypted_data);
   s->BindBlob(11, encrypted_data.data(),
               static_cast<int>(encrypted_data.length()));
 }
@@ skipping 16 matching lines @@
     NOTREACHED();
     return false;
   }
 
   DCHECK_GT(db_.GetLastChangeCount(), 0);
   return s.Succeeded();
 }
 
 static CreditCard* CreditCardFromStatement(const sql::Statement& s) {
   CreditCard* credit_card = new CreditCard(
-      UTF8ToUTF16(s.ColumnString(0)), s.ColumnInt(1));
+      s.ColumnString16(0), s.ColumnInt(1));
   credit_card->SetInfo(AutoFillType(CREDIT_CARD_NAME),
-                   UTF8ToUTF16(s.ColumnString(2)));
+                       s.ColumnString16(2));
   credit_card->SetInfo(AutoFillType(CREDIT_CARD_TYPE),
-                   UTF8ToUTF16(s.ColumnString(3)));
-  string16 credit_card_number = UTF8ToUTF16(s.ColumnString(4));
+                       s.ColumnString16(3));
+  string16 credit_card_number = s.ColumnString16(4);
   // It could be non-empty prior to version 23. After that it encrypted in
   // the column 10.
   if (credit_card_number.empty()) {
     int encrypted_cc_len = s.ColumnByteLength(10);
     std::string encrypted_cc;
     if (encrypted_cc_len) {
       encrypted_cc.resize(encrypted_cc_len);
       memcpy(&encrypted_cc[0], s.ColumnBlob(10), encrypted_cc_len);
       Encryptor::DecryptString16(encrypted_cc, &credit_card_number);
     }
   }
   credit_card->SetInfo(AutoFillType(CREDIT_CARD_NUMBER), credit_card_number);
   credit_card->SetInfo(AutoFillType(CREDIT_CARD_EXP_MONTH),
-                   UTF8ToUTF16(s.ColumnString(5)));
+                       s.ColumnString16(5));
   credit_card->SetInfo(AutoFillType(CREDIT_CARD_EXP_4_DIGIT_YEAR),
-                   UTF8ToUTF16(s.ColumnString(6)));
+                       s.ColumnString16(6));
 
-  string16 credit_card_verification_code = UTF8ToUTF16(s.ColumnString(7));
+  string16 credit_card_verification_code = s.ColumnString16(7);
   // It could be non-empty prior to version 23. After that it encrypted in
   // the column 11.
   if (credit_card_verification_code.empty()) {
     int encrypted_cc_len = s.ColumnByteLength(11);
     std::string encrypted_cc;
     if (encrypted_cc_len) {
       encrypted_cc.resize(encrypted_cc_len);
       memcpy(&encrypted_cc[0], s.ColumnBlob(11), encrypted_cc_len);
       Encryptor::DecryptString16(encrypted_cc, &credit_card_verification_code);
     }
   }
   credit_card->SetInfo(AutoFillType(CREDIT_CARD_VERIFICATION_CODE),
-                      credit_card_verification_code);
-  credit_card->set_billing_address(UTF8ToUTF16(s.ColumnString(8)));
-  credit_card->set_shipping_address(UTF8ToUTF16(s.ColumnString(9)));
+                       credit_card_verification_code);
+  credit_card->set_billing_address(s.ColumnString16(8));
+  credit_card->set_shipping_address(s.ColumnString16(9));
   // Column 10 is processed above.
   // Column 11 is processed above.
 
   return credit_card;
 }
 
 bool WebDatabase::GetCreditCardForLabel(const string16& label,
                                         CreditCard** credit_card) {
   DCHECK(credit_card);
   sql::Statement s(db_.GetUniqueStatement(
       "SELECT * FROM credit_cards "
       "WHERE label = ?"));
   if (!s) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
-  s.BindString(0, UTF16ToUTF8(label));
+  s.BindString16(0, label);
   if (!s.Step())
     return false;
 
   *credit_card = CreditCardFromStatement(s);
 
   return s.Succeeded();
 }
 
 bool WebDatabase::GetCreditCardForID(int credit_card_id,
                                      CreditCard** credit_card) {
@@ skipping 155 matching lines @@
 
     // Add successive versions here.  Each should set the version number and
     // compatible version number as appropriate, then fall through to the next
     // case.
 
     case kCurrentVersionNumber:
       // No migration needed.
       return;
   }
 }