Convert encryptor.cc and friends to string16.

chrome/browser/webdata/web_database.cc

 // 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.
 
 #include "chrome/browser/webdata/web_database.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 100 matching lines @@
 // Keys used in the meta table.
 static const char* kDefaultSearchProviderKey = "Default Search Provider ID";
 static const char* kBuiltinKeywordVersion = "Builtin Keyword Version";
 
 std::string JoinStrings(const std::string& separator,
                         const std::vector<std::string>& strings) {
   if (strings.empty())
     return std::string();
   std::vector<std::string>::const_iterator i(strings.begin());
   std::string result(*i);
-  while(++i != strings.end())
+  while (++i != strings.end())
     result += separator + *i;
   return result;
 }
 
 WebDatabase::WebDatabase() : db_(NULL), transaction_nesting_(0) {
 }
 
 WebDatabase::~WebDatabase() {
   if (db_) {
     DCHECK(transaction_nesting_ == 0) <<
@@ skipping 502 matching lines @@
                 "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)") != SQLITE_OK) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
   s.bind_string(0, form.origin.spec());
   s.bind_string(1, form.action.spec());
   s.bind_wstring(2, form.username_element);
   s.bind_wstring(3, form.username_value);
   s.bind_wstring(4, form.password_element);
-  Encryptor::EncryptWideString(form.password_value, &encrypted_password);
+  Encryptor::EncryptString16(WideToUTF16Hack(form.password_value),
+                             &encrypted_password);
   s.bind_blob(5, encrypted_password.data(),
               static_cast<int>(encrypted_password.length()));
   s.bind_wstring(6, form.submit_element);
   s.bind_string(7, form.signon_realm);
   s.bind_int(8, form.ssl_valid);
   s.bind_int(9, form.preferred);
   s.bind_int64(10, form.date_created.ToTimeT());
   s.bind_int(11, form.blacklisted_by_user);
   s.bind_int(12, form.scheme);
   if (s.step() != SQLITE_DONE) {
@@ skipping 14 matching lines @@
                 "WHERE origin_url = ? AND "
                 "username_element = ? AND "
                 "username_value = ? AND "
                 "password_element = ? AND "
                 "signon_realm = ?") != SQLITE_OK) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
   s.bind_string(0, form.action.spec());
-  Encryptor::EncryptWideString(form.password_value, &encrypted_password);
+  Encryptor::EncryptString16(WideToUTF16Hack(form.password_value),
+                             &encrypted_password);
   s.bind_blob(1, encrypted_password.data(),
               static_cast<int>(encrypted_password.length()));
   s.bind_int(2, form.ssl_valid);
   s.bind_int(3, form.preferred);
   s.bind_string(4, form.origin.spec());
   s.bind_wstring(5, form.username_element);
   s.bind_wstring(6, form.username_value);
   s.bind_wstring(7, form.password_element);
   s.bind_string(8, form.signon_realm);
 
@@ skipping 60 matching lines @@
                     std::numeric_limits<int64>::max() :
                     delete_end.ToTimeT());
 
   return s1.step() == SQLITE_DONE && s2.step() == SQLITE_DONE;
 }
 
 static void InitPasswordFormFromStatement(PasswordForm* form,
                                           SQLStatement* s) {
   std::string encrypted_password;
   std::string tmp;
+  string16 decrypted_password;
   s->column_string(0, &tmp);
   form->origin = GURL(tmp);
   s->column_string(1, &tmp);
   form->action = GURL(tmp);
   s->column_wstring(2, &form->username_element);
   s->column_wstring(3, &form->username_value);
   s->column_wstring(4, &form->password_element);
   s->column_blob_as_string(5, &encrypted_password);
-  Encryptor::DecryptWideString(encrypted_password, &form->password_value);
+  Encryptor::DecryptString16(encrypted_password, &decrypted_password);
+  form->password_value = UTF16ToWideHack(decrypted_password);
   s->column_wstring(6, &form->submit_element);
   s->column_string(7, &tmp);
   form->signon_realm = tmp;
   form->ssl_valid = (s->column_int(8) > 0);
   form->preferred = (s->column_int(9) > 0);
   form->date_created = Time::FromTimeT(s->column_int64(10));
   form->blacklisted_by_user = (s->column_int(11) > 0);
   int scheme_int = s->column_int(12);
   DCHECK((scheme_int >= 0) && (scheme_int <= PasswordForm::SCHEME_OTHER));
   form->scheme = static_cast<PasswordForm::Scheme>(scheme_int);
@@ skipping 77 matching lines @@
   }
 
   std::set<int64> ids;
   int result;
   while ((result = s.step()) == SQLITE_ROW)
     ids.insert(s.column_int64(0));
 
   bool success = true;
   for (std::set<int64>::const_iterator iter = ids.begin(); iter != ids.end();
        ++iter) {
-    if (!RemoveFormElement(*iter)) 
+    if (!RemoveFormElement(*iter))
       success = false;
   }
-  
+
   return success;
 }
 
 bool WebDatabase::GetIDAndCountOfFormElement(
     const AutofillForm::Element& element, int64* pair_id, int* count) {
   SQLStatement s;
 
   if (s.prepare(db_, "SELECT pair_id, count FROM autofill "
                      " WHERE name = ? AND value = ?") != SQLITE_OK) {
     NOTREACHED() << "Statement prepare failed";
@@ skipping 172 matching lines @@
 bool WebDatabase::RemoveFormElementsAddedBetween(const Time delete_begin,
                                                  const Time delete_end) {
   SQLStatement s;
   if (s.prepare(db_,
                 "SELECT DISTINCT pair_id FROM autofill_dates WHERE "
                 "date_created >= ? AND date_created < ?") != SQLITE_OK) {
     NOTREACHED() << "Statement 1 prepare failed";
     return false;
   }
   s.bind_int64(0, delete_begin.ToTimeT());
-  s.bind_int64(1, 
+  s.bind_int64(1,
                delete_end.is_null() ?
                    std::numeric_limits<int64>::max() :
                    delete_end.ToTimeT());
 
   std::vector<int64> pair_ids;
   int result;
   while ((result = s.step()) == SQLITE_ROW)
     pair_ids.push_back(s.column_int64(0));
 
   if (result != SQLITE_DONE) {
@@ skipping 33 matching lines @@
                                          delete_end.ToTimeT());
 
   bool result = (s.step() == SQLITE_DONE);
   if (how_many)
     *how_many = sqlite3_changes(db_);
 
   return result;
 }
 
 bool WebDatabase::AddToCountOfFormElement(int64 pair_id, int delta) {
-  int count=0;
+  int count = 0;
 
   if (!GetCountOfFormElement(pair_id, &count))
     return false;
 
   if (count + delta == 0) {
     if (!RemoveFormElement(pair_id))
       return false;
   } else {
     if (!SetCountOfFormElement(pair_id, count + delta))
       return false;
@@ skipping 11 matching lines @@
   s.bind_int64(0, pair_id);
   if (s.step() != SQLITE_DONE)
     return false;
 
   return RemoveFormElementForTimeRange(pair_id, Time(), Time(), NULL);
 }
 
 void WebDatabase::MigrateOldVersionsAsNeeded() {
   // Migrate if necessary.
   int current_version = meta_table_.GetVersionNumber();
-  switch(current_version) {
+  switch (current_version) {
     // Versions 1 - 19 are unhandled.  Version numbers greater than
     // kCurrentVersionNumber should have already been weeded out by the caller.
     default:
       // When the version is too old, we just try to continue anyway.  There
       // should not be a released product that makes a database too old for us
       // to handle.
       LOG(WARNING) << "Web database version " << current_version <<
           " is too old to handle.";
       return;
 
@@ skipping 22 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;
   }
 }