OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/ui/passwords/manage_passwords_state.h" | 5 #include "chrome/browser/ui/passwords/manage_passwords_state.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
| 10 #include "base/memory/ptr_util.h" |
10 #include "base/strings/utf_string_conversions.h" | 11 #include "base/strings/utf_string_conversions.h" |
11 #include "components/password_manager/core/browser/password_form_manager.h" | 12 #include "components/password_manager/core/browser/password_form_manager.h" |
12 #include "components/password_manager/core/browser/password_manager.h" | 13 #include "components/password_manager/core/browser/password_manager.h" |
13 #include "components/password_manager/core/browser/stub_password_manager_client.
h" | 14 #include "components/password_manager/core/browser/stub_password_manager_client.
h" |
14 #include "components/password_manager/core/browser/stub_password_manager_driver.
h" | 15 #include "components/password_manager/core/browser/stub_password_manager_driver.
h" |
15 #include "testing/gmock/include/gmock/gmock.h" | 16 #include "testing/gmock/include/gmock/gmock.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 17 #include "testing/gtest/include/gtest/gtest.h" |
17 #include "url/gurl.h" | 18 #include "url/gurl.h" |
18 #include "url/origin.h" | 19 #include "url/origin.h" |
19 | 20 |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
59 return test_local_federated_form_; | 60 return test_local_federated_form_; |
60 } | 61 } |
61 autofill::PasswordForm& test_federated_form() { return test_federated_form_; } | 62 autofill::PasswordForm& test_federated_form() { return test_federated_form_; } |
62 ScopedVector<autofill::PasswordForm>& test_stored_forms() { | 63 ScopedVector<autofill::PasswordForm>& test_stored_forms() { |
63 return test_stored_forms_; | 64 return test_stored_forms_; |
64 } | 65 } |
65 ManagePasswordsState& passwords_data() { return passwords_data_; } | 66 ManagePasswordsState& passwords_data() { return passwords_data_; } |
66 | 67 |
67 // Returns a PasswordFormManager containing |test_stored_forms_| as the best | 68 // Returns a PasswordFormManager containing |test_stored_forms_| as the best |
68 // matches. | 69 // matches. |
69 scoped_ptr<password_manager::PasswordFormManager> CreateFormManager(); | 70 std::unique_ptr<password_manager::PasswordFormManager> CreateFormManager(); |
70 | 71 |
71 // Returns a PasswordFormManager containing test_federated_form() as a stored | 72 // Returns a PasswordFormManager containing test_federated_form() as a stored |
72 // federated credential. | 73 // federated credential. |
73 scoped_ptr<password_manager::PasswordFormManager> | 74 std::unique_ptr<password_manager::PasswordFormManager> |
74 CreateFormManagerWithFederation(); | 75 CreateFormManagerWithFederation(); |
75 | 76 |
76 // Pushes irrelevant updates to |passwords_data_| and checks that they don't | 77 // Pushes irrelevant updates to |passwords_data_| and checks that they don't |
77 // affect the state. | 78 // affect the state. |
78 void TestNoisyUpdates(); | 79 void TestNoisyUpdates(); |
79 | 80 |
80 // Pushes both relevant and irrelevant updates to |passwords_data_|. | 81 // Pushes both relevant and irrelevant updates to |passwords_data_|. |
81 void TestAllUpdates(); | 82 void TestAllUpdates(); |
82 | 83 |
83 // Pushes a blacklisted form and checks that it doesn't affect the state. | 84 // Pushes a blacklisted form and checks that it doesn't affect the state. |
84 void TestBlacklistedUpdates(); | 85 void TestBlacklistedUpdates(); |
85 | 86 |
86 MOCK_METHOD1(CredentialCallback, void(const autofill::PasswordForm*)); | 87 MOCK_METHOD1(CredentialCallback, void(const autofill::PasswordForm*)); |
87 | 88 |
88 private: | 89 private: |
89 // Implements both CreateFormManager and CreateFormManagerWithFederation. | 90 // Implements both CreateFormManager and CreateFormManagerWithFederation. |
90 scoped_ptr<password_manager::PasswordFormManager> CreateFormManagerInternal( | 91 std::unique_ptr<password_manager::PasswordFormManager> |
91 bool include_federated); | 92 CreateFormManagerInternal(bool include_federated); |
92 | 93 |
93 password_manager::StubPasswordManagerClient stub_client_; | 94 password_manager::StubPasswordManagerClient stub_client_; |
94 password_manager::StubPasswordManagerDriver driver_; | 95 password_manager::StubPasswordManagerDriver driver_; |
95 password_manager::PasswordManager password_manager_; | 96 password_manager::PasswordManager password_manager_; |
96 | 97 |
97 ManagePasswordsState passwords_data_; | 98 ManagePasswordsState passwords_data_; |
98 autofill::PasswordForm test_local_form_; | 99 autofill::PasswordForm test_local_form_; |
99 autofill::PasswordForm test_submitted_form_; | 100 autofill::PasswordForm test_submitted_form_; |
100 autofill::PasswordForm test_local_federated_form_; | 101 autofill::PasswordForm test_local_federated_form_; |
101 autofill::PasswordForm test_federated_form_; | 102 autofill::PasswordForm test_federated_form_; |
102 ScopedVector<autofill::PasswordForm> test_stored_forms_; | 103 ScopedVector<autofill::PasswordForm> test_stored_forms_; |
103 }; | 104 }; |
104 | 105 |
105 scoped_ptr<password_manager::PasswordFormManager> | 106 std::unique_ptr<password_manager::PasswordFormManager> |
106 ManagePasswordsStateTest::CreateFormManager() { | 107 ManagePasswordsStateTest::CreateFormManager() { |
107 return CreateFormManagerInternal(false); | 108 return CreateFormManagerInternal(false); |
108 } | 109 } |
109 | 110 |
110 scoped_ptr<password_manager::PasswordFormManager> | 111 std::unique_ptr<password_manager::PasswordFormManager> |
111 ManagePasswordsStateTest::CreateFormManagerWithFederation() { | 112 ManagePasswordsStateTest::CreateFormManagerWithFederation() { |
112 return CreateFormManagerInternal(true); | 113 return CreateFormManagerInternal(true); |
113 } | 114 } |
114 | 115 |
115 scoped_ptr<password_manager::PasswordFormManager> | 116 std::unique_ptr<password_manager::PasswordFormManager> |
116 ManagePasswordsStateTest::CreateFormManagerInternal(bool include_federated) { | 117 ManagePasswordsStateTest::CreateFormManagerInternal(bool include_federated) { |
117 scoped_ptr<password_manager::PasswordFormManager> test_form_manager( | 118 std::unique_ptr<password_manager::PasswordFormManager> test_form_manager( |
118 new password_manager::PasswordFormManager( | 119 new password_manager::PasswordFormManager( |
119 &password_manager_, &stub_client_, driver_.AsWeakPtr(), | 120 &password_manager_, &stub_client_, driver_.AsWeakPtr(), |
120 test_local_form(), false)); | 121 test_local_form(), false)); |
121 test_form_manager->SimulateFetchMatchingLoginsFromPasswordStore(); | 122 test_form_manager->SimulateFetchMatchingLoginsFromPasswordStore(); |
122 if (include_federated) { | 123 if (include_federated) { |
123 test_stored_forms_.push_back( | 124 test_stored_forms_.push_back( |
124 new autofill::PasswordForm(test_local_federated_form())); | 125 new autofill::PasswordForm(test_local_federated_form())); |
125 } | 126 } |
126 test_form_manager->OnGetPasswordStoreResults(std::move(test_stored_forms_)); | 127 test_form_manager->OnGetPasswordStoreResults(std::move(test_stored_forms_)); |
127 EXPECT_EQ(include_federated ? 1u : 0u, | 128 EXPECT_EQ(include_federated ? 1u : 0u, |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
257 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 258 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
258 EXPECT_EQ(password_manager::ui::INACTIVE_STATE, passwords_data().state()); | 259 EXPECT_EQ(password_manager::ui::INACTIVE_STATE, passwords_data().state()); |
259 EXPECT_EQ(GURL::EmptyGURL(), passwords_data().origin()); | 260 EXPECT_EQ(GURL::EmptyGURL(), passwords_data().origin()); |
260 EXPECT_FALSE(passwords_data().form_manager()); | 261 EXPECT_FALSE(passwords_data().form_manager()); |
261 | 262 |
262 TestNoisyUpdates(); | 263 TestNoisyUpdates(); |
263 } | 264 } |
264 | 265 |
265 TEST_F(ManagePasswordsStateTest, PasswordSubmitted) { | 266 TEST_F(ManagePasswordsStateTest, PasswordSubmitted) { |
266 test_stored_forms().push_back(new autofill::PasswordForm(test_local_form())); | 267 test_stored_forms().push_back(new autofill::PasswordForm(test_local_form())); |
267 scoped_ptr<password_manager::PasswordFormManager> test_form_manager( | 268 std::unique_ptr<password_manager::PasswordFormManager> test_form_manager( |
268 CreateFormManager()); | 269 CreateFormManager()); |
269 test_form_manager->ProvisionallySave( | 270 test_form_manager->ProvisionallySave( |
270 test_submitted_form(), | 271 test_submitted_form(), |
271 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 272 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
272 passwords_data().OnPendingPassword(std::move(test_form_manager)); | 273 passwords_data().OnPendingPassword(std::move(test_form_manager)); |
273 | 274 |
274 EXPECT_THAT(passwords_data().GetCurrentForms(), | 275 EXPECT_THAT(passwords_data().GetCurrentForms(), |
275 ElementsAre(Pointee(test_local_form()))); | 276 ElementsAre(Pointee(test_local_form()))); |
276 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 277 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
277 EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE, | 278 EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE, |
278 passwords_data().state()); | 279 passwords_data().state()); |
279 EXPECT_EQ(test_submitted_form().origin, passwords_data().origin()); | 280 EXPECT_EQ(test_submitted_form().origin, passwords_data().origin()); |
280 ASSERT_TRUE(passwords_data().form_manager()); | 281 ASSERT_TRUE(passwords_data().form_manager()); |
281 EXPECT_EQ(test_submitted_form(), | 282 EXPECT_EQ(test_submitted_form(), |
282 passwords_data().form_manager()->pending_credentials()); | 283 passwords_data().form_manager()->pending_credentials()); |
283 TestAllUpdates(); | 284 TestAllUpdates(); |
284 } | 285 } |
285 | 286 |
286 TEST_F(ManagePasswordsStateTest, PasswordSaved) { | 287 TEST_F(ManagePasswordsStateTest, PasswordSaved) { |
287 test_stored_forms().push_back(new autofill::PasswordForm(test_local_form())); | 288 test_stored_forms().push_back(new autofill::PasswordForm(test_local_form())); |
288 scoped_ptr<password_manager::PasswordFormManager> test_form_manager( | 289 std::unique_ptr<password_manager::PasswordFormManager> test_form_manager( |
289 CreateFormManager()); | 290 CreateFormManager()); |
290 test_form_manager->ProvisionallySave( | 291 test_form_manager->ProvisionallySave( |
291 test_submitted_form(), | 292 test_submitted_form(), |
292 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 293 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
293 passwords_data().OnPendingPassword(std::move(test_form_manager)); | 294 passwords_data().OnPendingPassword(std::move(test_form_manager)); |
294 EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE, | 295 EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE, |
295 passwords_data().state()); | 296 passwords_data().state()); |
296 | 297 |
297 passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE); | 298 passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE); |
298 EXPECT_THAT(passwords_data().GetCurrentForms(), | 299 EXPECT_THAT(passwords_data().GetCurrentForms(), |
299 ElementsAre(Pointee(test_local_form()))); | 300 ElementsAre(Pointee(test_local_form()))); |
300 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 301 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
301 EXPECT_EQ(password_manager::ui::MANAGE_STATE, | 302 EXPECT_EQ(password_manager::ui::MANAGE_STATE, |
302 passwords_data().state()); | 303 passwords_data().state()); |
303 EXPECT_EQ(test_submitted_form().origin, passwords_data().origin()); | 304 EXPECT_EQ(test_submitted_form().origin, passwords_data().origin()); |
304 TestAllUpdates(); | 305 TestAllUpdates(); |
305 } | 306 } |
306 | 307 |
307 TEST_F(ManagePasswordsStateTest, PasswordSubmittedFederationsPresent) { | 308 TEST_F(ManagePasswordsStateTest, PasswordSubmittedFederationsPresent) { |
308 scoped_ptr<password_manager::PasswordFormManager> test_form_manager( | 309 std::unique_ptr<password_manager::PasswordFormManager> test_form_manager( |
309 CreateFormManagerWithFederation()); | 310 CreateFormManagerWithFederation()); |
310 test_form_manager->ProvisionallySave( | 311 test_form_manager->ProvisionallySave( |
311 test_submitted_form(), | 312 test_submitted_form(), |
312 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 313 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
313 passwords_data().OnPendingPassword(std::move(test_form_manager)); | 314 passwords_data().OnPendingPassword(std::move(test_form_manager)); |
314 | 315 |
315 EXPECT_THAT(passwords_data().GetCurrentForms(), | 316 EXPECT_THAT(passwords_data().GetCurrentForms(), |
316 ElementsAre(Pointee(test_local_federated_form()))); | 317 ElementsAre(Pointee(test_local_federated_form()))); |
317 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 318 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
318 } | 319 } |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
363 passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE); | 364 passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE); |
364 EXPECT_THAT(passwords_data().GetCurrentForms(), | 365 EXPECT_THAT(passwords_data().GetCurrentForms(), |
365 ElementsAre(Pointee(test_local_form()))); | 366 ElementsAre(Pointee(test_local_form()))); |
366 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 367 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
367 EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state()); | 368 EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state()); |
368 EXPECT_EQ(test_local_form().origin, passwords_data().origin()); | 369 EXPECT_EQ(test_local_form().origin, passwords_data().origin()); |
369 TestAllUpdates(); | 370 TestAllUpdates(); |
370 } | 371 } |
371 | 372 |
372 TEST_F(ManagePasswordsStateTest, AutomaticPasswordSave) { | 373 TEST_F(ManagePasswordsStateTest, AutomaticPasswordSave) { |
373 scoped_ptr<password_manager::PasswordFormManager> test_form_manager( | 374 std::unique_ptr<password_manager::PasswordFormManager> test_form_manager( |
374 CreateFormManager()); | 375 CreateFormManager()); |
375 test_form_manager->ProvisionallySave( | 376 test_form_manager->ProvisionallySave( |
376 test_submitted_form(), | 377 test_submitted_form(), |
377 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 378 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
378 | 379 |
379 passwords_data().OnAutomaticPasswordSave(std::move(test_form_manager)); | 380 passwords_data().OnAutomaticPasswordSave(std::move(test_form_manager)); |
380 EXPECT_EQ(password_manager::ui::CONFIRMATION_STATE, passwords_data().state()); | 381 EXPECT_EQ(password_manager::ui::CONFIRMATION_STATE, passwords_data().state()); |
381 EXPECT_EQ(test_submitted_form().origin, passwords_data().origin()); | 382 EXPECT_EQ(test_submitted_form().origin, passwords_data().origin()); |
382 ASSERT_TRUE(passwords_data().form_manager()); | 383 ASSERT_TRUE(passwords_data().form_manager()); |
383 EXPECT_EQ(test_submitted_form(), | 384 EXPECT_EQ(test_submitted_form(), |
384 passwords_data().form_manager()->pending_credentials()); | 385 passwords_data().form_manager()->pending_credentials()); |
385 TestAllUpdates(); | 386 TestAllUpdates(); |
386 | 387 |
387 passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE); | 388 passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE); |
388 EXPECT_THAT(passwords_data().GetCurrentForms(), | 389 EXPECT_THAT(passwords_data().GetCurrentForms(), |
389 ElementsAre(Pointee(test_submitted_form()))); | 390 ElementsAre(Pointee(test_submitted_form()))); |
390 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 391 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
391 EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state()); | 392 EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state()); |
392 EXPECT_EQ(test_submitted_form().origin, passwords_data().origin()); | 393 EXPECT_EQ(test_submitted_form().origin, passwords_data().origin()); |
393 TestAllUpdates(); | 394 TestAllUpdates(); |
394 } | 395 } |
395 | 396 |
396 TEST_F(ManagePasswordsStateTest, AutomaticPasswordSaveWithFederations) { | 397 TEST_F(ManagePasswordsStateTest, AutomaticPasswordSaveWithFederations) { |
397 scoped_ptr<password_manager::PasswordFormManager> test_form_manager( | 398 std::unique_ptr<password_manager::PasswordFormManager> test_form_manager( |
398 CreateFormManagerWithFederation()); | 399 CreateFormManagerWithFederation()); |
399 test_form_manager->ProvisionallySave( | 400 test_form_manager->ProvisionallySave( |
400 test_submitted_form(), | 401 test_submitted_form(), |
401 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 402 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
402 | 403 |
403 passwords_data().OnAutomaticPasswordSave(std::move(test_form_manager)); | 404 passwords_data().OnAutomaticPasswordSave(std::move(test_form_manager)); |
404 EXPECT_THAT(passwords_data().GetCurrentForms(), | 405 EXPECT_THAT(passwords_data().GetCurrentForms(), |
405 UnorderedElementsAre(Pointee(test_submitted_form()), | 406 UnorderedElementsAre(Pointee(test_submitted_form()), |
406 Pointee(test_local_federated_form()))); | 407 Pointee(test_local_federated_form()))); |
407 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 408 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
408 } | 409 } |
409 | 410 |
410 TEST_F(ManagePasswordsStateTest, PasswordAutofilled) { | 411 TEST_F(ManagePasswordsStateTest, PasswordAutofilled) { |
411 autofill::PasswordFormMap password_form_map; | 412 autofill::PasswordFormMap password_form_map; |
412 password_form_map.insert(std::make_pair( | 413 password_form_map.insert(std::make_pair( |
413 test_local_form().username_value, | 414 test_local_form().username_value, |
414 make_scoped_ptr(new autofill::PasswordForm(test_local_form())))); | 415 base::WrapUnique(new autofill::PasswordForm(test_local_form())))); |
415 GURL origin("https://example.com"); | 416 GURL origin("https://example.com"); |
416 passwords_data().OnPasswordAutofilled(password_form_map, origin, nullptr); | 417 passwords_data().OnPasswordAutofilled(password_form_map, origin, nullptr); |
417 | 418 |
418 EXPECT_THAT(passwords_data().GetCurrentForms(), | 419 EXPECT_THAT(passwords_data().GetCurrentForms(), |
419 ElementsAre(Pointee(test_local_form()))); | 420 ElementsAre(Pointee(test_local_form()))); |
420 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 421 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
421 EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state()); | 422 EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state()); |
422 EXPECT_EQ(origin, passwords_data().origin()); | 423 EXPECT_EQ(origin, passwords_data().origin()); |
423 | 424 |
424 // |passwords_data| should hold a separate copy of test_local_form(). | 425 // |passwords_data| should hold a separate copy of test_local_form(). |
425 EXPECT_THAT(passwords_data().GetCurrentForms(), | 426 EXPECT_THAT(passwords_data().GetCurrentForms(), |
426 Not(Contains(&test_local_form()))); | 427 Not(Contains(&test_local_form()))); |
427 TestAllUpdates(); | 428 TestAllUpdates(); |
428 } | 429 } |
429 | 430 |
430 TEST_F(ManagePasswordsStateTest, PasswordAutofillWithSavedFederations) { | 431 TEST_F(ManagePasswordsStateTest, PasswordAutofillWithSavedFederations) { |
431 autofill::PasswordFormMap password_form_map; | 432 autofill::PasswordFormMap password_form_map; |
432 password_form_map.insert(std::make_pair( | 433 password_form_map.insert(std::make_pair( |
433 test_local_form().username_value, | 434 test_local_form().username_value, |
434 make_scoped_ptr(new autofill::PasswordForm(test_local_form())))); | 435 base::WrapUnique(new autofill::PasswordForm(test_local_form())))); |
435 GURL origin("https://example.com"); | 436 GURL origin("https://example.com"); |
436 std::vector<scoped_ptr<autofill::PasswordForm>> federated; | 437 std::vector<std::unique_ptr<autofill::PasswordForm>> federated; |
437 federated.push_back( | 438 federated.push_back(base::WrapUnique( |
438 make_scoped_ptr(new autofill::PasswordForm(test_local_federated_form()))); | 439 new autofill::PasswordForm(test_local_federated_form()))); |
439 passwords_data().OnPasswordAutofilled(password_form_map, origin, &federated); | 440 passwords_data().OnPasswordAutofilled(password_form_map, origin, &federated); |
440 | 441 |
441 // |federated| represents the locally saved federations. These are bundled in | 442 // |federated| represents the locally saved federations. These are bundled in |
442 // the "current forms". | 443 // the "current forms". |
443 EXPECT_THAT(passwords_data().GetCurrentForms(), | 444 EXPECT_THAT(passwords_data().GetCurrentForms(), |
444 UnorderedElementsAre(Pointee(test_local_form()), | 445 UnorderedElementsAre(Pointee(test_local_form()), |
445 Pointee(test_local_federated_form()))); | 446 Pointee(test_local_federated_form()))); |
446 // |federated_credentials_forms()| do not refer to the saved federations. | 447 // |federated_credentials_forms()| do not refer to the saved federations. |
447 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 448 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
448 EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state()); | 449 EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state()); |
449 } | 450 } |
450 | 451 |
451 TEST_F(ManagePasswordsStateTest, ActiveOnMixedPSLAndNonPSLMatched) { | 452 TEST_F(ManagePasswordsStateTest, ActiveOnMixedPSLAndNonPSLMatched) { |
452 autofill::PasswordFormMap password_form_map; | 453 autofill::PasswordFormMap password_form_map; |
453 password_form_map.insert(std::make_pair( | 454 password_form_map.insert(std::make_pair( |
454 test_local_form().username_value, | 455 test_local_form().username_value, |
455 make_scoped_ptr(new autofill::PasswordForm(test_local_form())))); | 456 base::WrapUnique(new autofill::PasswordForm(test_local_form())))); |
456 autofill::PasswordForm psl_matched_test_form = test_local_form(); | 457 autofill::PasswordForm psl_matched_test_form = test_local_form(); |
457 psl_matched_test_form.is_public_suffix_match = true; | 458 psl_matched_test_form.is_public_suffix_match = true; |
458 password_form_map.insert(std::make_pair( | 459 password_form_map.insert(std::make_pair( |
459 psl_matched_test_form.username_value, | 460 psl_matched_test_form.username_value, |
460 make_scoped_ptr(new autofill::PasswordForm(psl_matched_test_form)))); | 461 base::WrapUnique(new autofill::PasswordForm(psl_matched_test_form)))); |
461 GURL origin("https://example.com"); | 462 GURL origin("https://example.com"); |
462 passwords_data().OnPasswordAutofilled(password_form_map, origin, nullptr); | 463 passwords_data().OnPasswordAutofilled(password_form_map, origin, nullptr); |
463 | 464 |
464 EXPECT_THAT(passwords_data().GetCurrentForms(), | 465 EXPECT_THAT(passwords_data().GetCurrentForms(), |
465 ElementsAre(Pointee(test_local_form()))); | 466 ElementsAre(Pointee(test_local_form()))); |
466 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 467 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
467 EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state()); | 468 EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state()); |
468 EXPECT_EQ(origin, passwords_data().origin()); | 469 EXPECT_EQ(origin, passwords_data().origin()); |
469 | 470 |
470 // |passwords_data| should hold a separate copy of test_local_form(). | 471 // |passwords_data| should hold a separate copy of test_local_form(). |
471 EXPECT_THAT(passwords_data().GetCurrentForms(), | 472 EXPECT_THAT(passwords_data().GetCurrentForms(), |
472 Not(Contains(&test_local_form()))); | 473 Not(Contains(&test_local_form()))); |
473 TestAllUpdates(); | 474 TestAllUpdates(); |
474 } | 475 } |
475 | 476 |
476 TEST_F(ManagePasswordsStateTest, InactiveOnPSLMatched) { | 477 TEST_F(ManagePasswordsStateTest, InactiveOnPSLMatched) { |
477 autofill::PasswordForm psl_matched_test_form = test_local_form(); | 478 autofill::PasswordForm psl_matched_test_form = test_local_form(); |
478 psl_matched_test_form.is_public_suffix_match = true; | 479 psl_matched_test_form.is_public_suffix_match = true; |
479 autofill::PasswordFormMap password_form_map; | 480 autofill::PasswordFormMap password_form_map; |
480 password_form_map.insert(std::make_pair( | 481 password_form_map.insert(std::make_pair( |
481 psl_matched_test_form.username_value, | 482 psl_matched_test_form.username_value, |
482 make_scoped_ptr(new autofill::PasswordForm(psl_matched_test_form)))); | 483 base::WrapUnique(new autofill::PasswordForm(psl_matched_test_form)))); |
483 passwords_data().OnPasswordAutofilled( | 484 passwords_data().OnPasswordAutofilled( |
484 password_form_map, GURL("https://m.example.com/"), nullptr); | 485 password_form_map, GURL("https://m.example.com/"), nullptr); |
485 | 486 |
486 EXPECT_THAT(passwords_data().GetCurrentForms(), IsEmpty()); | 487 EXPECT_THAT(passwords_data().GetCurrentForms(), IsEmpty()); |
487 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 488 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
488 EXPECT_EQ(password_manager::ui::INACTIVE_STATE, passwords_data().state()); | 489 EXPECT_EQ(password_manager::ui::INACTIVE_STATE, passwords_data().state()); |
489 EXPECT_EQ(GURL::EmptyGURL(), passwords_data().origin()); | 490 EXPECT_EQ(GURL::EmptyGURL(), passwords_data().origin()); |
490 EXPECT_FALSE(passwords_data().form_manager()); | 491 EXPECT_FALSE(passwords_data().form_manager()); |
491 } | 492 } |
492 | 493 |
493 TEST_F(ManagePasswordsStateTest, OnInactive) { | 494 TEST_F(ManagePasswordsStateTest, OnInactive) { |
494 scoped_ptr<password_manager::PasswordFormManager> test_form_manager( | 495 std::unique_ptr<password_manager::PasswordFormManager> test_form_manager( |
495 CreateFormManager()); | 496 CreateFormManager()); |
496 test_form_manager->ProvisionallySave( | 497 test_form_manager->ProvisionallySave( |
497 test_submitted_form(), | 498 test_submitted_form(), |
498 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 499 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
499 passwords_data().OnPendingPassword(std::move(test_form_manager)); | 500 passwords_data().OnPendingPassword(std::move(test_form_manager)); |
500 EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE, | 501 EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE, |
501 passwords_data().state()); | 502 passwords_data().state()); |
502 passwords_data().OnInactive(); | 503 passwords_data().OnInactive(); |
503 EXPECT_THAT(passwords_data().GetCurrentForms(), IsEmpty()); | 504 EXPECT_THAT(passwords_data().GetCurrentForms(), IsEmpty()); |
504 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 505 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
505 EXPECT_EQ(password_manager::ui::INACTIVE_STATE, passwords_data().state()); | 506 EXPECT_EQ(password_manager::ui::INACTIVE_STATE, passwords_data().state()); |
506 EXPECT_EQ(GURL::EmptyGURL(), passwords_data().origin()); | 507 EXPECT_EQ(GURL::EmptyGURL(), passwords_data().origin()); |
507 EXPECT_FALSE(passwords_data().form_manager()); | 508 EXPECT_FALSE(passwords_data().form_manager()); |
508 TestNoisyUpdates(); | 509 TestNoisyUpdates(); |
509 } | 510 } |
510 | 511 |
511 TEST_F(ManagePasswordsStateTest, PendingPasswordAddBlacklisted) { | 512 TEST_F(ManagePasswordsStateTest, PendingPasswordAddBlacklisted) { |
512 scoped_ptr<password_manager::PasswordFormManager> test_form_manager( | 513 std::unique_ptr<password_manager::PasswordFormManager> test_form_manager( |
513 CreateFormManager()); | 514 CreateFormManager()); |
514 test_form_manager->ProvisionallySave( | 515 test_form_manager->ProvisionallySave( |
515 test_submitted_form(), | 516 test_submitted_form(), |
516 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 517 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
517 passwords_data().OnPendingPassword(std::move(test_form_manager)); | 518 passwords_data().OnPendingPassword(std::move(test_form_manager)); |
518 EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE, | 519 EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE, |
519 passwords_data().state()); | 520 passwords_data().state()); |
520 | 521 |
521 TestBlacklistedUpdates(); | 522 TestBlacklistedUpdates(); |
522 } | 523 } |
(...skipping 19 matching lines...) Expand all Loading... |
542 ScopedVector<autofill::PasswordForm> local_credentials; | 543 ScopedVector<autofill::PasswordForm> local_credentials; |
543 local_credentials.push_back(new autofill::PasswordForm(test_local_form())); | 544 local_credentials.push_back(new autofill::PasswordForm(test_local_form())); |
544 passwords_data().OnAutoSignin(std::move(local_credentials), | 545 passwords_data().OnAutoSignin(std::move(local_credentials), |
545 test_local_form().origin); | 546 test_local_form().origin); |
546 EXPECT_EQ(password_manager::ui::AUTO_SIGNIN_STATE, passwords_data().state()); | 547 EXPECT_EQ(password_manager::ui::AUTO_SIGNIN_STATE, passwords_data().state()); |
547 | 548 |
548 TestBlacklistedUpdates(); | 549 TestBlacklistedUpdates(); |
549 } | 550 } |
550 | 551 |
551 TEST_F(ManagePasswordsStateTest, AutomaticPasswordSaveAddBlacklisted) { | 552 TEST_F(ManagePasswordsStateTest, AutomaticPasswordSaveAddBlacklisted) { |
552 scoped_ptr<password_manager::PasswordFormManager> test_form_manager( | 553 std::unique_ptr<password_manager::PasswordFormManager> test_form_manager( |
553 CreateFormManager()); | 554 CreateFormManager()); |
554 test_form_manager->ProvisionallySave( | 555 test_form_manager->ProvisionallySave( |
555 test_submitted_form(), | 556 test_submitted_form(), |
556 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 557 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
557 passwords_data().OnAutomaticPasswordSave(std::move(test_form_manager)); | 558 passwords_data().OnAutomaticPasswordSave(std::move(test_form_manager)); |
558 EXPECT_EQ(password_manager::ui::CONFIRMATION_STATE, passwords_data().state()); | 559 EXPECT_EQ(password_manager::ui::CONFIRMATION_STATE, passwords_data().state()); |
559 | 560 |
560 TestBlacklistedUpdates(); | 561 TestBlacklistedUpdates(); |
561 } | 562 } |
562 | 563 |
563 TEST_F(ManagePasswordsStateTest, BackgroundAutofilledAddBlacklisted) { | 564 TEST_F(ManagePasswordsStateTest, BackgroundAutofilledAddBlacklisted) { |
564 autofill::PasswordFormMap password_form_map; | 565 autofill::PasswordFormMap password_form_map; |
565 password_form_map.insert(std::make_pair( | 566 password_form_map.insert(std::make_pair( |
566 test_local_form().username_value, | 567 test_local_form().username_value, |
567 make_scoped_ptr(new autofill::PasswordForm(test_local_form())))); | 568 base::WrapUnique(new autofill::PasswordForm(test_local_form())))); |
568 passwords_data().OnPasswordAutofilled( | 569 passwords_data().OnPasswordAutofilled( |
569 password_form_map, password_form_map.begin()->second->origin, nullptr); | 570 password_form_map, password_form_map.begin()->second->origin, nullptr); |
570 EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state()); | 571 EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state()); |
571 | 572 |
572 TestBlacklistedUpdates(); | 573 TestBlacklistedUpdates(); |
573 } | 574 } |
574 | 575 |
575 TEST_F(ManagePasswordsStateTest, PasswordUpdateAddBlacklisted) { | 576 TEST_F(ManagePasswordsStateTest, PasswordUpdateAddBlacklisted) { |
576 scoped_ptr<password_manager::PasswordFormManager> test_form_manager( | 577 std::unique_ptr<password_manager::PasswordFormManager> test_form_manager( |
577 CreateFormManager()); | 578 CreateFormManager()); |
578 test_form_manager->ProvisionallySave( | 579 test_form_manager->ProvisionallySave( |
579 test_submitted_form(), | 580 test_submitted_form(), |
580 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 581 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
581 passwords_data().OnUpdatePassword(std::move(test_form_manager)); | 582 passwords_data().OnUpdatePassword(std::move(test_form_manager)); |
582 EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_UPDATE_STATE, | 583 EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_UPDATE_STATE, |
583 passwords_data().state()); | 584 passwords_data().state()); |
584 | 585 |
585 TestBlacklistedUpdates(); | 586 TestBlacklistedUpdates(); |
586 } | 587 } |
587 | 588 |
588 TEST_F(ManagePasswordsStateTest, PasswordUpdateSubmitted) { | 589 TEST_F(ManagePasswordsStateTest, PasswordUpdateSubmitted) { |
589 test_stored_forms().push_back(new autofill::PasswordForm(test_local_form())); | 590 test_stored_forms().push_back(new autofill::PasswordForm(test_local_form())); |
590 scoped_ptr<password_manager::PasswordFormManager> test_form_manager( | 591 std::unique_ptr<password_manager::PasswordFormManager> test_form_manager( |
591 CreateFormManager()); | 592 CreateFormManager()); |
592 test_form_manager->ProvisionallySave( | 593 test_form_manager->ProvisionallySave( |
593 test_submitted_form(), | 594 test_submitted_form(), |
594 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 595 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
595 passwords_data().OnUpdatePassword(std::move(test_form_manager)); | 596 passwords_data().OnUpdatePassword(std::move(test_form_manager)); |
596 | 597 |
597 EXPECT_THAT(passwords_data().GetCurrentForms(), | 598 EXPECT_THAT(passwords_data().GetCurrentForms(), |
598 ElementsAre(Pointee(test_local_form()))); | 599 ElementsAre(Pointee(test_local_form()))); |
599 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 600 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
600 EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_UPDATE_STATE, | 601 EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_UPDATE_STATE, |
601 passwords_data().state()); | 602 passwords_data().state()); |
602 EXPECT_EQ(test_submitted_form().origin, passwords_data().origin()); | 603 EXPECT_EQ(test_submitted_form().origin, passwords_data().origin()); |
603 ASSERT_TRUE(passwords_data().form_manager()); | 604 ASSERT_TRUE(passwords_data().form_manager()); |
604 EXPECT_EQ(test_submitted_form(), | 605 EXPECT_EQ(test_submitted_form(), |
605 passwords_data().form_manager()->pending_credentials()); | 606 passwords_data().form_manager()->pending_credentials()); |
606 TestAllUpdates(); | 607 TestAllUpdates(); |
607 } | 608 } |
608 | 609 |
609 TEST_F(ManagePasswordsStateTest, AndroidPasswordUpdateSubmitted) { | 610 TEST_F(ManagePasswordsStateTest, AndroidPasswordUpdateSubmitted) { |
610 autofill::PasswordForm android_form; | 611 autofill::PasswordForm android_form; |
611 android_form.signon_realm = "android://dHJhc2g=@com.example.android/"; | 612 android_form.signon_realm = "android://dHJhc2g=@com.example.android/"; |
612 android_form.origin = GURL(android_form.signon_realm); | 613 android_form.origin = GURL(android_form.signon_realm); |
613 android_form.username_value = test_submitted_form().username_value; | 614 android_form.username_value = test_submitted_form().username_value; |
614 android_form.password_value = base::ASCIIToUTF16("old pass"); | 615 android_form.password_value = base::ASCIIToUTF16("old pass"); |
615 test_stored_forms().push_back(new autofill::PasswordForm(android_form)); | 616 test_stored_forms().push_back(new autofill::PasswordForm(android_form)); |
616 scoped_ptr<password_manager::PasswordFormManager> test_form_manager( | 617 std::unique_ptr<password_manager::PasswordFormManager> test_form_manager( |
617 CreateFormManager()); | 618 CreateFormManager()); |
618 test_form_manager->ProvisionallySave( | 619 test_form_manager->ProvisionallySave( |
619 test_submitted_form(), | 620 test_submitted_form(), |
620 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 621 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
621 passwords_data().OnUpdatePassword(std::move(test_form_manager)); | 622 passwords_data().OnUpdatePassword(std::move(test_form_manager)); |
622 | 623 |
623 EXPECT_THAT(passwords_data().GetCurrentForms(), | 624 EXPECT_THAT(passwords_data().GetCurrentForms(), |
624 ElementsAre(Pointee(android_form))); | 625 ElementsAre(Pointee(android_form))); |
625 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 626 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
626 EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_UPDATE_STATE, | 627 EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_UPDATE_STATE, |
627 passwords_data().state()); | 628 passwords_data().state()); |
628 EXPECT_EQ(test_submitted_form().origin, passwords_data().origin()); | 629 EXPECT_EQ(test_submitted_form().origin, passwords_data().origin()); |
629 ASSERT_TRUE(passwords_data().form_manager()); | 630 ASSERT_TRUE(passwords_data().form_manager()); |
630 android_form.password_value = test_submitted_form().password_value; | 631 android_form.password_value = test_submitted_form().password_value; |
631 EXPECT_EQ(android_form, | 632 EXPECT_EQ(android_form, |
632 passwords_data().form_manager()->pending_credentials()); | 633 passwords_data().form_manager()->pending_credentials()); |
633 TestAllUpdates(); | 634 TestAllUpdates(); |
634 } | 635 } |
635 | 636 |
636 TEST_F(ManagePasswordsStateTest, PasswordUpdateSubmittedWithFederations) { | 637 TEST_F(ManagePasswordsStateTest, PasswordUpdateSubmittedWithFederations) { |
637 test_stored_forms().push_back(new autofill::PasswordForm(test_local_form())); | 638 test_stored_forms().push_back(new autofill::PasswordForm(test_local_form())); |
638 scoped_ptr<password_manager::PasswordFormManager> test_form_manager( | 639 std::unique_ptr<password_manager::PasswordFormManager> test_form_manager( |
639 CreateFormManagerWithFederation()); | 640 CreateFormManagerWithFederation()); |
640 test_form_manager->ProvisionallySave( | 641 test_form_manager->ProvisionallySave( |
641 test_submitted_form(), | 642 test_submitted_form(), |
642 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 643 password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
643 passwords_data().OnUpdatePassword(std::move(test_form_manager)); | 644 passwords_data().OnUpdatePassword(std::move(test_form_manager)); |
644 | 645 |
645 EXPECT_THAT(passwords_data().GetCurrentForms(), | 646 EXPECT_THAT(passwords_data().GetCurrentForms(), |
646 UnorderedElementsAre(Pointee(test_local_form()), | 647 UnorderedElementsAre(Pointee(test_local_form()), |
647 Pointee(test_local_federated_form()))); | 648 Pointee(test_local_federated_form()))); |
648 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); | 649 EXPECT_THAT(passwords_data().federated_credentials_forms(), IsEmpty()); |
(...skipping 26 matching lines...) Expand all Loading... |
675 passwords_data().OnRequestCredentials(ScopedVector<autofill::PasswordForm>(), | 676 passwords_data().OnRequestCredentials(ScopedVector<autofill::PasswordForm>(), |
676 ScopedVector<autofill::PasswordForm>(), | 677 ScopedVector<autofill::PasswordForm>(), |
677 test_local_form().origin); | 678 test_local_form().origin); |
678 passwords_data().set_credentials_callback(base::Bind( | 679 passwords_data().set_credentials_callback(base::Bind( |
679 &ManagePasswordsStateTest::CredentialCallback, base::Unretained(this))); | 680 &ManagePasswordsStateTest::CredentialCallback, base::Unretained(this))); |
680 EXPECT_CALL(*this, CredentialCallback(&test_local_federated_form())); | 681 EXPECT_CALL(*this, CredentialCallback(&test_local_federated_form())); |
681 passwords_data().ChooseCredential(&test_local_federated_form()); | 682 passwords_data().ChooseCredential(&test_local_federated_form()); |
682 } | 683 } |
683 | 684 |
684 } // namespace | 685 } // namespace |
OLD | NEW |