Rename PasswordForm::is_zero_click to PasswordForm::skip_next_zero_click.

components/password_manager/core/browser/login_database.cc

 // Copyright 2014 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 "components/password_manager/core/browser/login_database.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.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/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/password_manager/core/browser/password_manager_client.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 using autofill::PasswordForm;
 
 namespace password_manager {
 
-const int kCurrentVersionNumber = 10;
+const int kCurrentVersionNumber = 11;
 static const int kCompatibleVersionNumber = 1;
 
 Pickle SerializeVector(const std::vector<base::string16>& vec) {
   Pickle p;
   for (size_t i = 0; i < vec.size(); ++i) {
     p.WriteString16(vec[i]);
   }
   return p;
 }
 
@@ skipping 26 matching lines @@
   COLUMN_BLACKLISTED_BY_USER,
   COLUMN_SCHEME,
   COLUMN_PASSWORD_TYPE,
   COLUMN_POSSIBLE_USERNAMES,
   COLUMN_TIMES_USED,
   COLUMN_FORM_DATA,
   COLUMN_DATE_SYNCED,
   COLUMN_DISPLAY_NAME,
   COLUMN_AVATAR_URL,
   COLUMN_FEDERATION_URL,
-  COLUMN_IS_ZERO_CLICK,
+  COLUMN_SKIP_ZERO_CLICK,
 };
 
 void BindAddStatement(const PasswordForm& form,
                       const std::string& encrypted_password,
                       sql::Statement* s) {
   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);
@@ skipping 14 matching lines @@
   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());
   s->BindInt64(COLUMN_DATE_SYNCED, form.date_synced.ToInternalValue());
   s->BindString16(COLUMN_DISPLAY_NAME, form.display_name);
   s->BindString(COLUMN_AVATAR_URL, form.avatar_url.spec());
   s->BindString(COLUMN_FEDERATION_URL, form.federation_url.spec());
-  s->BindInt(COLUMN_IS_ZERO_CLICK, form.is_zero_click);
+  s->BindInt(COLUMN_SKIP_ZERO_CLICK, form.skip_zero_click);
 }
 
 void AddCallback(int err, sql::Statement* /*stmt*/) {
   if (err == 19 /*SQLITE_CONSTRAINT*/)
     DLOG(WARNING) << "LoginDatabase::AddLogin updated an existing form";
 }
 
 bool DoesMatchConstraints(const PasswordForm& form) {
   if (form.origin.is_empty()) {
     DLOG(ERROR) << "Constraint violation: form.origin is empty";
@@ skipping 20 matching lines @@
 }
 
 void LogAccountStat(const std::string& name, int sample) {
   LogDynamicUMAStat(name, sample, 0, 32, 6);
 }
 
 void LogTimesUsedStat(const std::string& name, int sample) {
   LogDynamicUMAStat(name, sample, 0, 100, 10);
 }
 
+// Creates a table named |table_name| using our current schema.
+bool CreateNewTable(sql::Connection* db, const char* table_name) {
+  std::string query = base::StringPrintf(
+      "CREATE TABLE %s ("
+      "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,"
+      "date_synced INTEGER,"
+      "display_name VARCHAR,"
+      "avatar_url VARCHAR,"
+      "federation_url VARCHAR,"
+      "skip_zero_click INTEGER,"
+      "UNIQUE (origin_url, username_element, username_value, "
+      "password_element, signon_realm))", table_name);
+  return db->Execute(query.c_str());
+}
+
+bool CreateIndexOnSignonRealm(sql::Connection* db, const char* table_name) {
+  std::string query = base::StringPrintf(
+      "CREATE INDEX logins_signon ON %s (signon_realm)", table_name);
+  return db->Execute(query.c_str());
+}
+
 }  // namespace
 
 LoginDatabase::LoginDatabase(const base::FilePath& db_path)
     : db_path_(db_path) {
 }
 
 LoginDatabase::~LoginDatabase() {
 }
 
 bool LoginDatabase::Init() {
@@ skipping 130 matching lines @@
       };
 
       if (!db_.Execute(("CREATE TEMPORARY TABLE logins_data(" + fields_to_copy +
                         ")").c_str()) ||
           !db_.Execute(copy_data_query("logins", "logins_data").c_str()) ||
           !db_.Execute("DROP TABLE logins") ||
           !db_.Execute(
               ("CREATE TABLE logins(" + fields_to_copy + ")").c_str()) ||
           !db_.Execute(copy_data_query("logins_data", "logins").c_str()) ||
           !db_.Execute("DROP TABLE logins_data") ||
-          !db_.Execute("CREATE INDEX logins_signon ON logins (signon_realm)"))
+          !CreateIndexOnSignonRealm(&db_, "logins"))
         return false;
 
       meta_table_.SetVersionNumber(10);
     }
+    case 10: {
+      // rename is_zero_click -> skip_zero_click and restore the unique key
+      // (origin_url, username_element, username_value, password_element,
+      // signon_realm).
+      const char copy_query[] = "INSERT OR REPLACE INTO logins_new 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, form_data, "
+          "date_synced, display_name, avatar_url, federation_url, is_zero_click"
+          " FROM logins";
+      if (!CreateNewTable(&db_, "logins_new") ||
+          !db_.Execute(copy_query) ||
+          !db_.Execute("DROP TABLE logins") ||
+          !db_.Execute("ALTER TABLE logins_new RENAME TO logins") ||
+          !CreateIndexOnSignonRealm(&db_, "logins"))
+        return false;
+      meta_table_.SetVersionNumber(11);
+    }
     case kCurrentVersionNumber:
       // Already up to date
       return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 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,"
-            "date_synced INTEGER,"
-            "display_name VARCHAR,"
-            "avatar_url VARCHAR,"
-            "federation_url VARCHAR,"
-            "is_zero_click INTEGER,"
-            "UNIQUE "
-            "(origin_url, username_element, "
-            "username_value, password_element, "
-            "submit_element, signon_realm))")) {
+    if (!CreateNewTable(&db_, "logins")) {
       NOTREACHED();
       return false;
     }
-    if (!db_.Execute("CREATE INDEX logins_signon ON "
-                     "logins (signon_realm)")) {
+    if (!CreateIndexOnSignonRealm(&db_, "logins")) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 void LoginDatabase::ReportMetrics(const std::string& sync_username,
                                   bool custom_passphrase_sync_enabled) {
   sql::Statement s(db_.GetCachedStatement(
@@ skipping 105 matching lines @@
 
   // You *must* change LoginTableColumns if this query changes.
   sql::Statement s(db_.GetCachedStatement(
       SQL_FROM_HERE,
       "INSERT 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, form_data, "
       " date_synced, display_name, avatar_url,"
-      " federation_url, is_zero_click) VALUES "
+      " federation_url, skip_zero_click) VALUES "
       "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
   BindAddStatement(form, encrypted_password, &s);
   db_.set_error_callback(base::Bind(&AddCallback));
   const bool success = s.Run();
   db_.reset_error_callback();
   if (success) {
     list.push_back(PasswordStoreChange(PasswordStoreChange::ADD, form));
     return list;
   }
   // Repeat the same statement but with REPLACE semantic.
   s.Assign(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, form_data, "
       " date_synced, display_name, avatar_url,"
-      " federation_url, is_zero_click) VALUES "
+      " federation_url, skip_zero_click) VALUES "
       "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
   BindAddStatement(form, encrypted_password, &s);
   if (s.Run()) {
     list.push_back(PasswordStoreChange(PasswordStoreChange::REMOVE, form));
     list.push_back(PasswordStoreChange(PasswordStoreChange::ADD, form));
   }
   return list;
 }
 
 PasswordStoreChangeList LoginDatabase::UpdateLogin(const PasswordForm& form) {
@@ skipping 14 matching lines @@
                                           "times_used = ?, "
                                           "submit_element = ?, "
                                           "date_synced = ?, "
                                           "date_created = ?, "
                                           "blacklisted_by_user = ?, "
                                           "scheme = ?, "
                                           "password_type = ?, "
                                           "display_name = ?, "
                                           "avatar_url = ?, "
                                           "federation_url = ?, "
-                                          "is_zero_click = ? "
+                                          "skip_zero_click = ? "
                                           "WHERE origin_url = ? AND "
                                           "username_element = ? AND "
                                           "username_value = ? AND "
                                           "password_element = ? AND "
                                           "signon_realm = ?"));
   s.BindString(0, form.action.spec());
   s.BindBlob(1, encrypted_password.data(),
              static_cast<int>(encrypted_password.length()));
   s.BindInt(2, form.ssl_valid);
   s.BindInt(3, form.preferred);
   Pickle pickle = SerializeVector(form.other_possible_usernames);
   s.BindBlob(4, pickle.data(), pickle.size());
   s.BindInt(5, form.times_used);
   s.BindString16(6, form.submit_element);
   s.BindInt64(7, form.date_synced.ToInternalValue());
   s.BindInt64(8, form.date_created.ToInternalValue());
   s.BindInt(9, form.blacklisted_by_user);
   s.BindInt(10, form.scheme);
   s.BindInt(11, form.type);
   s.BindString16(12, form.display_name);
   s.BindString(13, form.avatar_url.spec());
   s.BindString(14, form.federation_url.spec());
-  s.BindInt(15, form.is_zero_click);
+  s.BindInt(15, form.skip_zero_click);
 
   // WHERE starts here.
   s.BindString(16, form.origin.spec());
   s.BindString16(17, form.username_element);
   s.BindString16(18, form.username_value);
   s.BindString16(19, form.password_element);
   s.BindString(20, form.signon_realm);
 
   if (!s.Run())
     return PasswordStoreChangeList();
@@ skipping 100 matching lines @@
         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);
   }
   form->date_synced =
       base::Time::FromInternalValue(s.ColumnInt64(COLUMN_DATE_SYNCED));
   form->display_name = s.ColumnString16(COLUMN_DISPLAY_NAME);
   form->avatar_url = GURL(s.ColumnString(COLUMN_AVATAR_URL));
   form->federation_url = GURL(s.ColumnString(COLUMN_FEDERATION_URL));
-  form->is_zero_click = (s.ColumnInt(COLUMN_IS_ZERO_CLICK) > 0);
+  form->skip_zero_click = (s.ColumnInt(COLUMN_SKIP_ZERO_CLICK) > 0);
   return ENCRYPTION_RESULT_SUCCESS;
 }
 
 bool LoginDatabase::GetLogins(
     const PasswordForm& form,
     ScopedVector<autofill::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, form_data, "
       "date_synced, display_name, avatar_url, "
-      "federation_url, is_zero_click FROM logins WHERE signon_realm == ? ";
+      "federation_url, skip_zero_click "
+      "FROM logins WHERE signon_realm == ? ";
   sql::Statement s;
   const GURL signon_realm(form.signon_realm);
   std::string registered_domain = GetRegistryControlledDomain(signon_realm);
   PSLDomainMatchMetric psl_domain_match_metric = PSL_DOMAIN_MATCH_NONE;
   const bool should_PSL_matching_apply =
       form.scheme == PasswordForm::SCHEME_HTML &&
       ShouldPSLDomainMatchingApply(registered_domain);
   // PSL matching only applies to HTML forms.
   if (should_PSL_matching_apply) {
     // We are extending the original SQL query with one that includes more
@@ skipping 76 matching lines @@
     ScopedVector<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, form_data, "
       "date_synced, display_name, avatar_url, "
-      "federation_url, is_zero_click FROM logins "
+      "federation_url, skip_zero_click FROM logins "
       "WHERE date_created >= ? AND date_created < ?"
       "ORDER BY origin_url"));
   s.BindInt64(0, begin.ToInternalValue());
   s.BindInt64(1, end.is_null() ? std::numeric_limits<int64>::max()
                                : end.ToInternalValue());
 
   while (s.Step()) {
     scoped_ptr<PasswordForm> new_form(new PasswordForm());
     EncryptionResult result = InitPasswordFormFromStatement(new_form.get(), s);
     if (result == ENCRYPTION_RESULT_SERVICE_FAILURE)
@@ skipping 11 matching lines @@
     const base::Time end,
     ScopedVector<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, form_data, "
       "date_synced, display_name, avatar_url, "
-      "federation_url, is_zero_click FROM logins "
+      "federation_url, skip_zero_click FROM logins "
       "WHERE date_synced >= ? AND date_synced < ?"
       "ORDER BY origin_url"));
   s.BindInt64(0, begin.ToInternalValue());
   s.BindInt64(1,
               end.is_null() ? base::Time::Max().ToInternalValue()
                             : end.ToInternalValue());
 
   while (s.Step()) {
     scoped_ptr<PasswordForm> new_form(new PasswordForm());
     EncryptionResult result = InitPasswordFormFromStatement(new_form.get(), s);
@@ skipping 23 matching lines @@
   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, form_data, "
       "date_synced, display_name, avatar_url, "
-      "federation_url, is_zero_click FROM logins "
+      "federation_url, skip_zero_click 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());
     EncryptionResult result = InitPasswordFormFromStatement(new_form.get(), s);
     if (result == ENCRYPTION_RESULT_SERVICE_FAILURE)
       return false;
     if (result == ENCRYPTION_RESULT_ITEM_FAILURE)
       continue;
     DCHECK(result == ENCRYPTION_RESULT_SUCCESS);
     forms->push_back(new_form.release());
   }
   return s.Succeeded();
 }
 
 bool LoginDatabase::DeleteAndRecreateDatabaseFile() {
   DCHECK(db_.is_open());
   meta_table_.Reset();
   db_.Close();
   sql::Connection::Delete(db_path_);
   return Init();
 }
 
 }  // namespace password_manager