Remove PasswordForm::ssl_valid

components/password_manager/content/browser/credential_manager_impl_unittest.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/content/browser/credential_manager_impl.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <tuple>
@@ skipping 206 matching lines @@
     NavigateAndCommit(GURL("https://example.com/test.html"));
 
     form_.username_value = base::ASCIIToUTF16("Username");
     form_.display_name = base::ASCIIToUTF16("Display Name");
     form_.icon_url = GURL("https://example.com/icon.png");
     form_.password_value = base::ASCIIToUTF16("Password");
     form_.origin = web_contents()->GetLastCommittedURL().GetOrigin();
     form_.signon_realm = form_.origin.spec();
     form_.scheme = autofill::PasswordForm::SCHEME_HTML;
     form_.skip_zero_click = false;
-    form_.ssl_valid = true;
 
     affiliated_form1_.username_value = base::ASCIIToUTF16("Affiliated 1");
     affiliated_form1_.display_name = base::ASCIIToUTF16("Display Name");
     affiliated_form1_.password_value = base::ASCIIToUTF16("Password");
     affiliated_form1_.origin = GURL();
     affiliated_form1_.signon_realm = kTestAndroidRealm1;
     affiliated_form1_.scheme = autofill::PasswordForm::SCHEME_HTML;
     affiliated_form1_.skip_zero_click = false;
-    affiliated_form1_.ssl_valid = true;
 
     affiliated_form2_.username_value = base::ASCIIToUTF16("Affiliated 2");
     affiliated_form2_.display_name = base::ASCIIToUTF16("Display Name");
     affiliated_form2_.password_value = base::ASCIIToUTF16("Password");
     affiliated_form2_.origin = GURL();
     affiliated_form2_.signon_realm = kTestAndroidRealm2;
     affiliated_form2_.scheme = autofill::PasswordForm::SCHEME_HTML;
     affiliated_form2_.skip_zero_click = false;
-    affiliated_form2_.ssl_valid = true;
 
     origin_path_form_.username_value = base::ASCIIToUTF16("Username 2");
     origin_path_form_.display_name = base::ASCIIToUTF16("Display Name 2");
     origin_path_form_.password_value = base::ASCIIToUTF16("Password 2");
     origin_path_form_.origin = GURL("https://example.com/path");
     origin_path_form_.signon_realm = origin_path_form_.origin.spec();
     origin_path_form_.scheme = autofill::PasswordForm::SCHEME_HTML;
     origin_path_form_.skip_zero_click = false;
 
     subdomain_form_.username_value = base::ASCIIToUTF16("Username 2");
@@ skipping 961 matching lines @@
   ExpectZeroClickSignInSuccess(true, true, federations,
                                mojom::CredentialType::PASSWORD);
 }
 
 TEST_F(CredentialManagerImplTest, GetSynthesizedFormForOrigin) {
   autofill::PasswordForm synthesized =
       cm_service_impl_->GetSynthesizedFormForOrigin();
   EXPECT_EQ(kTestWebOrigin, synthesized.origin.spec());
   EXPECT_EQ(kTestWebOrigin, synthesized.signon_realm);
   EXPECT_EQ(autofill::PasswordForm::SCHEME_HTML, synthesized.scheme);
-  EXPECT_TRUE(synthesized.ssl_valid);
 }
 
 TEST_F(CredentialManagerImplTest, BlacklistPasswordCredential) {
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(
                             _, CredentialSourceType::CREDENTIAL_SOURCE_API));
 
   CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_PASSWORD);
   bool called = false;
   CallStore(info, base::Bind(&RespondCallback, &called));
   // Allow the PasswordFormManager to talk to the password store
   RunAllPendingTasks();
 
   ASSERT_TRUE(client_->pending_manager());
   client_->pending_manager()->PermanentlyBlacklist();
   // Allow the PasswordFormManager to talk to the password store.
   RunAllPendingTasks();
 
   // Verify that the site is blacklisted.
   autofill::PasswordForm blacklisted;
   TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
   blacklisted.blacklisted_by_user = true;
   blacklisted.origin = form_.origin;
   blacklisted.signon_realm = form_.signon_realm;
   blacklisted.type = autofill::PasswordForm::TYPE_API;
-  blacklisted.ssl_valid = true;
   blacklisted.date_created = passwords[form_.signon_realm][0].date_created;
   EXPECT_THAT(passwords[form_.signon_realm], testing::ElementsAre(blacklisted));
 }
 
 TEST_F(CredentialManagerImplTest, BlacklistFederatedCredential) {
   form_.federation_origin = url::Origin(GURL("https://example.com/"));
   form_.password_value = base::string16();
   form_.signon_realm = "federation://example.com/example.com";
 
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(
@@ skipping 10 matching lines @@
   RunAllPendingTasks();
 
   // Verify that the site is blacklisted.
   TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
   ASSERT_TRUE(passwords.count(form_.origin.spec()));
   autofill::PasswordForm blacklisted;
   blacklisted.blacklisted_by_user = true;
   blacklisted.origin = form_.origin;
   blacklisted.signon_realm = blacklisted.origin.spec();
   blacklisted.type = autofill::PasswordForm::TYPE_API;
-  blacklisted.ssl_valid = true;
   blacklisted.date_created =
       passwords[blacklisted.signon_realm][0].date_created;
   EXPECT_THAT(passwords[blacklisted.signon_realm],
               testing::ElementsAre(blacklisted));
 }
 
 TEST_F(CredentialManagerImplTest, RespectBlacklistingPasswordCredential) {
   autofill::PasswordForm blacklisted;
   blacklisted.blacklisted_by_user = true;
   blacklisted.origin = form_.origin;
   blacklisted.signon_realm = blacklisted.origin.spec();
-  blacklisted.ssl_valid = true;
   store_->AddLogin(blacklisted);
 
   CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_PASSWORD);
   bool called = false;
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(
                             _, CredentialSourceType::CREDENTIAL_SOURCE_API));
   CallStore(info, base::Bind(&RespondCallback, &called));
   // Allow the PasswordFormManager to talk to the password store
   RunAllPendingTasks();
 
   ASSERT_TRUE(client_->pending_manager());
   EXPECT_TRUE(client_->pending_manager()->IsBlacklisted());
 }
 
 TEST_F(CredentialManagerImplTest, RespectBlacklistingFederatedCredential) {
   autofill::PasswordForm blacklisted;
   blacklisted.blacklisted_by_user = true;
   blacklisted.origin = form_.origin;
   blacklisted.signon_realm = blacklisted.origin.spec();
-  blacklisted.ssl_valid = true;
   store_->AddLogin(blacklisted);
 
   form_.federation_origin = url::Origin(GURL("https://example.com/"));
   form_.password_value = base::string16();
   form_.signon_realm = "federation://example.com/example.com";
   CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_FEDERATED);
   bool called = false;
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(
                             _, CredentialSourceType::CREDENTIAL_SOURCE_API));
   CallStore(info, base::Bind(&RespondCallback, &called));
   // Allow the PasswordFormManager to talk to the password store
   RunAllPendingTasks();
 
   ASSERT_TRUE(client_->pending_manager());
   EXPECT_TRUE(client_->pending_manager()->IsBlacklisted());
 }
 
 }  // namespace password_manager