Revert "Revert 223907 "[password generation] Upload possible account cre...""

chrome/browser/password_manager/login_database.cc

 // Copyright (c) 2012 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/password_manager/login_database.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "chrome/common/chrome_switches.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 using autofill::PasswordForm;
 
-static const int kCurrentVersionNumber = 3;
+static const int kCurrentVersionNumber = 4;
 static const int kCompatibleVersionNumber = 1;
 
 namespace {
 
 // Convenience enum for interacting with SQL queries that use all the columns.
 enum LoginTableColumns {
   COLUMN_ORIGIN_URL = 0,
   COLUMN_ACTION_URL,
   COLUMN_USERNAME_ELEMENT,
   COLUMN_USERNAME_VALUE,
   COLUMN_PASSWORD_ELEMENT,
   COLUMN_PASSWORD_VALUE,
   COLUMN_SUBMIT_ELEMENT,
   COLUMN_SIGNON_REALM,
   COLUMN_SSL_VALID,
   COLUMN_PREFERRED,
   COLUMN_DATE_CREATED,
   COLUMN_BLACKLISTED_BY_USER,
   COLUMN_SCHEME,
   COLUMN_PASSWORD_TYPE,
   COLUMN_POSSIBLE_USERNAMES,
-  COLUMN_TIMES_USED
+  COLUMN_TIMES_USED,
+  COLUMN_FORM_DATA
 };
 
 // Using the public suffix list for matching the origin is only needed for
 // websites that do not have a single hostname for entering credentials. It
 // would be better for their users if they did, but until then we help them find
 // credentials across different hostnames. We know that accounts.google.com is
 // the only hostname we should be accepting credentials on for any domain under
 // google.com, so we can apply a tighter policy for that domain.
 // For owners of domains where a single hostname is always used when your
 // users are entering their credentials, please contact palmer@chromium.org,
@@ skipping 119 matching lines @@
 
 bool LoginDatabase::MigrateOldVersionsAsNeeded() {
   switch (meta_table_.GetVersionNumber()) {
     case 1:
       if (!db_.Execute("ALTER TABLE logins "
                        "ADD COLUMN password_type INTEGER") ||
           !db_.Execute("ALTER TABLE logins "
                        "ADD COLUMN possible_usernames BLOB")) {
         return false;
       }
+      // Fall through.
     case 2:
-      if (!db_.Execute("ALTER TABLE logins "
-                       "ADD COLUMN times_used INTEGER")) {
+      if (!db_.Execute("ALTER TABLE logins ADD COLUMN times_used INTEGER")) {
         return false;
       }
-      break;
+      // Fall through.
+    case 3:
+      if (!db_.Execute("ALTER TABLE logins ADD COLUMN form_data BLOB")) {
+        return false;
+      }
+      // Fall through.
     case kCurrentVersionNumber:
       // Already up to date
       return true;
-      break;
     default:
       NOTREACHED();
       return false;
   }
   meta_table_.SetVersionNumber(kCurrentVersionNumber);
   return true;
 }
 
 bool LoginDatabase::InitLoginsTable() {
   if (!db_.DoesTableExist("logins")) {
     if (!db_.Execute("CREATE TABLE logins ("
                      "origin_url VARCHAR NOT NULL, "
                      "action_url VARCHAR, "
                      "username_element VARCHAR, "
                      "username_value VARCHAR, "
                      "password_element VARCHAR, "
                      "password_value BLOB, "
                      "submit_element VARCHAR, "
                      "signon_realm VARCHAR NOT NULL,"
                      "ssl_valid INTEGER NOT NULL,"
                      "preferred INTEGER NOT NULL,"
                      "date_created INTEGER NOT NULL,"
                      "blacklisted_by_user INTEGER NOT NULL,"
                      "scheme INTEGER NOT NULL,"
                      "password_type INTEGER,"
                      "possible_usernames BLOB,"
                      "times_used INTEGER,"
+                     "form_data BLOB,"
                      "UNIQUE "
                      "(origin_url, username_element, "
                      "username_value, password_element, "
                      "submit_element, signon_realm))")) {
       NOTREACHED();
       return false;
     }
     if (!db_.Execute("CREATE INDEX logins_signon ON "
                      "logins (signon_realm)")) {
       NOTREACHED();
@@ skipping 57 matching lines @@
   std::string encrypted_password;
   if (!EncryptedString(form.password_value, &encrypted_password))
     return false;
 
   // You *must* change LoginTableColumns if this query changes.
   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
       "INSERT OR REPLACE INTO logins "
       "(origin_url, action_url, username_element, username_value, "
       " password_element, password_value, submit_element, "
       " signon_realm, ssl_valid, preferred, date_created, blacklisted_by_user, "
-      " scheme, password_type, possible_usernames, times_used) "
+      " scheme, password_type, possible_usernames, times_used, form_data) "
       "VALUES "
-      "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
+      "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
   s.BindString(COLUMN_ORIGIN_URL, form.origin.spec());
   s.BindString(COLUMN_ACTION_URL, form.action.spec());
   s.BindString16(COLUMN_USERNAME_ELEMENT, form.username_element);
   s.BindString16(COLUMN_USERNAME_VALUE, form.username_value);
   s.BindString16(COLUMN_PASSWORD_ELEMENT, form.password_element);
   s.BindBlob(COLUMN_PASSWORD_VALUE, encrypted_password.data(),
               static_cast<int>(encrypted_password.length()));
   s.BindString16(COLUMN_SUBMIT_ELEMENT, form.submit_element);
   s.BindString(COLUMN_SIGNON_REALM, form.signon_realm);
   s.BindInt(COLUMN_SSL_VALID, form.ssl_valid);
   s.BindInt(COLUMN_PREFERRED, form.preferred);
   s.BindInt64(COLUMN_DATE_CREATED, form.date_created.ToTimeT());
   s.BindInt(COLUMN_BLACKLISTED_BY_USER, form.blacklisted_by_user);
   s.BindInt(COLUMN_SCHEME, form.scheme);
   s.BindInt(COLUMN_PASSWORD_TYPE, form.type);
-  Pickle pickle = SerializeVector(form.other_possible_usernames);
-  s.BindBlob(COLUMN_POSSIBLE_USERNAMES, pickle.data(), pickle.size());
+  Pickle usernames_pickle = SerializeVector(form.other_possible_usernames);
+  s.BindBlob(COLUMN_POSSIBLE_USERNAMES,
+             usernames_pickle.data(),
+             usernames_pickle.size());
   s.BindInt(COLUMN_TIMES_USED, form.times_used);
+  Pickle form_data_pickle;
+  autofill::SerializeFormData(form.form_data, &form_data_pickle);
+  s.BindBlob(COLUMN_FORM_DATA,
+             form_data_pickle.data(),
+             form_data_pickle.size());
 
   return s.Run();
 }
 
 bool LoginDatabase::UpdateLogin(const PasswordForm& form, int* items_changed) {
   std::string encrypted_password;
   if (!EncryptedString(form.password_value, &encrypted_password))
     return false;
 
   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
@@ skipping 92 matching lines @@
   DCHECK((scheme_int >= 0) && (scheme_int <= PasswordForm::SCHEME_OTHER));
   form->scheme = static_cast<PasswordForm::Scheme>(scheme_int);
   int type_int = s.ColumnInt(COLUMN_PASSWORD_TYPE);
   DCHECK(type_int >= 0 && type_int <= PasswordForm::TYPE_GENERATED);
   form->type = static_cast<PasswordForm::Type>(type_int);
   Pickle pickle(
       static_cast<const char*>(s.ColumnBlob(COLUMN_POSSIBLE_USERNAMES)),
       s.ColumnByteLength(COLUMN_POSSIBLE_USERNAMES));
   form->other_possible_usernames = DeserializeVector(pickle);
   form->times_used = s.ColumnInt(COLUMN_TIMES_USED);
+  Pickle form_data_pickle(
+      static_cast<const char*>(s.ColumnBlob(COLUMN_FORM_DATA)),
+      s.ColumnByteLength(COLUMN_FORM_DATA));
+  PickleIterator form_data_iter(form_data_pickle);
+  autofill::DeserializeFormData(&form_data_iter, &form->form_data);
   return true;
 }
 
 bool LoginDatabase::GetLogins(const PasswordForm& form,
                               std::vector<PasswordForm*>* forms) const {
   DCHECK(forms);
   // You *must* change LoginTableColumns if this query changes.
   const std::string sql_query = "SELECT origin_url, action_url, "
       "username_element, username_value, "
       "password_element, password_value, submit_element, "
       "signon_realm, ssl_valid, preferred, date_created, blacklisted_by_user, "
-      "scheme, password_type, possible_usernames, times_used "
+      "scheme, password_type, possible_usernames, times_used, form_data "
       "FROM logins WHERE signon_realm == ? ";
   sql::Statement s;
   const GURL signon_realm(form.signon_realm);
   std::string registered_domain = GetRegistryControlledDomain(signon_realm);
   if (public_suffix_domain_matching_ &&
       ShouldPSLDomainMatchingApply(registered_domain)) {
     // We are extending the original SQL query with one that includes more
     // possible matches based on public suffix domain matching. Using a regexp
     // here is just an optimization to not have to parse all the stored entries
     // in the |logins| table. The result (scheme, domain and port) is verified
@@ skipping 58 matching lines @@
 bool LoginDatabase::GetLoginsCreatedBetween(
     const base::Time begin,
     const base::Time end,
     std::vector<autofill::PasswordForm*>* forms) const {
   DCHECK(forms);
   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
       "SELECT origin_url, action_url, "
       "username_element, username_value, "
       "password_element, password_value, submit_element, "
       "signon_realm, ssl_valid, preferred, date_created, blacklisted_by_user, "
-      "scheme, password_type, possible_usernames, times_used "
+      "scheme, password_type, possible_usernames, times_used, form_data "
       "FROM logins WHERE date_created >= ? AND date_created < ?"
       "ORDER BY origin_url"));
   s.BindInt64(0, begin.ToTimeT());
   s.BindInt64(1, end.is_null() ? std::numeric_limits<int64>::max()
                                : end.ToTimeT());
 
   while (s.Step()) {
     scoped_ptr<PasswordForm> new_form(new PasswordForm());
     if (!InitPasswordFormFromStatement(new_form.get(), s))
       return false;
@@ skipping 14 matching lines @@
 
 bool LoginDatabase::GetAllLoginsWithBlacklistSetting(
     bool blacklisted, std::vector<PasswordForm*>* forms) const {
   DCHECK(forms);
   // You *must* change LoginTableColumns if this query changes.
   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
       "SELECT origin_url, action_url, "
       "username_element, username_value, "
       "password_element, password_value, submit_element, "
       "signon_realm, ssl_valid, preferred, date_created, blacklisted_by_user, "
-      "scheme, password_type, possible_usernames, times_used "
+      "scheme, password_type, possible_usernames, times_used, form_data "
       "FROM logins WHERE blacklisted_by_user == ? "
       "ORDER BY origin_url"));
   s.BindInt(0, blacklisted ? 1 : 0);
 
   while (s.Step()) {
     scoped_ptr<PasswordForm> new_form(new PasswordForm());
     if (!InitPasswordFormFromStatement(new_form.get(), s))
       return false;
     forms->push_back(new_form.release());
   }
@@ skipping 19 matching lines @@
 std::vector<string16> LoginDatabase::DeserializeVector(const Pickle& p) const {
   std::vector<string16> ret;
   string16 str;
 
   PickleIterator iterator(p);
   while (iterator.ReadString16(&str)) {
     ret.push_back(str);
   }
   return ret;
 }