chrome/browser/ui/passwords/manage_passwords_state_unittest.cc

   1 // Copyright 2015 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/ui/passwords/manage_passwords_state.h"
   6
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "components/password_manager/core/browser/password_form_manager.h"
   9 #include "components/password_manager/core/browser/stub_password_manager_client.h"
  10 #include "components/password_manager/core/common/credential_manager_types.h"
  11 #include "testing/gmock/include/gmock/gmock.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 using ::testing::_;
  15 using ::testing::Contains;
  16 using ::testing::ElementsAre;
  17 using ::testing::IsEmpty;
  18 using ::testing::Not;
  19 using ::testing::Pointee;
  20 using ::testing::UnorderedElementsAre;
  21
  22 namespace {
  23
  24 class ManagePasswordsStateTest : public testing::Test {
  25  public:
  26   ManagePasswordsStateTest() = default;
  27
  28   void SetUp() override {
  29     test_local_form_.origin = GURL("http://example.com");
  30     test_local_form_.username_value = base::ASCIIToUTF16("username");
  31     test_local_form_.password_value = base::ASCIIToUTF16("12345");
  32
  33     test_submitted_form_ = test_local_form_;
  34     test_submitted_form_.username_value = base::ASCIIToUTF16("new one");
  35     test_submitted_form_.password_value = base::ASCIIToUTF16("asdfjkl;");
  36
  37     test_federated_form_.origin = GURL("https://idp.com");
  38     test_federated_form_.username_value = base::ASCIIToUTF16("username");
  39
  40     passwords_data_.set_client(&client_);
  41   }
  42
  43   autofill::PasswordForm& test_local_form() { return test_local_form_; }
  44   autofill::PasswordForm& test_submitted_form() { return test_submitted_form_; }
  45   autofill::PasswordForm& test_federated_form() { return test_federated_form_; }
  46   ManagePasswordsState& passwords_data() { return passwords_data_; }
  47
  48   // Returns a PasswordFormManager containing test_local_form() as a best match.
  49   scoped_ptr<password_manager::PasswordFormManager> CreateFormManager();
  50
  51   // Pushes irrelevant updates to |passwords_data_| and checks that they don't
  52   // affect the state.
  53   void TestNoisyUpdates();
  54
  55   // Pushes both relevant and irrelevant updates to |passwords_data_|.
  56   void TestAllUpdates();
  57
  58   MOCK_METHOD1(OnChooseCredential,
  59                void(const password_manager::CredentialInfo&));
  60
  61  private:
  62   password_manager::StubPasswordManagerClient client_;
  63
  64   ManagePasswordsState passwords_data_;
  65   autofill::PasswordForm test_local_form_;
  66   autofill::PasswordForm test_submitted_form_;
  67   autofill::PasswordForm test_federated_form_;
  68
  69   DISALLOW_COPY_AND_ASSIGN(ManagePasswordsStateTest);
  70 };
  71
  72 scoped_ptr<password_manager::PasswordFormManager>
  73 ManagePasswordsStateTest::CreateFormManager() {
  74   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
  75       new password_manager::PasswordFormManager(
  76           nullptr, &client_,
  77           base::WeakPtr<password_manager::PasswordManagerDriver>(),
  78           test_local_form(), false));
  79   test_form_manager->SimulateFetchMatchingLoginsFromPasswordStore();
  80   ScopedVector<autofill::PasswordForm> stored_forms;
  81   stored_forms.push_back(new autofill::PasswordForm(test_local_form()));
  82   test_form_manager->OnGetPasswordStoreResults(stored_forms.Pass());
  83   EXPECT_EQ(1u, test_form_manager->best_matches().size());
  84   EXPECT_EQ(test_local_form(),
  85             *test_form_manager->best_matches().begin()->second);
  86   return test_form_manager.Pass();
  87 }
  88
  89 void ManagePasswordsStateTest::TestNoisyUpdates() {
  90   const std::vector<const autofill::PasswordForm*> forms =
  91       passwords_data_.GetCurrentForms();
  92   const std::vector<const autofill::PasswordForm*> federated_forms =
  93       passwords_data_.federated_credentials_forms();
  94   const password_manager::ui::State state = passwords_data_.state();
  95   const GURL origin = passwords_data_.origin();
  96
  97   // Push "Add".
  98   autofill::PasswordForm form;
  99   form.origin = GURL("http://3rdparty.com");
 100   form.username_value = base::ASCIIToUTF16("username");
 101   form.password_value = base::ASCIIToUTF16("12345");
 102   password_manager::PasswordStoreChange change(
 103       password_manager::PasswordStoreChange::ADD, form);
 104   password_manager::PasswordStoreChangeList list(1, change);
 105   passwords_data().ProcessLoginsChanged(list);
 106   EXPECT_EQ(forms, passwords_data().GetCurrentForms());
 107   EXPECT_EQ(federated_forms, passwords_data().federated_credentials_forms());
 108   EXPECT_EQ(state, passwords_data().state());
 109   EXPECT_EQ(origin, passwords_data().origin());
 110
 111   // Update the form.
 112   form.password_value = base::ASCIIToUTF16("password");
 113   list[0] = password_manager::PasswordStoreChange(
 114       password_manager::PasswordStoreChange::UPDATE, form);
 115   passwords_data().ProcessLoginsChanged(list);
 116   EXPECT_EQ(forms, passwords_data().GetCurrentForms());
 117   EXPECT_EQ(federated_forms, passwords_data().federated_credentials_forms());
 118   EXPECT_EQ(state, passwords_data().state());
 119   EXPECT_EQ(origin, passwords_data().origin());
 120
 121   // Delete the form.
 122   list[0] = password_manager::PasswordStoreChange(
 123       password_manager::PasswordStoreChange::REMOVE, form);
 124   passwords_data().ProcessLoginsChanged(list);
 125   EXPECT_EQ(forms, passwords_data().GetCurrentForms());
 126   EXPECT_EQ(federated_forms, passwords_data().federated_credentials_forms());
 127   EXPECT_EQ(state, passwords_data().state());
 128   EXPECT_EQ(origin, passwords_data().origin());
 129 }
 130
 131 void ManagePasswordsStateTest::TestAllUpdates() {
 132   const std::vector<const autofill::PasswordForm*> forms =
 133       passwords_data_.GetCurrentForms();
 134   const std::vector<const autofill::PasswordForm*> federated_forms =
 135       passwords_data_.federated_credentials_forms();
 136   const password_manager::ui::State state = passwords_data_.state();
 137   const GURL origin = passwords_data_.origin();
 138   EXPECT_NE(GURL::EmptyGURL(), origin);
 139
 140   // Push "Add".
 141   autofill::PasswordForm form;
 142   form.origin = origin;
 143   form.username_value = base::ASCIIToUTF16("user15");
 144   form.password_value = base::ASCIIToUTF16("12345");
 145   password_manager::PasswordStoreChange change(
 146       password_manager::PasswordStoreChange::ADD, form);
 147   password_manager::PasswordStoreChangeList list(1, change);
 148   passwords_data().ProcessLoginsChanged(list);
 149   EXPECT_THAT(passwords_data().GetCurrentForms(), Contains(Pointee(form)));
 150   EXPECT_EQ(federated_forms, passwords_data().federated_credentials_forms());
 151   EXPECT_EQ(state, passwords_data().state());
 152   EXPECT_EQ(origin, passwords_data().origin());
 153
 154   // Update the form.
 155   form.password_value = base::ASCIIToUTF16("password");
 156   list[0] = password_manager::PasswordStoreChange(
 157       password_manager::PasswordStoreChange::UPDATE, form);
 158   passwords_data().ProcessLoginsChanged(list);
 159   EXPECT_THAT(passwords_data().GetCurrentForms(), Contains(Pointee(form)));
 160   EXPECT_EQ(federated_forms, passwords_data().federated_credentials_forms());
 161   EXPECT_EQ(state, passwords_data().state());
 162   EXPECT_EQ(origin, passwords_data().origin());
 163
 164   // Delete the form.
 165   list[0] = password_manager::PasswordStoreChange(
 166       password_manager::PasswordStoreChange::REMOVE, form);
 167   passwords_data().ProcessLoginsChanged(list);
 168   EXPECT_EQ(forms, passwords_data().GetCurrentForms());
 169   EXPECT_EQ(federated_forms, passwords_data().federated_credentials_forms());
 170   EXPECT_EQ(state, passwords_data().state());
 171   EXPECT_EQ(origin, passwords_data().origin());
 172
 173   TestNoisyUpdates();
 174 }
 175
 176 TEST_F(ManagePasswordsStateTest, DefaultState) {
 177   EXPECT_THAT(passwords_data().GetCurrentForms(), IsEmpty());
 178   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 179   EXPECT_EQ(password_manager::ui::INACTIVE_STATE, passwords_data().state());
 180   EXPECT_EQ(GURL::EmptyGURL(), passwords_data().origin());
 181   EXPECT_FALSE(passwords_data().form_manager());
 182
 183   TestNoisyUpdates();
 184 }
 185
 186 TEST_F(ManagePasswordsStateTest, PasswordSubmitted) {
 187   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
 188       CreateFormManager());
 189   test_form_manager->ProvisionallySave(
 190       test_submitted_form(),
 191       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 192   passwords_data().OnPendingPassword(test_form_manager.Pass());
 193
 194   EXPECT_THAT(passwords_data().GetCurrentForms(),
 195               ElementsAre(Pointee(test_local_form())));
 196   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 197   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE,
 198             passwords_data().state());
 199   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
 200   ASSERT_TRUE(passwords_data().form_manager());
 201   EXPECT_EQ(test_submitted_form(),
 202             passwords_data().form_manager()->pending_credentials());
 203   TestAllUpdates();
 204 }
 205
 206 TEST_F(ManagePasswordsStateTest, PasswordSaved) {
 207   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
 208       CreateFormManager());
 209   test_form_manager->ProvisionallySave(
 210       test_submitted_form(),
 211       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 212   passwords_data().OnPendingPassword(test_form_manager.Pass());
 213   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE,
 214             passwords_data().state());
 215
 216   passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE);
 217   EXPECT_THAT(passwords_data().GetCurrentForms(),
 218               ElementsAre(Pointee(test_local_form())));
 219   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 220   EXPECT_EQ(password_manager::ui::MANAGE_STATE,
 221             passwords_data().state());
 222   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
 223   TestAllUpdates();
 224 }
 225
 226 TEST_F(ManagePasswordsStateTest, OnRequestCredentials) {
 227   ScopedVector<autofill::PasswordForm> local_credentials;
 228   local_credentials.push_back(new autofill::PasswordForm(test_local_form()));
 229   ScopedVector<autofill::PasswordForm> federated_credentials;
 230   federated_credentials.push_back(
 231       new autofill::PasswordForm(test_federated_form()));
 232   const GURL origin = test_local_form().origin;
 233   passwords_data().OnRequestCredentials(local_credentials.Pass(),
 234                                         federated_credentials.Pass(), origin);
 235   passwords_data().set_credentials_callback(
 236       base::Bind(&ManagePasswordsStateTest::OnChooseCredential,
 237                  base::Unretained(this)));
 238   EXPECT_THAT(passwords_data().GetCurrentForms(),
 239               ElementsAre(Pointee(test_local_form())));
 240   EXPECT_THAT(passwords_data().federated_credentials_forms(),
 241               ElementsAre(Pointee(test_federated_form())));
 242   EXPECT_EQ(password_manager::ui::CREDENTIAL_REQUEST_STATE,
 243             passwords_data().state());
 244   EXPECT_EQ(origin, passwords_data().origin());
 245   TestAllUpdates();
 246
 247   password_manager::CredentialInfo credential_info(
 248       test_local_form(),
 249       password_manager::CredentialType::CREDENTIAL_TYPE_LOCAL);
 250   EXPECT_CALL(*this, OnChooseCredential(_))
 251       .WillOnce(testing::SaveArg<0>(&credential_info));
 252   passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE);
 253   EXPECT_EQ(password_manager::CredentialType::CREDENTIAL_TYPE_EMPTY,
 254             credential_info.type);
 255   EXPECT_TRUE(passwords_data().credentials_callback().is_null());
 256   EXPECT_THAT(passwords_data().GetCurrentForms(),
 257               ElementsAre(Pointee(test_local_form())));
 258   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 259   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
 260   EXPECT_EQ(origin, passwords_data().origin());
 261   TestAllUpdates();
 262 }
 263
 264 TEST_F(ManagePasswordsStateTest, AutoSignin) {
 265   ScopedVector<autofill::PasswordForm> local_credentials;
 266   local_credentials.push_back(new autofill::PasswordForm(test_local_form()));
 267   passwords_data().OnAutoSignin(local_credentials.Pass());
 268   EXPECT_THAT(passwords_data().GetCurrentForms(),
 269               ElementsAre(Pointee(test_local_form())));
 270   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 271   EXPECT_EQ(password_manager::ui::AUTO_SIGNIN_STATE, passwords_data().state());
 272   EXPECT_EQ(test_local_form().origin, passwords_data().origin());
 273   TestAllUpdates();
 274
 275   passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE);
 276   EXPECT_THAT(passwords_data().GetCurrentForms(),
 277               ElementsAre(Pointee(test_local_form())));
 278   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 279   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
 280   EXPECT_EQ(test_local_form().origin, passwords_data().origin());
 281   TestAllUpdates();
 282 }
 283
 284 TEST_F(ManagePasswordsStateTest, AutomaticPasswordSave) {
 285   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
 286       CreateFormManager());
 287   test_form_manager->ProvisionallySave(
 288       test_submitted_form(),
 289       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 290
 291   passwords_data().OnAutomaticPasswordSave(test_form_manager.Pass());
 292   EXPECT_EQ(password_manager::ui::CONFIRMATION_STATE, passwords_data().state());
 293   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
 294   ASSERT_TRUE(passwords_data().form_manager());
 295   EXPECT_EQ(test_submitted_form(),
 296             passwords_data().form_manager()->pending_credentials());
 297   TestAllUpdates();
 298
 299   passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE);
 300   EXPECT_THAT(passwords_data().GetCurrentForms(),
 301               UnorderedElementsAre(Pointee(test_local_form()),
 302                                    Pointee(test_submitted_form())));
 303   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 304   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
 305   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
 306   TestAllUpdates();
 307 }
 308
 309 TEST_F(ManagePasswordsStateTest, PasswordBlacklisted) {
 310   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
 311       CreateFormManager());
 312   test_form_manager->ProvisionallySave(
 313       test_submitted_form(),
 314       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 315   passwords_data().OnPendingPassword(test_form_manager.Pass());
 316   passwords_data().TransitionToState(password_manager::ui::BLACKLIST_STATE);
 317   EXPECT_THAT(passwords_data().GetCurrentForms(),
 318               ElementsAre(Pointee(test_local_form())));
 319   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 320   EXPECT_EQ(password_manager::ui::BLACKLIST_STATE, passwords_data().state());
 321   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
 322   TestAllUpdates();
 323 }
 324
 325 TEST_F(ManagePasswordsStateTest, PasswordAutofilled) {
 326   autofill::PasswordFormMap password_form_map;
 327   password_form_map[test_local_form().username_value] = &test_local_form();
 328   passwords_data().OnPasswordAutofilled(password_form_map);
 329
 330   EXPECT_THAT(passwords_data().GetCurrentForms(),
 331               ElementsAre(Pointee(test_local_form())));
 332   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 333   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
 334   EXPECT_EQ(test_local_form().origin, passwords_data().origin());
 335
 336   // |passwords_data| should hold a separate copy of test_local_form().
 337   EXPECT_THAT(passwords_data().GetCurrentForms(),
 338               Not(Contains(&test_local_form())));
 339   TestAllUpdates();
 340 }
 341
 342 TEST_F(ManagePasswordsStateTest, InactiveOnPSLMatched) {
 343   autofill::PasswordForm psl_matched_test_form = test_local_form();
 344   psl_matched_test_form.original_signon_realm = "http://pslmatched.example.com";
 345   autofill::PasswordFormMap password_form_map;
 346   password_form_map[psl_matched_test_form.username_value] =
 347       &psl_matched_test_form;
 348   passwords_data().OnPasswordAutofilled(password_form_map);
 349
 350   EXPECT_THAT(passwords_data().GetCurrentForms(), IsEmpty());
 351   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 352   EXPECT_EQ(password_manager::ui::INACTIVE_STATE, passwords_data().state());
 353   EXPECT_EQ(GURL::EmptyGURL(), passwords_data().origin());
 354   EXPECT_FALSE(passwords_data().form_manager());
 355 }
 356
 357 TEST_F(ManagePasswordsStateTest, BlacklistBlockedAutofill) {
 358   autofill::PasswordForm blacklisted;
 359   blacklisted.blacklisted_by_user = true;
 360   blacklisted.origin = GURL("http://example.com/bad");
 361   autofill::PasswordFormMap password_form_map;
 362   password_form_map[blacklisted.username_value] = &blacklisted;
 363   password_form_map[test_local_form().username_value] = &test_local_form();
 364   passwords_data().OnBlacklistBlockedAutofill(password_form_map);
 365
 366   EXPECT_THAT(passwords_data().GetCurrentForms(),
 367               ElementsAre(Pointee(blacklisted), Pointee(test_local_form())));
 368   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 369   EXPECT_EQ(password_manager::ui::BLACKLIST_STATE, passwords_data().state());
 370   EXPECT_EQ(blacklisted.origin, passwords_data().origin());
 371
 372   // |passwords_data| should hold a separate copy of test_local_form().
 373   EXPECT_THAT(passwords_data().GetCurrentForms(),
 374               Not(Contains(&test_local_form())));
 375   TestAllUpdates();
 376 }
 377
 378 TEST_F(ManagePasswordsStateTest, Unblacklist) {
 379   autofill::PasswordForm blacklisted;
 380   blacklisted.blacklisted_by_user = true;
 381   blacklisted.origin = test_local_form().origin;
 382   autofill::PasswordFormMap password_form_map;
 383   password_form_map[blacklisted.username_value] = &blacklisted;
 384   passwords_data().OnBlacklistBlockedAutofill(password_form_map);
 385   EXPECT_EQ(password_manager::ui::BLACKLIST_STATE, passwords_data().state());
 386   passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE);
 387
 388   EXPECT_THAT(passwords_data().GetCurrentForms(),
 389               ElementsAre(Pointee(blacklisted)));
 390   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 391   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
 392   EXPECT_EQ(blacklisted.origin, passwords_data().origin());
 393   TestAllUpdates();
 394 }
 395
 396 TEST_F(ManagePasswordsStateTest, OnInactive) {
 397   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
 398       CreateFormManager());
 399   test_form_manager->ProvisionallySave(
 400       test_submitted_form(),
 401       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 402   passwords_data().OnPendingPassword(test_form_manager.Pass());
 403   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE,
 404             passwords_data().state());
 405   passwords_data().OnInactive();
 406   EXPECT_THAT(passwords_data().GetCurrentForms(), IsEmpty());
 407   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 408   EXPECT_EQ(password_manager::ui::INACTIVE_STATE, passwords_data().state());
 409   EXPECT_EQ(GURL::EmptyGURL(), passwords_data().origin());
 410   EXPECT_FALSE(passwords_data().form_manager());
 411   TestNoisyUpdates();
 412 }
 413
 414 TEST_F(ManagePasswordsStateTest, PendingPasswordToBlacklisted) {
 415   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
 416       CreateFormManager());
 417   test_form_manager->ProvisionallySave(
 418       test_submitted_form(),
 419       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 420   passwords_data().OnPendingPassword(test_form_manager.Pass());
 421   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE,
 422             passwords_data().state());
 423
 424   // Process the blacklisted form.
 425   autofill::PasswordForm blacklisted = test_local_form();
 426   blacklisted.blacklisted_by_user = true;
 427   blacklisted.username_value = base::string16();
 428   password_manager::PasswordStoreChangeList list;
 429   list.push_back(password_manager::PasswordStoreChange(
 430       password_manager::PasswordStoreChange::ADD, blacklisted));
 431   passwords_data().ProcessLoginsChanged(list);
 432   EXPECT_THAT(passwords_data().GetCurrentForms(),
 433               ElementsAre(Pointee(blacklisted), Pointee(test_local_form())));
 434   EXPECT_EQ(password_manager::ui::BLACKLIST_STATE, passwords_data().state());
 435   EXPECT_EQ(test_local_form().origin, passwords_data().origin());
 436
 437   // Delete the blacklisted form.
 438   list[0] = password_manager::PasswordStoreChange(
 439       password_manager::PasswordStoreChange::REMOVE, blacklisted);
 440   passwords_data().ProcessLoginsChanged(list);
 441   EXPECT_THAT(passwords_data().GetCurrentForms(),
 442               ElementsAre(Pointee(test_local_form())));
 443   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 444   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
 445   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
 446 }
 447
 448 TEST_F(ManagePasswordsStateTest, RequestCredentialsToBlacklisted) {
 449   ScopedVector<autofill::PasswordForm> local_credentials;
 450   local_credentials.push_back(new autofill::PasswordForm(test_local_form()));
 451   ScopedVector<autofill::PasswordForm> federated_credentials;
 452   federated_credentials.push_back(
 453       new autofill::PasswordForm(test_federated_form()));
 454   const GURL origin = test_local_form().origin;
 455   passwords_data().OnRequestCredentials(local_credentials.Pass(),
 456                                         federated_credentials.Pass(), origin);
 457   passwords_data().set_credentials_callback(
 458       base::Bind(&ManagePasswordsStateTest::OnChooseCredential,
 459                  base::Unretained(this)));
 460   EXPECT_EQ(password_manager::ui::CREDENTIAL_REQUEST_STATE,
 461             passwords_data().state());
 462
 463   // Process the blacklisted form.
 464   autofill::PasswordForm blacklisted = test_local_form();
 465   blacklisted.blacklisted_by_user = true;
 466   blacklisted.username_value = base::string16();
 467   password_manager::PasswordStoreChangeList list;
 468   list.push_back(password_manager::PasswordStoreChange(
 469       password_manager::PasswordStoreChange::ADD, blacklisted));
 470   password_manager::CredentialInfo credential_info(
 471       test_local_form(),
 472       password_manager::CredentialType::CREDENTIAL_TYPE_LOCAL);
 473   EXPECT_CALL(*this, OnChooseCredential(_))
 474       .WillOnce(testing::SaveArg<0>(&credential_info));
 475   passwords_data().ProcessLoginsChanged(list);
 476   EXPECT_THAT(passwords_data().GetCurrentForms(),
 477               ElementsAre(Pointee(blacklisted), Pointee(test_local_form())));
 478   EXPECT_EQ(password_manager::ui::BLACKLIST_STATE, passwords_data().state());
 479   EXPECT_EQ(test_local_form().origin, passwords_data().origin());
 480   EXPECT_EQ(password_manager::CredentialType::CREDENTIAL_TYPE_EMPTY,
 481             credential_info.type);
 482   EXPECT_TRUE(passwords_data().credentials_callback().is_null());
 483
 484   // Delete the blacklisted form.
 485   list[0] = password_manager::PasswordStoreChange(
 486       password_manager::PasswordStoreChange::REMOVE, blacklisted);
 487   passwords_data().ProcessLoginsChanged(list);
 488   EXPECT_THAT(passwords_data().GetCurrentForms(),
 489               ElementsAre(Pointee(test_local_form())));
 490   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 491   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
 492   EXPECT_EQ(origin, passwords_data().origin());
 493 }
 494
 495 TEST_F(ManagePasswordsStateTest, AutoSigninToBlacklisted) {
 496   ScopedVector<autofill::PasswordForm> local_credentials;
 497   local_credentials.push_back(new autofill::PasswordForm(test_local_form()));
 498   passwords_data().OnAutoSignin(local_credentials.Pass());
 499   EXPECT_EQ(password_manager::ui::AUTO_SIGNIN_STATE, passwords_data().state());
 500
 501   // Process the blacklisted form.
 502   autofill::PasswordForm blacklisted = test_local_form();
 503   blacklisted.blacklisted_by_user = true;
 504   blacklisted.username_value = base::string16();
 505   password_manager::PasswordStoreChange change(
 506       password_manager::PasswordStoreChange::ADD, blacklisted);
 507   password_manager::PasswordStoreChangeList list(1, change);
 508   passwords_data().ProcessLoginsChanged(list);
 509   EXPECT_THAT(passwords_data().GetCurrentForms(),
 510               ElementsAre(Pointee(blacklisted), Pointee(test_local_form())));
 511   EXPECT_EQ(password_manager::ui::BLACKLIST_STATE, passwords_data().state());
 512   EXPECT_EQ(test_local_form().origin, passwords_data().origin());
 513
 514   // Delete the blacklisted form.
 515   list[0] = password_manager::PasswordStoreChange(
 516       password_manager::PasswordStoreChange::REMOVE, blacklisted);
 517   passwords_data().ProcessLoginsChanged(list);
 518   EXPECT_THAT(passwords_data().GetCurrentForms(),
 519               ElementsAre(Pointee(test_local_form())));
 520   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 521   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
 522   EXPECT_EQ(test_local_form().origin, passwords_data().origin());
 523 }
 524
 525 TEST_F(ManagePasswordsStateTest, AutomaticPasswordSaveToBlacklisted) {
 526   scoped_ptr<password_manager::PasswordFormManager> test_form_manager(
 527       CreateFormManager());
 528   test_form_manager->ProvisionallySave(
 529       test_submitted_form(),
 530       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 531   passwords_data().OnAutomaticPasswordSave(test_form_manager.Pass());
 532   EXPECT_EQ(password_manager::ui::CONFIRMATION_STATE, passwords_data().state());
 533
 534   // Process the blacklisted form.
 535   autofill::PasswordForm blacklisted = test_local_form();
 536   blacklisted.blacklisted_by_user = true;
 537   blacklisted.username_value = base::string16();
 538   password_manager::PasswordStoreChange change(
 539       password_manager::PasswordStoreChange::ADD, blacklisted);
 540   password_manager::PasswordStoreChangeList list(1, change);
 541   passwords_data().ProcessLoginsChanged(list);
 542   EXPECT_EQ(*passwords_data().GetCurrentForms()[0], blacklisted);
 543   EXPECT_EQ(password_manager::ui::BLACKLIST_STATE, passwords_data().state());
 544   EXPECT_EQ(test_local_form().origin, passwords_data().origin());
 545
 546   // Delete the blacklisted form.
 547   list[0] = password_manager::PasswordStoreChange(
 548       password_manager::PasswordStoreChange::REMOVE, blacklisted);
 549   passwords_data().ProcessLoginsChanged(list);
 550   EXPECT_THAT(passwords_data().GetCurrentForms(),
 551               UnorderedElementsAre(Pointee(test_local_form()),
 552                                    Pointee(test_submitted_form())));
 553   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 554   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
 555   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
 556 }
 557
 558 TEST_F(ManagePasswordsStateTest, BackgroundAutofilledToBlacklisted) {
 559   autofill::PasswordFormMap password_form_map;
 560   password_form_map[test_local_form().username_value] = &test_local_form();
 561   passwords_data().OnPasswordAutofilled(password_form_map);
 562   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
 563
 564   // Process the blacklisted form.
 565   autofill::PasswordForm blacklisted = test_local_form();
 566   blacklisted.blacklisted_by_user = true;
 567   blacklisted.username_value = base::string16();
 568   password_manager::PasswordStoreChange change(
 569       password_manager::PasswordStoreChange::ADD, blacklisted);
 570   password_manager::PasswordStoreChangeList list(1, change);
 571   passwords_data().ProcessLoginsChanged(list);
 572   EXPECT_THAT(passwords_data().GetCurrentForms(),
 573               ElementsAre(Pointee(blacklisted), Pointee(test_local_form())));
 574   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 575   EXPECT_EQ(password_manager::ui::BLACKLIST_STATE, passwords_data().state());
 576   EXPECT_EQ(test_local_form().origin, passwords_data().origin());
 577
 578   // Delete the blacklisted form.
 579   list[0] = password_manager::PasswordStoreChange(
 580       password_manager::PasswordStoreChange::REMOVE, blacklisted);
 581   passwords_data().ProcessLoginsChanged(list);
 582   EXPECT_THAT(passwords_data().GetCurrentForms(),
 583               ElementsAre(Pointee(test_local_form())));
 584   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 585   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
 586   EXPECT_EQ(test_local_form().origin, passwords_data().origin());
 587 }
 588
 589 TEST_F(ManagePasswordsStateTest, BlacklistedToAutofilled) {
 590   autofill::PasswordFormMap password_form_map;
 591   password_form_map[test_local_form().username_value] = &test_local_form();
 592   autofill::PasswordForm blacklisted;
 593   blacklisted.blacklisted_by_user = true;
 594   blacklisted.origin = GURL("http://example.com/bad");
 595   password_form_map[blacklisted.username_value] = &blacklisted;
 596   passwords_data().OnBlacklistBlockedAutofill(password_form_map);
 597   EXPECT_EQ(password_manager::ui::BLACKLIST_STATE, passwords_data().state());
 598   EXPECT_EQ(blacklisted.origin, passwords_data().origin());
 599
 600   // Delete the blacklisted form.
 601   password_manager::PasswordStoreChangeList list;
 602   list.push_back(password_manager::PasswordStoreChange(
 603       password_manager::PasswordStoreChange::REMOVE, blacklisted));
 604   passwords_data().ProcessLoginsChanged(list);
 605   EXPECT_THAT(passwords_data().GetCurrentForms(),
 606               ElementsAre(Pointee(test_local_form())));
 607   EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty());
 608   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
 609   EXPECT_EQ(blacklisted.origin, passwords_data().origin());
 610 }
 611
 612 }  // namespace