Remove PasswordForm::ssl_valid

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 <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <limits>
@@ skipping 24 matching lines @@
 #include "sql/statement.h"
 #include "sql/transaction.h"
 #include "url/origin.h"
 #include "url/url_constants.h"
 
 using autofill::PasswordForm;
 
 namespace password_manager {
 
 // The current version number of the login database schema.
-const int kCurrentVersionNumber = 17;
+const int kCurrentVersionNumber = 18;
 // The oldest version of the schema such that a legacy Chrome client using that
 // version can still read/write the current database.
-const int kCompatibleVersionNumber = 14;
+const int kCompatibleVersionNumber = 18;
 
 base::Pickle SerializeVector(const std::vector<base::string16>& vec) {
   base::Pickle p;
   for (size_t i = 0; i < vec.size(); ++i) {
     p.WriteString16(vec[i]);
   }
   return p;
 }
 
 std::vector<base::string16> DeserializeVector(const base::Pickle& p) {
@@ skipping 12 matching lines @@
 // 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_FORM_DATA,
   COLUMN_DATE_SYNCED,
   COLUMN_DISPLAY_NAME,
@@ skipping 26 matching lines @@
                       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);
   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.ToInternalValue());
   s->BindInt(COLUMN_BLACKLISTED_BY_USER, form.blacklisted_by_user);
   s->BindInt(COLUMN_SCHEME, form.scheme);
   s->BindInt(COLUMN_PASSWORD_TYPE, form.type);
   base::Pickle usernames_pickle =
       SerializeVector(form.other_possible_usernames);
   s->BindBlob(COLUMN_POSSIBLE_USERNAMES,
               usernames_pickle.data(),
               usernames_pickle.size());
@@ skipping 280 matching lines @@
   DCHECK_EQ(14u, version);
 
   // Version 15.
   builder->SealVersion();
   // Version 16.
   builder->SealVersion();
   // Version 17.
   version = builder->SealVersion();
   DCHECK_EQ(17u, version);
 
+  // Version 18.
+  builder->DropColumn("ssl_valid");
+  version = builder->SealVersion();
+  DCHECK_EQ(18u, version);
+
   DCHECK_EQ(static_cast<size_t>(COLUMN_NUM), builder->NumberOfColumns())
       << "Adjust LoginTableColumns if you change column definitions here.";
 }
 
 // Call this after having called InitializeBuilder, to migrate the database from
 // the current version to kCurrentVersionNumber.
 bool MigrateLogins(unsigned current_version,
                    SQLTableBuilder* builder,
                    sql::Connection* db) {
   if (!builder->MigrateFrom(current_version, db))
@@ skipping 282 matching lines @@
                      "WHERE b.blacklisted_by_user=0 AND b.username_value!='' "
                      "AND a.signon_realm = b.signon_realm)"));
   if (standalone_empty_usernames_statement.Step()) {
     int num_entries = standalone_empty_usernames_statement.ColumnInt(0);
     UMA_HISTOGRAM_COUNTS_100(
         "PasswordManager.EmptyUsernames.WithoutCorrespondingNonempty",
         num_entries);
   }
 
   sql::Statement logins_with_schemes_statement(db_.GetUniqueStatement(
-      "SELECT signon_realm, origin_url, ssl_valid, blacklisted_by_user "
-      "FROM logins;"));
+      "SELECT signon_realm, origin_url, blacklisted_by_user FROM logins;"));
 
   if (!logins_with_schemes_statement.is_valid())
     return;
 
   int android_logins = 0;
   int ftp_logins = 0;
   int http_logins = 0;
   int https_logins = 0;
   int other_logins = 0;
 
   while (logins_with_schemes_statement.Step()) {
     std::string signon_realm = logins_with_schemes_statement.ColumnString(0);
     GURL origin_url = GURL(logins_with_schemes_statement.ColumnString(1));
-    bool ssl_valid = !!logins_with_schemes_statement.ColumnInt(2);
-    bool blacklisted_by_user = !!logins_with_schemes_statement.ColumnInt(3);
+    bool blacklisted_by_user = !!logins_with_schemes_statement.ColumnInt(2);
     if (blacklisted_by_user)
       continue;
 
     if (IsValidAndroidFacetURI(signon_realm)) {
       ++android_logins;
     } else if (origin_url.SchemeIs(url::kHttpsScheme)) {
       ++https_logins;
-      metrics_util::LogUMAHistogramBoolean(
-          "PasswordManager.UserStoredPasswordWithInvalidSSLCert", !ssl_valid);
     } else if (origin_url.SchemeIs(url::kHttpScheme)) {
       ++http_logins;
     } else if (origin_url.SchemeIs(url::kFtpScheme)) {
       ++ftp_logins;
     } else {
       ++other_logins;
     }
   }
 
   LogNumberOfAccountsForScheme("Android", android_logins);
@@ skipping 68 matching lines @@
 #endif
   // Replacement is necessary to deal with updating imported credentials. See
   // crbug.com/349138 for details.
   DCHECK(!update_statement_.empty());
   sql::Statement s(
       db_.GetCachedStatement(SQL_FROM_HERE, update_statement_.c_str()));
   s.BindString(0, form.action.spec());
   s.BindBlob(1, encrypted_password.data(),
              static_cast<int>(encrypted_password.length()));
   s.BindString16(2, form.submit_element);
-  s.BindInt(3, form.ssl_valid);
-  s.BindInt(4, form.preferred);
-  s.BindInt64(5, form.date_created.ToInternalValue());
-  s.BindInt(6, form.blacklisted_by_user);
-  s.BindInt(7, form.scheme);
-  s.BindInt(8, form.type);
+  s.BindInt(3, form.preferred);
+  s.BindInt64(4, form.date_created.ToInternalValue());
+  s.BindInt(5, form.blacklisted_by_user);
+  s.BindInt(6, form.scheme);
+  s.BindInt(7, form.type);
   base::Pickle pickle = SerializeVector(form.other_possible_usernames);
-  s.BindBlob(9, pickle.data(), pickle.size());
-  s.BindInt(10, form.times_used);
+  s.BindBlob(8, pickle.data(), pickle.size());
+  s.BindInt(9, form.times_used);
   base::Pickle form_data_pickle;
   autofill::SerializeFormData(form.form_data, &form_data_pickle);
-  s.BindBlob(11, form_data_pickle.data(), form_data_pickle.size());
-  s.BindInt64(12, form.date_synced.ToInternalValue());
-  s.BindString16(13, form.display_name);
-  s.BindString(14, form.icon_url.spec());
+  s.BindBlob(10, form_data_pickle.data(), form_data_pickle.size());
+  s.BindInt64(11, form.date_synced.ToInternalValue());
+  s.BindString16(12, form.display_name);
+  s.BindString(13, form.icon_url.spec());
   // An empty Origin serializes as "null" which would be strange to store here.
-  s.BindString(15, form.federation_origin.unique()
+  s.BindString(14, form.federation_origin.unique()
                        ? std::string()
                        : form.federation_origin.Serialize());
-  s.BindInt(16, form.skip_zero_click);
-  s.BindInt(17, form.generation_upload_status);
+  s.BindInt(15, form.skip_zero_click);
+  s.BindInt(16, form.generation_upload_status);
 
   // WHERE starts here.
-  s.BindString(18, form.origin.spec());
-  s.BindString16(19, form.username_element);
-  s.BindString16(20, form.username_value);
-  s.BindString16(21, form.password_element);
-  s.BindString(22, form.signon_realm);
+  s.BindString(17, form.origin.spec());
+  s.BindString16(18, form.username_element);
+  s.BindString16(19, form.username_value);
+  s.BindString16(20, form.password_element);
+  s.BindString(21, form.signon_realm);
 
   if (!s.Run())
     return PasswordStoreChangeList();
 
   PasswordStoreChangeList list;
   if (db_.GetLastChangeCount())
     list.push_back(PasswordStoreChange(PasswordStoreChange::UPDATE, form));
 
   return list;
 }
@@ skipping 92 matching lines @@
   form->origin = GURL(tmp);
   tmp = s.ColumnString(COLUMN_ACTION_URL);
   form->action = GURL(tmp);
   form->username_element = s.ColumnString16(COLUMN_USERNAME_ELEMENT);
   form->username_value = s.ColumnString16(COLUMN_USERNAME_VALUE);
   form->password_element = s.ColumnString16(COLUMN_PASSWORD_ELEMENT);
   form->password_value = decrypted_password;
   form->submit_element = s.ColumnString16(COLUMN_SUBMIT_ELEMENT);
   tmp = s.ColumnString(COLUMN_SIGNON_REALM);
   form->signon_realm = tmp;
-  form->ssl_valid = (s.ColumnInt(COLUMN_SSL_VALID) > 0);
   form->preferred = (s.ColumnInt(COLUMN_PREFERRED) > 0);
   form->date_created =
       base::Time::FromInternalValue(s.ColumnInt64(COLUMN_DATE_CREATED));
   form->blacklisted_by_user = (s.ColumnInt(COLUMN_BLACKLISTED_BY_USER) > 0);
   int scheme_int = s.ColumnInt(COLUMN_SCHEME);
   DCHECK_LE(0, scheme_int);
   DCHECK_GE(PasswordForm::SCHEME_LAST, scheme_int);
   form->scheme = static_cast<PasswordForm::Scheme>(scheme_int);
   int type_int = s.ColumnInt(COLUMN_PASSWORD_TYPE);
   DCHECK(type_int >= 0 && type_int <= PasswordForm::TYPE_LAST) << type_int;
@@ skipping 288 matching lines @@
   DCHECK(blacklisted_statement_.empty());
   blacklisted_statement_ =
       "SELECT " + all_column_names +
       " FROM logins WHERE blacklisted_by_user == ? ORDER BY origin_url";
   DCHECK(encrypted_statement_.empty());
   encrypted_statement_ =
       "SELECT password_value FROM logins WHERE " + all_unique_key_column_names;
 }
 
 }  // namespace password_manager