chrome/browser/password_manager/login_database.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/password_manager/login_database.h"
   6
   7 #include <algorithm>
   8 #include <limits>
   9
  10 #include "base/files/file_path.h"
  11 #include "base/logging.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/pickle.h"
  14 #include "base/strings/string_util.h"
  15 #include "base/time/time.h"
  16 #include "components/autofill/core/common/password_form.h"
  17 #include "sql/connection.h"
  18 #include "sql/statement.h"
  19 #include "sql/transaction.h"
  20
  21 using autofill::PasswordForm;
  22
  23 static const int kCurrentVersionNumber = 4;
  24 static const int kCompatibleVersionNumber = 1;
  25
  26 namespace {
  27
  28 // Convenience enum for interacting with SQL queries that use all the columns.
  29 enum LoginTableColumns {
  30   COLUMN_ORIGIN_URL = 0,
  31   COLUMN_ACTION_URL,
  32   COLUMN_USERNAME_ELEMENT,
  33   COLUMN_USERNAME_VALUE,
  34   COLUMN_PASSWORD_ELEMENT,
  35   COLUMN_PASSWORD_VALUE,
  36   COLUMN_SUBMIT_ELEMENT,
  37   COLUMN_SIGNON_REALM,
  38   COLUMN_SSL_VALID,
  39   COLUMN_PREFERRED,
  40   COLUMN_DATE_CREATED,
  41   COLUMN_BLACKLISTED_BY_USER,
  42   COLUMN_SCHEME,
  43   COLUMN_PASSWORD_TYPE,
  44   COLUMN_POSSIBLE_USERNAMES,
  45   COLUMN_TIMES_USED,
  46   COLUMN_FORM_DATA
  47 };
  48
  49 }  // namespace
  50
  51 LoginDatabase::LoginDatabase() {
  52 }
  53
  54 LoginDatabase::~LoginDatabase() {
  55 }
  56
  57 bool LoginDatabase::Init(const base::FilePath& db_path) {
  58   // Set pragmas for a small, private database (based on WebDatabase).
  59   db_.set_page_size(2048);
  60   db_.set_cache_size(32);
  61   db_.set_exclusive_locking();
  62   db_.set_restrict_to_user();
  63
  64   if (!db_.Open(db_path)) {
  65     LOG(WARNING) << "Unable to open the password store database.";
  66     return false;
  67   }
  68
  69   sql::Transaction transaction(&db_);
  70   transaction.Begin();
  71
  72   // Check the database version.
  73   if (!meta_table_.Init(&db_, kCurrentVersionNumber,
  74                         kCompatibleVersionNumber)) {
  75     db_.Close();
  76     return false;
  77   }
  78   if (meta_table_.GetCompatibleVersionNumber() > kCurrentVersionNumber) {
  79     LOG(WARNING) << "Password store database is too new.";
  80     db_.Close();
  81     return false;
  82   }
  83
  84   // Initialize the tables.
  85   if (!InitLoginsTable()) {
  86     LOG(WARNING) << "Unable to initialize the password store database.";
  87     db_.Close();
  88     return false;
  89   }
  90
  91   // Save the path for DeleteDatabaseFile().
  92   db_path_ = db_path;
  93
  94   // If the file on disk is an older database version, bring it up to date.
  95   if (!MigrateOldVersionsAsNeeded()) {
  96     LOG(WARNING) << "Unable to migrate database";
  97     db_.Close();
  98     return false;
  99   }
 100
 101   if (!transaction.Commit()) {
 102     db_.Close();
 103     return false;
 104   }
 105
 106   return true;
 107 }
 108
 109 bool LoginDatabase::MigrateOldVersionsAsNeeded() {
 110   switch (meta_table_.GetVersionNumber()) {
 111     case 1:
 112       if (!db_.Execute("ALTER TABLE logins "
 113                        "ADD COLUMN password_type INTEGER") ||
 114           !db_.Execute("ALTER TABLE logins "
 115                        "ADD COLUMN possible_usernames BLOB")) {
 116         return false;
 117       }
 118       meta_table_.SetVersionNumber(2);
 119       // Fall through.
 120     case 2:
 121       if (!db_.Execute("ALTER TABLE logins ADD COLUMN times_used INTEGER")) {
 122         return false;
 123       }
 124       meta_table_.SetVersionNumber(3);
 125       // Fall through.
 126     case 3:
 127       // We need to check if the column exists because of
 128       // https://crbug.com/295851
 129       if (!db_.DoesColumnExist("logins", "form_data") &&
 130           !db_.Execute("ALTER TABLE logins ADD COLUMN form_data BLOB")) {
 131         return false;
 132       }
 133       meta_table_.SetVersionNumber(4);
 134       // Fall through.
 135     case kCurrentVersionNumber:
 136       // Already up to date
 137       return true;
 138     default:
 139       NOTREACHED();
 140       return false;
 141   }
 142 }
 143
 144 bool LoginDatabase::InitLoginsTable() {
 145   if (!db_.DoesTableExist("logins")) {
 146     if (!db_.Execute("CREATE TABLE logins ("
 147                      "origin_url VARCHAR NOT NULL, "
 148                      "action_url VARCHAR, "
 149                      "username_element VARCHAR, "
 150                      "username_value VARCHAR, "
 151                      "password_element VARCHAR, "
 152                      "password_value BLOB, "
 153                      "submit_element VARCHAR, "
 154                      "signon_realm VARCHAR NOT NULL,"
 155                      "ssl_valid INTEGER NOT NULL,"
 156                      "preferred INTEGER NOT NULL,"
 157                      "date_created INTEGER NOT NULL,"
 158                      "blacklisted_by_user INTEGER NOT NULL,"
 159                      "scheme INTEGER NOT NULL,"
 160                      "password_type INTEGER,"
 161                      "possible_usernames BLOB,"
 162                      "times_used INTEGER,"
 163                      "form_data BLOB,"
 164                      "UNIQUE "
 165                      "(origin_url, username_element, "
 166                      "username_value, password_element, "
 167                      "submit_element, signon_realm))")) {
 168       NOTREACHED();
 169       return false;
 170     }
 171     if (!db_.Execute("CREATE INDEX logins_signon ON "
 172                      "logins (signon_realm)")) {
 173       NOTREACHED();
 174       return false;
 175     }
 176   }
 177   return true;
 178 }
 179
 180 void LoginDatabase::ReportMetrics() {
 181   sql::Statement s(db_.GetCachedStatement(
 182       SQL_FROM_HERE,
 183       "SELECT signon_realm, blacklisted_by_user, COUNT(username_value) "
 184       "FROM logins GROUP BY signon_realm, blacklisted_by_user"));
 185
 186   if (!s.is_valid())
 187     return;
 188
 189   int total_accounts = 0;
 190   int blacklisted_sites = 0;
 191   while (s.Step()) {
 192     int blacklisted = s.ColumnInt(1);
 193     int accounts_per_site = s.ColumnInt(2);
 194     if (blacklisted) {
 195       ++blacklisted_sites;
 196     } else {
 197       total_accounts += accounts_per_site;
 198       UMA_HISTOGRAM_CUSTOM_COUNTS("PasswordManager.AccountsPerSite",
 199                                   accounts_per_site, 0, 32, 6);
 200     }
 201   }
 202   UMA_HISTOGRAM_CUSTOM_COUNTS("PasswordManager.TotalAccounts",
 203                               total_accounts, 0, 32, 6);
 204   UMA_HISTOGRAM_CUSTOM_COUNTS("PasswordManager.BlacklistedSites",
 205                               blacklisted_sites, 0, 32, 6);
 206
 207   sql::Statement usage_statement(db_.GetCachedStatement(
 208       SQL_FROM_HERE,
 209       "SELECT password_type, times_used FROM logins"));
 210
 211   if (!usage_statement.is_valid())
 212     return;
 213
 214   while (usage_statement.Step()) {
 215     PasswordForm::Type type = static_cast<PasswordForm::Type>(
 216         usage_statement.ColumnInt(0));
 217
 218     if (type == PasswordForm::TYPE_GENERATED) {
 219       UMA_HISTOGRAM_CUSTOM_COUNTS(
 220           "PasswordManager.TimesGeneratedPasswordUsed",
 221           usage_statement.ColumnInt(1), 0, 100, 10);
 222     } else {
 223       UMA_HISTOGRAM_CUSTOM_COUNTS(
 224           "PasswordManager.TimesPasswordUsed",
 225           usage_statement.ColumnInt(1), 0, 100, 10);
 226     }
 227   }
 228 }
 229
 230 bool LoginDatabase::AddLogin(const PasswordForm& form) {
 231   std::string encrypted_password;
 232   if (EncryptedString(form.password_value, &encrypted_password) !=
 233           ENCRYPTION_RESULT_SUCCESS)
 234     return false;
 235
 236   // You *must* change LoginTableColumns if this query changes.
 237   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
 238       "INSERT OR REPLACE INTO logins "
 239       "(origin_url, action_url, username_element, username_value, "
 240       " password_element, password_value, submit_element, "
 241       " signon_realm, ssl_valid, preferred, date_created, blacklisted_by_user, "
 242       " scheme, password_type, possible_usernames, times_used, form_data) "
 243       "VALUES "
 244       "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
 245   s.BindString(COLUMN_ORIGIN_URL, form.origin.spec());
 246   s.BindString(COLUMN_ACTION_URL, form.action.spec());
 247   s.BindString16(COLUMN_USERNAME_ELEMENT, form.username_element);
 248   s.BindString16(COLUMN_USERNAME_VALUE, form.username_value);
 249   s.BindString16(COLUMN_PASSWORD_ELEMENT, form.password_element);
 250   s.BindBlob(COLUMN_PASSWORD_VALUE, encrypted_password.data(),
 251               static_cast<int>(encrypted_password.length()));
 252   s.BindString16(COLUMN_SUBMIT_ELEMENT, form.submit_element);
 253   s.BindString(COLUMN_SIGNON_REALM, form.signon_realm);
 254   s.BindInt(COLUMN_SSL_VALID, form.ssl_valid);
 255   s.BindInt(COLUMN_PREFERRED, form.preferred);
 256   s.BindInt64(COLUMN_DATE_CREATED, form.date_created.ToTimeT());
 257   s.BindInt(COLUMN_BLACKLISTED_BY_USER, form.blacklisted_by_user);
 258   s.BindInt(COLUMN_SCHEME, form.scheme);
 259   s.BindInt(COLUMN_PASSWORD_TYPE, form.type);
 260   Pickle usernames_pickle = SerializeVector(form.other_possible_usernames);
 261   s.BindBlob(COLUMN_POSSIBLE_USERNAMES,
 262              usernames_pickle.data(),
 263              usernames_pickle.size());
 264   s.BindInt(COLUMN_TIMES_USED, form.times_used);
 265   Pickle form_data_pickle;
 266   autofill::SerializeFormData(form.form_data, &form_data_pickle);
 267   s.BindBlob(COLUMN_FORM_DATA,
 268              form_data_pickle.data(),
 269              form_data_pickle.size());
 270
 271   return s.Run();
 272 }
 273
 274 bool LoginDatabase::UpdateLogin(const PasswordForm& form, int* items_changed) {
 275   std::string encrypted_password;
 276   if (EncryptedString(form.password_value, &encrypted_password) !=
 277           ENCRYPTION_RESULT_SUCCESS)
 278     return false;
 279
 280   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
 281       "UPDATE logins SET "
 282       "action_url = ?, "
 283       "password_value = ?, "
 284       "ssl_valid = ?, "
 285       "preferred = ?, "
 286       "possible_usernames = ?, "
 287       "times_used = ? "
 288       "WHERE origin_url = ? AND "
 289       "username_element = ? AND "
 290       "username_value = ? AND "
 291       "password_element = ? AND "
 292       "signon_realm = ?"));
 293   s.BindString(0, form.action.spec());
 294   s.BindBlob(1, encrypted_password.data(),
 295              static_cast<int>(encrypted_password.length()));
 296   s.BindInt(2, form.ssl_valid);
 297   s.BindInt(3, form.preferred);
 298   Pickle pickle = SerializeVector(form.other_possible_usernames);
 299   s.BindBlob(4, pickle.data(), pickle.size());
 300   s.BindInt(5, form.times_used);
 301   s.BindString(6, form.origin.spec());
 302   s.BindString16(7, form.username_element);
 303   s.BindString16(8, form.username_value);
 304   s.BindString16(9, form.password_element);
 305   s.BindString(10, form.signon_realm);
 306
 307   if (!s.Run())
 308     return false;
 309
 310   if (items_changed)
 311     *items_changed = db_.GetLastChangeCount();
 312
 313   return true;
 314 }
 315
 316 bool LoginDatabase::RemoveLogin(const PasswordForm& form) {
 317   // Remove a login by UNIQUE-constrained fields.
 318   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
 319       "DELETE FROM logins WHERE "
 320       "origin_url = ? AND "
 321       "username_element = ? AND "
 322       "username_value = ? AND "
 323       "password_element = ? AND "
 324       "submit_element = ? AND "
 325       "signon_realm = ? "));
 326   s.BindString(0, form.origin.spec());
 327   s.BindString16(1, form.username_element);
 328   s.BindString16(2, form.username_value);
 329   s.BindString16(3, form.password_element);
 330   s.BindString16(4, form.submit_element);
 331   s.BindString(5, form.signon_realm);
 332
 333   return s.Run();
 334 }
 335
 336 bool LoginDatabase::RemoveLoginsCreatedBetween(const base::Time delete_begin,
 337                                                const base::Time delete_end) {
 338   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
 339       "DELETE FROM logins WHERE "
 340       "date_created >= ? AND date_created < ?"));
 341   s.BindInt64(0, delete_begin.ToTimeT());
 342   s.BindInt64(1, delete_end.is_null() ? std::numeric_limits<int64>::max()
 343                                       : delete_end.ToTimeT());
 344
 345   return s.Run();
 346 }
 347
 348 LoginDatabase::EncryptionResult LoginDatabase::InitPasswordFormFromStatement(
 349     PasswordForm* form,
 350     sql::Statement& s) const {
 351   std::string encrypted_password;
 352   s.ColumnBlobAsString(COLUMN_PASSWORD_VALUE, &encrypted_password);
 353   base::string16 decrypted_password;
 354   EncryptionResult encryption_result =
 355       DecryptedString(encrypted_password, &decrypted_password);
 356   if (encryption_result != ENCRYPTION_RESULT_SUCCESS)
 357     return encryption_result;
 358
 359   std::string tmp = s.ColumnString(COLUMN_ORIGIN_URL);
 360   form->origin = GURL(tmp);
 361   tmp = s.ColumnString(COLUMN_ACTION_URL);
 362   form->action = GURL(tmp);
 363   form->username_element = s.ColumnString16(COLUMN_USERNAME_ELEMENT);
 364   form->username_value = s.ColumnString16(COLUMN_USERNAME_VALUE);
 365   form->password_element = s.ColumnString16(COLUMN_PASSWORD_ELEMENT);
 366   form->password_value = decrypted_password;
 367   form->submit_element = s.ColumnString16(COLUMN_SUBMIT_ELEMENT);
 368   tmp = s.ColumnString(COLUMN_SIGNON_REALM);
 369   form->signon_realm = tmp;
 370   form->ssl_valid = (s.ColumnInt(COLUMN_SSL_VALID) > 0);
 371   form->preferred = (s.ColumnInt(COLUMN_PREFERRED) > 0);
 372   form->date_created = base::Time::FromTimeT(
 373       s.ColumnInt64(COLUMN_DATE_CREATED));
 374   form->blacklisted_by_user = (s.ColumnInt(COLUMN_BLACKLISTED_BY_USER) > 0);
 375   int scheme_int = s.ColumnInt(COLUMN_SCHEME);
 376   DCHECK((scheme_int >= 0) && (scheme_int <= PasswordForm::SCHEME_OTHER));
 377   form->scheme = static_cast<PasswordForm::Scheme>(scheme_int);
 378   int type_int = s.ColumnInt(COLUMN_PASSWORD_TYPE);
 379   DCHECK(type_int >= 0 && type_int <= PasswordForm::TYPE_GENERATED);
 380   form->type = static_cast<PasswordForm::Type>(type_int);
 381   Pickle pickle(
 382       static_cast<const char*>(s.ColumnBlob(COLUMN_POSSIBLE_USERNAMES)),
 383       s.ColumnByteLength(COLUMN_POSSIBLE_USERNAMES));
 384   form->other_possible_usernames = DeserializeVector(pickle);
 385   form->times_used = s.ColumnInt(COLUMN_TIMES_USED);
 386   Pickle form_data_pickle(
 387       static_cast<const char*>(s.ColumnBlob(COLUMN_FORM_DATA)),
 388       s.ColumnByteLength(COLUMN_FORM_DATA));
 389   PickleIterator form_data_iter(form_data_pickle);
 390   autofill::DeserializeFormData(&form_data_iter, &form->form_data);
 391   return ENCRYPTION_RESULT_SUCCESS;
 392 }
 393
 394 bool LoginDatabase::GetLogins(const PasswordForm& form,
 395                               std::vector<PasswordForm*>* forms) const {
 396   DCHECK(forms);
 397   // You *must* change LoginTableColumns if this query changes.
 398   const std::string sql_query = "SELECT origin_url, action_url, "
 399       "username_element, username_value, "
 400       "password_element, password_value, submit_element, "
 401       "signon_realm, ssl_valid, preferred, date_created, blacklisted_by_user, "
 402       "scheme, password_type, possible_usernames, times_used, form_data "
 403       "FROM logins WHERE signon_realm == ? ";
 404   sql::Statement s;
 405   const GURL signon_realm(form.signon_realm);
 406   std::string registered_domain =
 407       PSLMatchingHelper::GetRegistryControlledDomain(signon_realm);
 408   PSLMatchingHelper::PSLDomainMatchMetric psl_domain_match_metric =
 409       PSLMatchingHelper::PSL_DOMAIN_MATCH_NONE;
 410   if (psl_helper_.ShouldPSLDomainMatchingApply(registered_domain)) {
 411     // We are extending the original SQL query with one that includes more
 412     // possible matches based on public suffix domain matching. Using a regexp
 413     // here is just an optimization to not have to parse all the stored entries
 414     // in the |logins| table. The result (scheme, domain and port) is verified
 415     // further down using GURL. See the functions SchemeMatches,
 416     // RegistryControlledDomainMatches and PortMatches.
 417     const std::string extended_sql_query =
 418         sql_query + "OR signon_realm REGEXP ? ";
 419     // TODO(nyquist) Re-enable usage of GetCachedStatement when
 420     // http://crbug.com/248608 is fixed.
 421     s.Assign(db_.GetUniqueStatement(extended_sql_query.c_str()));
 422     // We need to escape . in the domain. Since the domain has already been
 423     // sanitized using GURL, we do not need to escape any other characters.
 424     base::ReplaceChars(registered_domain, ".", "\\.", &registered_domain);
 425     std::string scheme = signon_realm.scheme();
 426     // We need to escape . in the scheme. Since the scheme has already been
 427     // sanitized using GURL, we do not need to escape any other characters.
 428     // The scheme soap.beep is an example with '.'.
 429     base::ReplaceChars(scheme, ".", "\\.", &scheme);
 430     const std::string port = signon_realm.port();
 431     // For a signon realm such as http://foo.bar/, this regexp will match
 432     // domains on the form http://foo.bar/, http://www.foo.bar/,
 433     // http://www.mobile.foo.bar/. It will not match http://notfoo.bar/.
 434     // The scheme and port has to be the same as the observed form.
 435     std::string regexp = "^(" + scheme + ":\\/\\/)([\\w-]+\\.)*" +
 436                          registered_domain + "(:" + port + ")?\\/$";
 437     s.BindString(0, form.signon_realm);
 438     s.BindString(1, regexp);
 439   } else {
 440     psl_domain_match_metric = PSLMatchingHelper::PSL_DOMAIN_MATCH_DISABLED;
 441     s.Assign(db_.GetCachedStatement(SQL_FROM_HERE, sql_query.c_str()));
 442     s.BindString(0, form.signon_realm);
 443   }
 444
 445   while (s.Step()) {
 446     scoped_ptr<PasswordForm> new_form(new PasswordForm());
 447     EncryptionResult result = InitPasswordFormFromStatement(new_form.get(), s);
 448     if (result == ENCRYPTION_RESULT_SERVICE_FAILURE)
 449       return false;
 450     if (result == ENCRYPTION_RESULT_ITEM_FAILURE)
 451       continue;
 452     DCHECK(result == ENCRYPTION_RESULT_SUCCESS);
 453     if (psl_helper_.IsMatchingEnabled()) {
 454       if (!PSLMatchingHelper::IsPublicSuffixDomainMatch(new_form->signon_realm,
 455                                                          form.signon_realm)) {
 456         // The database returned results that should not match. Skipping result.
 457         continue;
 458       }
 459       if (form.signon_realm != new_form->signon_realm) {
 460         psl_domain_match_metric = PSLMatchingHelper::PSL_DOMAIN_MATCH_FOUND;
 461         // This is not a perfect match, so we need to create a new valid result.
 462         // We do this by copying over origin, signon realm and action from the
 463         // observed form and setting the original signon realm to what we found
 464         // in the database. We use the fact that |original_signon_realm| is
 465         // non-empty to communicate that this match was found using public
 466         // suffix matching.
 467         new_form->original_signon_realm = new_form->signon_realm;
 468         new_form->origin = form.origin;
 469         new_form->signon_realm = form.signon_realm;
 470         new_form->action = form.action;
 471       }
 472     }
 473     forms->push_back(new_form.release());
 474   }
 475   UMA_HISTOGRAM_ENUMERATION("PasswordManager.PslDomainMatchTriggering",
 476                             psl_domain_match_metric,
 477                             PSLMatchingHelper::PSL_DOMAIN_MATCH_COUNT);
 478   return s.Succeeded();
 479 }
 480
 481 bool LoginDatabase::GetLoginsCreatedBetween(
 482     const base::Time begin,
 483     const base::Time end,
 484     std::vector<autofill::PasswordForm*>* forms) const {
 485   DCHECK(forms);
 486   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
 487       "SELECT origin_url, action_url, "
 488       "username_element, username_value, "
 489       "password_element, password_value, submit_element, "
 490       "signon_realm, ssl_valid, preferred, date_created, blacklisted_by_user, "
 491       "scheme, password_type, possible_usernames, times_used, form_data "
 492       "FROM logins WHERE date_created >= ? AND date_created < ?"
 493       "ORDER BY origin_url"));
 494   s.BindInt64(0, begin.ToTimeT());
 495   s.BindInt64(1, end.is_null() ? std::numeric_limits<int64>::max()
 496                                : end.ToTimeT());
 497
 498   while (s.Step()) {
 499     scoped_ptr<PasswordForm> new_form(new PasswordForm());
 500     EncryptionResult result = InitPasswordFormFromStatement(new_form.get(), s);
 501     if (result == ENCRYPTION_RESULT_SERVICE_FAILURE)
 502       return false;
 503     if (result == ENCRYPTION_RESULT_ITEM_FAILURE)
 504       continue;
 505     DCHECK(result == ENCRYPTION_RESULT_SUCCESS);
 506     forms->push_back(new_form.release());
 507   }
 508   return s.Succeeded();
 509 }
 510
 511 bool LoginDatabase::GetAutofillableLogins(
 512     std::vector<PasswordForm*>* forms) const {
 513   return GetAllLoginsWithBlacklistSetting(false, forms);
 514 }
 515
 516 bool LoginDatabase::GetBlacklistLogins(
 517     std::vector<PasswordForm*>* forms) const {
 518   return GetAllLoginsWithBlacklistSetting(true, forms);
 519 }
 520
 521 bool LoginDatabase::GetAllLoginsWithBlacklistSetting(
 522     bool blacklisted, std::vector<PasswordForm*>* forms) const {
 523   DCHECK(forms);
 524   // You *must* change LoginTableColumns if this query changes.
 525   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
 526       "SELECT origin_url, action_url, "
 527       "username_element, username_value, "
 528       "password_element, password_value, submit_element, "
 529       "signon_realm, ssl_valid, preferred, date_created, blacklisted_by_user, "
 530       "scheme, password_type, possible_usernames, times_used, form_data "
 531       "FROM logins WHERE blacklisted_by_user == ? "
 532       "ORDER BY origin_url"));
 533   s.BindInt(0, blacklisted ? 1 : 0);
 534
 535   while (s.Step()) {
 536     scoped_ptr<PasswordForm> new_form(new PasswordForm());
 537     EncryptionResult result = InitPasswordFormFromStatement(new_form.get(), s);
 538     if (result == ENCRYPTION_RESULT_SERVICE_FAILURE)
 539       return false;
 540     if (result == ENCRYPTION_RESULT_ITEM_FAILURE)
 541       continue;
 542     DCHECK(result == ENCRYPTION_RESULT_SUCCESS);
 543     forms->push_back(new_form.release());
 544   }
 545   return s.Succeeded();
 546 }
 547
 548 bool LoginDatabase::DeleteAndRecreateDatabaseFile() {
 549   DCHECK(db_.is_open());
 550   meta_table_.Reset();
 551   db_.Close();
 552   sql::Connection::Delete(db_path_);
 553   return Init(db_path_);
 554 }
 555
 556 Pickle LoginDatabase::SerializeVector(
 557     const std::vector<base::string16>& vec) const {
 558   Pickle p;
 559   for (size_t i = 0; i < vec.size(); ++i) {
 560     p.WriteString16(vec[i]);
 561   }
 562   return p;
 563 }
 564
 565 std::vector<base::string16> LoginDatabase::DeserializeVector(
 566     const Pickle& p) const {
 567   std::vector<base::string16> ret;
 568   base::string16 str;
 569
 570   PickleIterator iterator(p);
 571   while (iterator.ReadString16(&str)) {
 572     ret.push_back(str);
 573   }
 574   return ret;
 575 }