OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "components/password_manager/core/browser/password_form_manager.h" | 5 #include "components/password_manager/core/browser/password_form_manager.h" |
6 | 6 |
7 #include <map> | 7 #include <map> |
8 #include <memory> | 8 #include <memory> |
9 #include <set> | 9 #include <set> |
10 #include <utility> | 10 #include <utility> |
(...skipping 369 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
380 field.name = ASCIIToUTF16("Email"); | 380 field.name = ASCIIToUTF16("Email"); |
381 field.form_control_type = "text"; | 381 field.form_control_type = "text"; |
382 saved_match_.form_data.fields.push_back(field); | 382 saved_match_.form_data.fields.push_back(field); |
383 | 383 |
384 field.label = ASCIIToUTF16("password"); | 384 field.label = ASCIIToUTF16("password"); |
385 field.name = ASCIIToUTF16("Passwd"); | 385 field.name = ASCIIToUTF16("Passwd"); |
386 field.form_control_type = "password"; | 386 field.form_control_type = "password"; |
387 saved_match_.form_data.fields.push_back(field); | 387 saved_match_.form_data.fields.push_back(field); |
388 | 388 |
389 password_manager_.reset(new PasswordManager(&client_)); | 389 password_manager_.reset(new PasswordManager(&client_)); |
390 form_manager_.reset(new PasswordFormManager( | 390 form_manager_ = base::MakeRefCounted<PasswordFormManager>( |
391 password_manager_.get(), &client_, client_.driver(), observed_form_, | 391 password_manager_.get(), &client_, client_.driver(), observed_form_, |
392 base::MakeUnique<NiceMock<MockFormSaver>>(), &fake_form_fetcher_)); | 392 base::MakeUnique<NiceMock<MockFormSaver>>(), &fake_form_fetcher_); |
393 } | 393 } |
394 | 394 |
395 // Save saved_match() for observed_form() where |observed_form_data|, | 395 // Save saved_match() for observed_form() where |observed_form_data|, |
396 // |times_used|, and |status| are used to overwrite the default values for | 396 // |times_used|, and |status| are used to overwrite the default values for |
397 // observed_form(). |field_type| is the upload that we expect from saving, | 397 // observed_form(). |field_type| is the upload that we expect from saving, |
398 // with nullptr meaning no upload expected. | 398 // with nullptr meaning no upload expected. |
399 void AccountCreationUploadTest(const autofill::FormData& observed_form_data, | 399 void AccountCreationUploadTest(const autofill::FormData& observed_form_data, |
400 int times_used, | 400 int times_used, |
401 PasswordForm::GenerationUploadStatus status, | 401 PasswordForm::GenerationUploadStatus status, |
402 const autofill::ServerFieldType* field_type) { | 402 const autofill::ServerFieldType* field_type) { |
403 PasswordForm form(*observed_form()); | 403 PasswordForm form(*observed_form()); |
404 | 404 |
405 form.form_data = observed_form_data; | 405 form.form_data = observed_form_data; |
406 | 406 |
407 FakeFormFetcher fetcher; | 407 FakeFormFetcher fetcher; |
408 fetcher.Fetch(); | 408 fetcher.Fetch(); |
409 PasswordFormManager form_manager( | 409 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
vasilii
2017/05/29 13:15:48
Prefer base::MakeRefCounted to new
kolos1
2017/05/29 15:47:06
Done.
| |
410 password_manager(), client(), client()->driver(), form, | 410 password_manager(), client(), client()->driver(), form, |
411 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 411 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
412 PasswordForm match = CreateSavedMatch(false); | 412 PasswordForm match = CreateSavedMatch(false); |
413 match.generation_upload_status = status; | 413 match.generation_upload_status = status; |
414 match.times_used = times_used; | 414 match.times_used = times_used; |
415 | 415 |
416 PasswordForm form_to_save(form); | 416 PasswordForm form_to_save(form); |
417 form_to_save.preferred = true; | 417 form_to_save.preferred = true; |
418 form_to_save.username_element = ASCIIToUTF16("observed-username-field"); | 418 form_to_save.username_element = ASCIIToUTF16("observed-username-field"); |
419 form_to_save.username_value = match.username_value; | 419 form_to_save.username_value = match.username_value; |
420 form_to_save.password_value = match.password_value; | 420 form_to_save.password_value = match.password_value; |
421 | 421 |
422 fetcher.SetNonFederated({&match}, 0u); | 422 fetcher.SetNonFederated({&match}, 0u); |
423 std::string expected_login_signature; | 423 std::string expected_login_signature; |
424 autofill::FormStructure observed_structure(observed_form_data); | 424 autofill::FormStructure observed_structure(observed_form_data); |
425 autofill::FormStructure pending_structure(saved_match()->form_data); | 425 autofill::FormStructure pending_structure(saved_match()->form_data); |
426 if (observed_structure.FormSignatureAsStr() != | 426 if (observed_structure.FormSignatureAsStr() != |
427 pending_structure.FormSignatureAsStr() && | 427 pending_structure.FormSignatureAsStr() && |
428 times_used == 0) { | 428 times_used == 0) { |
429 expected_login_signature = observed_structure.FormSignatureAsStr(); | 429 expected_login_signature = observed_structure.FormSignatureAsStr(); |
430 } | 430 } |
431 autofill::ServerFieldTypeSet expected_available_field_types; | 431 autofill::ServerFieldTypeSet expected_available_field_types; |
432 FieldTypeMap expected_types; | 432 FieldTypeMap expected_types; |
433 expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE; | 433 expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE; |
434 expected_types[match.username_element] = autofill::UNKNOWN_TYPE; | 434 expected_types[match.username_element] = autofill::UNKNOWN_TYPE; |
435 | 435 |
436 bool expect_generation_vote = false; | 436 bool expect_generation_vote = false; |
437 if (field_type) { | 437 if (field_type) { |
438 // Show the password generation popup to check that the generation vote | 438 // Show the password generation popup to check that the generation vote |
439 // would be ignored. | 439 // would be ignored. |
440 form_manager.set_generation_element(saved_match()->password_element); | 440 form_manager->set_generation_element(saved_match()->password_element); |
441 form_manager.set_generation_popup_was_shown(true); | 441 form_manager->set_generation_popup_was_shown(true); |
442 expect_generation_vote = | 442 expect_generation_vote = |
443 *field_type != autofill::ACCOUNT_CREATION_PASSWORD; | 443 *field_type != autofill::ACCOUNT_CREATION_PASSWORD; |
444 | 444 |
445 expected_available_field_types.insert(*field_type); | 445 expected_available_field_types.insert(*field_type); |
446 expected_types[saved_match()->password_element] = *field_type; | 446 expected_types[saved_match()->password_element] = *field_type; |
447 } | 447 } |
448 | 448 |
449 if (field_type) { | 449 if (field_type) { |
450 EXPECT_CALL( | 450 EXPECT_CALL( |
451 *client()->mock_driver()->mock_autofill_download_manager(), | 451 *client()->mock_driver()->mock_autofill_download_manager(), |
452 StartUploadRequest(CheckUploadedAutofillTypesAndSignature( | 452 StartUploadRequest(CheckUploadedAutofillTypesAndSignature( |
453 pending_structure.FormSignatureAsStr(), | 453 pending_structure.FormSignatureAsStr(), |
454 expected_types, expect_generation_vote), | 454 expected_types, expect_generation_vote), |
455 false, expected_available_field_types, | 455 false, expected_available_field_types, |
456 expected_login_signature, true)); | 456 expected_login_signature, true)); |
457 } else { | 457 } else { |
458 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 458 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
459 StartUploadRequest(_, _, _, _, _)) | 459 StartUploadRequest(_, _, _, _, _)) |
460 .Times(0); | 460 .Times(0); |
461 } | 461 } |
462 form_manager.ProvisionallySave( | 462 form_manager->ProvisionallySave( |
463 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 463 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
464 form_manager.Save(); | 464 form_manager->Save(); |
465 Mock::VerifyAndClearExpectations( | 465 Mock::VerifyAndClearExpectations( |
466 client()->mock_driver()->mock_autofill_download_manager()); | 466 client()->mock_driver()->mock_autofill_download_manager()); |
467 } | 467 } |
468 | 468 |
469 // Test upload votes on change password forms. |field_type| is a vote that we | 469 // Test upload votes on change password forms. |field_type| is a vote that we |
470 // expect to be uploaded. | 470 // expect to be uploaded. |
471 void ChangePasswordUploadTest(autofill::ServerFieldType field_type, | 471 void ChangePasswordUploadTest(autofill::ServerFieldType field_type, |
472 bool has_confirmation_field) { | 472 bool has_confirmation_field) { |
473 SCOPED_TRACE(testing::Message() | 473 SCOPED_TRACE(testing::Message() |
474 << "field_type=" << field_type | 474 << "field_type=" << field_type |
(...skipping 13 matching lines...) Expand all Loading... | |
488 observed_form()->form_data.fields.push_back(empty_field); | 488 observed_form()->form_data.fields.push_back(empty_field); |
489 if (has_confirmation_field) { | 489 if (has_confirmation_field) { |
490 field.label = ASCIIToUTF16("ConfPwd"); | 490 field.label = ASCIIToUTF16("ConfPwd"); |
491 field.name = ASCIIToUTF16("ConfPwd"); | 491 field.name = ASCIIToUTF16("ConfPwd"); |
492 field.form_control_type = "password"; | 492 field.form_control_type = "password"; |
493 observed_form()->form_data.fields.push_back(field); | 493 observed_form()->form_data.fields.push_back(field); |
494 } | 494 } |
495 | 495 |
496 FakeFormFetcher fetcher; | 496 FakeFormFetcher fetcher; |
497 fetcher.Fetch(); | 497 fetcher.Fetch(); |
498 PasswordFormManager form_manager( | 498 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
499 password_manager(), client(), client()->driver(), *observed_form(), | 499 password_manager(), client(), client()->driver(), *observed_form(), |
500 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 500 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
501 fetcher.SetNonFederated({saved_match()}, 0u); | 501 fetcher.SetNonFederated({saved_match()}, 0u); |
502 | 502 |
503 // User submits current and new credentials to the observed form. | 503 // User submits current and new credentials to the observed form. |
504 PasswordForm submitted_form(*observed_form()); | 504 PasswordForm submitted_form(*observed_form()); |
505 // credentials.username_element.clear(); | 505 // credentials.username_element.clear(); |
506 submitted_form.username_value = saved_match()->username_value; | 506 submitted_form.username_value = saved_match()->username_value; |
507 submitted_form.password_value = saved_match()->password_value; | 507 submitted_form.password_value = saved_match()->password_value; |
508 submitted_form.new_password_value = ASCIIToUTF16("test2"); | 508 submitted_form.new_password_value = ASCIIToUTF16("test2"); |
509 submitted_form.preferred = true; | 509 submitted_form.preferred = true; |
510 form_manager.ProvisionallySave( | 510 form_manager->ProvisionallySave( |
511 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 511 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
512 | 512 |
513 // Successful login. The PasswordManager would instruct PasswordFormManager | 513 // Successful login. The PasswordManager would instruct PasswordFormManager |
514 // to update. | 514 // to update. |
515 EXPECT_FALSE(form_manager.IsNewLogin()); | 515 EXPECT_FALSE(form_manager->IsNewLogin()); |
516 EXPECT_FALSE( | 516 EXPECT_FALSE( |
517 form_manager.is_possible_change_password_form_without_username()); | 517 form_manager->is_possible_change_password_form_without_username()); |
518 | 518 |
519 // By now, the PasswordFormManager should have promoted the new password | 519 // By now, the PasswordFormManager should have promoted the new password |
520 // value already to be the current password, and should no longer maintain | 520 // value already to be the current password, and should no longer maintain |
521 // any info about the new password value. | 521 // any info about the new password value. |
522 EXPECT_EQ(submitted_form.new_password_value, | 522 EXPECT_EQ(submitted_form.new_password_value, |
523 form_manager.pending_credentials().password_value); | 523 form_manager->pending_credentials().password_value); |
524 EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty()); | 524 EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty()); |
525 | 525 |
526 std::map<base::string16, autofill::ServerFieldType> expected_types; | 526 std::map<base::string16, autofill::ServerFieldType> expected_types; |
527 expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE; | 527 expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE; |
528 expected_types[observed_form_.username_element] = autofill::UNKNOWN_TYPE; | 528 expected_types[observed_form_.username_element] = autofill::UNKNOWN_TYPE; |
529 expected_types[observed_form_.password_element] = autofill::PASSWORD; | 529 expected_types[observed_form_.password_element] = autofill::PASSWORD; |
530 expected_types[observed_form_.new_password_element] = field_type; | 530 expected_types[observed_form_.new_password_element] = field_type; |
531 expected_types[base::string16()] = autofill::UNKNOWN_TYPE; | 531 expected_types[base::string16()] = autofill::UNKNOWN_TYPE; |
532 | 532 |
533 autofill::ServerFieldTypeSet expected_available_field_types; | 533 autofill::ServerFieldTypeSet expected_available_field_types; |
534 expected_available_field_types.insert(autofill::PASSWORD); | 534 expected_available_field_types.insert(autofill::PASSWORD); |
(...skipping 15 matching lines...) Expand all Loading... | |
550 } | 550 } |
551 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 551 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
552 StartUploadRequest(CheckUploadedAutofillTypesAndSignature( | 552 StartUploadRequest(CheckUploadedAutofillTypesAndSignature( |
553 observed_form_signature, expected_types, | 553 observed_form_signature, expected_types, |
554 false /* expect_generation_vote */), | 554 false /* expect_generation_vote */), |
555 false, expected_available_field_types, | 555 false, expected_available_field_types, |
556 expected_login_signature, true)); | 556 expected_login_signature, true)); |
557 | 557 |
558 switch (field_type) { | 558 switch (field_type) { |
559 case autofill::NEW_PASSWORD: | 559 case autofill::NEW_PASSWORD: |
560 form_manager.Update(*saved_match()); | 560 form_manager->Update(*saved_match()); |
561 break; | 561 break; |
562 case autofill::PROBABLY_NEW_PASSWORD: | 562 case autofill::PROBABLY_NEW_PASSWORD: |
563 form_manager.OnNoInteraction(true /* it is an update */); | 563 form_manager->OnNoInteraction(true /* it is an update */); |
564 break; | 564 break; |
565 case autofill::NOT_NEW_PASSWORD: | 565 case autofill::NOT_NEW_PASSWORD: |
566 form_manager.OnNopeUpdateClicked(); | 566 form_manager->OnNopeUpdateClicked(); |
567 break; | 567 break; |
568 default: | 568 default: |
569 NOTREACHED(); | 569 NOTREACHED(); |
570 } | 570 } |
571 Mock::VerifyAndClearExpectations( | 571 Mock::VerifyAndClearExpectations( |
572 client()->mock_driver()->mock_autofill_download_manager()); | 572 client()->mock_driver()->mock_autofill_download_manager()); |
573 } | 573 } |
574 | 574 |
575 autofill::AutofillUploadContents::Field::PasswordGenerationType | 575 autofill::AutofillUploadContents::Field::PasswordGenerationType |
576 GetExpectedPasswordGenerationType(bool is_manual_generation, | 576 GetExpectedPasswordGenerationType(bool is_manual_generation, |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
631 submitted_form.username_value = saved_match()->username_value; | 631 submitted_form.username_value = saved_match()->username_value; |
632 submitted_form.password_value = saved_match()->password_value; | 632 submitted_form.password_value = saved_match()->password_value; |
633 | 633 |
634 if (is_change_password_form) { | 634 if (is_change_password_form) { |
635 submitted_form.new_password_value = | 635 submitted_form.new_password_value = |
636 saved_match()->password_value + ASCIIToUTF16("1"); | 636 saved_match()->password_value + ASCIIToUTF16("1"); |
637 } | 637 } |
638 | 638 |
639 FakeFormFetcher fetcher; | 639 FakeFormFetcher fetcher; |
640 fetcher.Fetch(); | 640 fetcher.Fetch(); |
641 PasswordFormManager form_manager( | 641 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
642 password_manager(), client(), client()->driver(), form, | 642 password_manager(), client(), client()->driver(), form, |
643 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 643 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
644 | 644 |
645 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 645 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
646 | 646 |
647 autofill::ServerFieldTypeSet expected_available_field_types; | 647 autofill::ServerFieldTypeSet expected_available_field_types; |
648 // Don't send autofill votes if the user didn't press "Save" button. | 648 // Don't send autofill votes if the user didn't press "Save" button. |
649 if (interaction == SAVE) | 649 if (interaction == SAVE) |
650 expected_available_field_types.insert(autofill::PASSWORD); | 650 expected_available_field_types.insert(autofill::PASSWORD); |
651 | 651 |
652 form_manager.set_is_manual_generation(is_manual_generation); | 652 form_manager->set_is_manual_generation(is_manual_generation); |
653 base::string16 generation_element = is_change_password_form | 653 base::string16 generation_element = is_change_password_form |
654 ? form.new_password_element | 654 ? form.new_password_element |
655 : form.password_element; | 655 : form.password_element; |
656 form_manager.set_generation_element(generation_element); | 656 form_manager->set_generation_element(generation_element); |
657 form_manager.set_generation_popup_was_shown(true); | 657 form_manager->set_generation_popup_was_shown(true); |
658 form_manager.set_has_generated_password(has_generated_password); | 658 form_manager->set_has_generated_password(has_generated_password); |
659 | 659 |
660 // Figure out expected generation event type. | 660 // Figure out expected generation event type. |
661 autofill::AutofillUploadContents::Field::PasswordGenerationType | 661 autofill::AutofillUploadContents::Field::PasswordGenerationType |
662 expected_generation_type = GetExpectedPasswordGenerationType( | 662 expected_generation_type = GetExpectedPasswordGenerationType( |
663 is_manual_generation, is_change_password_form, | 663 is_manual_generation, is_change_password_form, |
664 has_generated_password); | 664 has_generated_password); |
665 std::map<base::string16, | 665 std::map<base::string16, |
666 autofill::AutofillUploadContents::Field::PasswordGenerationType> | 666 autofill::AutofillUploadContents::Field::PasswordGenerationType> |
667 expected_generation_types; | 667 expected_generation_types; |
668 expected_generation_types[generation_element] = expected_generation_type; | 668 expected_generation_types[generation_element] = expected_generation_type; |
669 | 669 |
670 autofill::FormStructure form_structure(submitted_form.form_data); | 670 autofill::FormStructure form_structure(submitted_form.form_data); |
671 | 671 |
672 EXPECT_CALL( | 672 EXPECT_CALL( |
673 *client()->mock_driver()->mock_autofill_download_manager(), | 673 *client()->mock_driver()->mock_autofill_download_manager(), |
674 StartUploadRequest( | 674 StartUploadRequest( |
675 CheckUploadedGenerationTypesAndSignature( | 675 CheckUploadedGenerationTypesAndSignature( |
676 form_structure.FormSignatureAsStr(), expected_generation_types), | 676 form_structure.FormSignatureAsStr(), expected_generation_types), |
677 false, expected_available_field_types, std::string(), true)); | 677 false, expected_available_field_types, std::string(), true)); |
678 | 678 |
679 form_manager.ProvisionallySave( | 679 form_manager->ProvisionallySave( |
680 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 680 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
681 switch (interaction) { | 681 switch (interaction) { |
682 case SAVE: | 682 case SAVE: |
683 form_manager.Save(); | 683 form_manager->Save(); |
684 break; | 684 break; |
685 case NEVER: | 685 case NEVER: |
686 form_manager.OnNeverClicked(); | 686 form_manager->OnNeverClicked(); |
687 break; | 687 break; |
688 case NO_INTERACTION: | 688 case NO_INTERACTION: |
689 form_manager.OnNoInteraction(false /* not an update prompt*/); | 689 form_manager->OnNoInteraction(false /* not an update prompt*/); |
690 break; | 690 break; |
691 } | 691 } |
692 Mock::VerifyAndClearExpectations( | 692 Mock::VerifyAndClearExpectations( |
693 client()->mock_driver()->mock_autofill_download_manager()); | 693 client()->mock_driver()->mock_autofill_download_manager()); |
694 } | 694 } |
695 | 695 |
696 PasswordForm* observed_form() { return &observed_form_; } | 696 PasswordForm* observed_form() { return &observed_form_; } |
697 PasswordForm* saved_match() { return &saved_match_; } | 697 PasswordForm* saved_match() { return &saved_match_; } |
698 PasswordForm* psl_saved_match() { return &psl_saved_match_; } | 698 PasswordForm* psl_saved_match() { return &psl_saved_match_; } |
699 PasswordForm CreateSavedMatch(bool blacklisted) { | 699 PasswordForm CreateSavedMatch(bool blacklisted) { |
(...skipping 18 matching lines...) Expand all Loading... | |
718 base::MessageLoop message_loop_; | 718 base::MessageLoop message_loop_; |
719 | 719 |
720 PasswordForm observed_form_; | 720 PasswordForm observed_form_; |
721 PasswordForm saved_match_; | 721 PasswordForm saved_match_; |
722 PasswordForm psl_saved_match_; | 722 PasswordForm psl_saved_match_; |
723 TestPasswordManagerClient client_; | 723 TestPasswordManagerClient client_; |
724 std::unique_ptr<PasswordManager> password_manager_; | 724 std::unique_ptr<PasswordManager> password_manager_; |
725 // Define |fake_form_fetcher_| before |form_manager_|, because the former | 725 // Define |fake_form_fetcher_| before |form_manager_|, because the former |
726 // needs to outlive the latter. | 726 // needs to outlive the latter. |
727 FakeFormFetcher fake_form_fetcher_; | 727 FakeFormFetcher fake_form_fetcher_; |
728 std::unique_ptr<PasswordFormManager> form_manager_; | 728 scoped_refptr<PasswordFormManager> form_manager_; |
729 }; | 729 }; |
730 | 730 |
731 class PasswordFormManagerFillOnAccountSelectTest | 731 class PasswordFormManagerFillOnAccountSelectTest |
732 : public PasswordFormManagerTest { | 732 : public PasswordFormManagerTest { |
733 public: | 733 public: |
734 PasswordFormManagerFillOnAccountSelectTest() { | 734 PasswordFormManagerFillOnAccountSelectTest() { |
735 scoped_feature_list_.InitAndEnableFeature(features::kFillOnAccountSelect); | 735 scoped_feature_list_.InitAndEnableFeature(features::kFillOnAccountSelect); |
736 } | 736 } |
737 | 737 |
738 base::test::ScopedFeatureList scoped_feature_list_; | 738 base::test::ScopedFeatureList scoped_feature_list_; |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
837 } | 837 } |
838 | 838 |
839 // Test that stored blacklisted forms are correctly evaluated for whether they | 839 // Test that stored blacklisted forms are correctly evaluated for whether they |
840 // apply to the observed form. | 840 // apply to the observed form. |
841 TEST_F(PasswordFormManagerTest, TestBlacklistMatching) { | 841 TEST_F(PasswordFormManagerTest, TestBlacklistMatching) { |
842 observed_form()->origin = GURL("http://accounts.google.com/a/LoginAuth"); | 842 observed_form()->origin = GURL("http://accounts.google.com/a/LoginAuth"); |
843 observed_form()->action = GURL("http://accounts.google.com/a/Login"); | 843 observed_form()->action = GURL("http://accounts.google.com/a/Login"); |
844 observed_form()->signon_realm = "http://accounts.google.com"; | 844 observed_form()->signon_realm = "http://accounts.google.com"; |
845 FakeFormFetcher fetcher; | 845 FakeFormFetcher fetcher; |
846 fetcher.Fetch(); | 846 fetcher.Fetch(); |
847 PasswordFormManager form_manager(password_manager(), client(), | 847 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
848 client()->driver(), *observed_form(), | 848 password_manager(), client(), client()->driver(), *observed_form(), |
849 base::MakeUnique<MockFormSaver>(), &fetcher); | 849 base::MakeUnique<MockFormSaver>(), &fetcher)); |
850 | 850 |
851 // Doesn't apply because it is just a PSL match of the observed form. | 851 // Doesn't apply because it is just a PSL match of the observed form. |
852 PasswordForm blacklisted_psl = *observed_form(); | 852 PasswordForm blacklisted_psl = *observed_form(); |
853 blacklisted_psl.signon_realm = "http://m.accounts.google.com"; | 853 blacklisted_psl.signon_realm = "http://m.accounts.google.com"; |
854 blacklisted_psl.is_public_suffix_match = true; | 854 blacklisted_psl.is_public_suffix_match = true; |
855 blacklisted_psl.blacklisted_by_user = true; | 855 blacklisted_psl.blacklisted_by_user = true; |
856 | 856 |
857 // Doesn't apply because of different origin. | 857 // Doesn't apply because of different origin. |
858 PasswordForm blacklisted_not_match = *observed_form(); | 858 PasswordForm blacklisted_not_match = *observed_form(); |
859 blacklisted_not_match.origin = GURL("http://google.com/a/LoginAuth"); | 859 blacklisted_not_match.origin = GURL("http://google.com/a/LoginAuth"); |
(...skipping 22 matching lines...) Expand all Loading... | |
882 | 882 |
883 std::vector<const PasswordForm*> matches = {&blacklisted_psl, | 883 std::vector<const PasswordForm*> matches = {&blacklisted_psl, |
884 &blacklisted_not_match, | 884 &blacklisted_not_match, |
885 &blacklisted_not_match2, | 885 &blacklisted_not_match2, |
886 &blacklisted_not_match3, | 886 &blacklisted_not_match3, |
887 &blacklisted_match, | 887 &blacklisted_match, |
888 &blacklisted_match2, | 888 &blacklisted_match2, |
889 saved_match()}; | 889 saved_match()}; |
890 fetcher.SetNonFederated(matches, 0u); | 890 fetcher.SetNonFederated(matches, 0u); |
891 | 891 |
892 EXPECT_TRUE(form_manager.IsBlacklisted()); | 892 EXPECT_TRUE(form_manager->IsBlacklisted()); |
893 EXPECT_THAT(form_manager.blacklisted_matches(), | 893 EXPECT_THAT(form_manager->blacklisted_matches(), |
894 UnorderedElementsAre(Pointee(blacklisted_match), | 894 UnorderedElementsAre(Pointee(blacklisted_match), |
895 Pointee(blacklisted_match2))); | 895 Pointee(blacklisted_match2))); |
896 EXPECT_EQ(1u, form_manager.best_matches().size()); | 896 EXPECT_EQ(1u, form_manager->best_matches().size()); |
897 EXPECT_EQ(*saved_match(), *form_manager.preferred_match()); | 897 EXPECT_EQ(*saved_match(), *form_manager->preferred_match()); |
898 } | 898 } |
899 | 899 |
900 // Test that even in the presence of blacklisted matches, the non-blacklisted | 900 // Test that even in the presence of blacklisted matches, the non-blacklisted |
901 // ones are still autofilled. | 901 // ones are still autofilled. |
902 TEST_F(PasswordFormManagerTest, AutofillBlacklisted) { | 902 TEST_F(PasswordFormManagerTest, AutofillBlacklisted) { |
903 PasswordForm saved_form = *observed_form(); | 903 PasswordForm saved_form = *observed_form(); |
904 saved_form.username_value = ASCIIToUTF16("user"); | 904 saved_form.username_value = ASCIIToUTF16("user"); |
905 saved_form.password_value = ASCIIToUTF16("pass"); | 905 saved_form.password_value = ASCIIToUTF16("pass"); |
906 | 906 |
907 PasswordForm blacklisted = *observed_form(); | 907 PasswordForm blacklisted = *observed_form(); |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
977 } | 977 } |
978 | 978 |
979 // Test that when the submitted form contains a "new-password" field, then the | 979 // Test that when the submitted form contains a "new-password" field, then the |
980 // password value is taken from there. | 980 // password value is taken from there. |
981 TEST_F(PasswordFormManagerTest, TestNewLoginFromNewPasswordElement) { | 981 TEST_F(PasswordFormManagerTest, TestNewLoginFromNewPasswordElement) { |
982 observed_form()->new_password_element = ASCIIToUTF16("NewPasswd"); | 982 observed_form()->new_password_element = ASCIIToUTF16("NewPasswd"); |
983 observed_form()->username_marked_by_site = true; | 983 observed_form()->username_marked_by_site = true; |
984 | 984 |
985 FakeFormFetcher fetcher; | 985 FakeFormFetcher fetcher; |
986 fetcher.Fetch(); | 986 fetcher.Fetch(); |
987 PasswordFormManager form_manager(password_manager(), client(), | 987 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
988 client()->driver(), *observed_form(), | 988 password_manager(), client(), client()->driver(), *observed_form(), |
989 base::MakeUnique<MockFormSaver>(), &fetcher); | 989 base::MakeUnique<MockFormSaver>(), &fetcher)); |
990 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 990 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
991 | 991 |
992 // User enters current and new credentials to the observed form. | 992 // User enters current and new credentials to the observed form. |
993 PasswordForm credentials(*observed_form()); | 993 PasswordForm credentials(*observed_form()); |
994 credentials.username_value = saved_match()->username_value; | 994 credentials.username_value = saved_match()->username_value; |
995 credentials.password_value = ASCIIToUTF16("oldpassword"); | 995 credentials.password_value = ASCIIToUTF16("oldpassword"); |
996 credentials.new_password_value = ASCIIToUTF16("newpassword"); | 996 credentials.new_password_value = ASCIIToUTF16("newpassword"); |
997 credentials.preferred = true; | 997 credentials.preferred = true; |
998 form_manager.ProvisionallySave( | 998 form_manager->ProvisionallySave( |
999 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 999 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
1000 | 1000 |
1001 // Successful login. The PasswordManager would instruct PasswordFormManager | 1001 // Successful login. The PasswordManager would instruct PasswordFormManager |
1002 // to save, which should know this is a new login. | 1002 // to save, which should know this is a new login. |
1003 EXPECT_TRUE(form_manager.IsNewLogin()); | 1003 EXPECT_TRUE(form_manager->IsNewLogin()); |
1004 EXPECT_EQ(credentials.origin, form_manager.pending_credentials().origin); | 1004 EXPECT_EQ(credentials.origin, form_manager->pending_credentials().origin); |
1005 EXPECT_EQ(credentials.signon_realm, | 1005 EXPECT_EQ(credentials.signon_realm, |
1006 form_manager.pending_credentials().signon_realm); | 1006 form_manager->pending_credentials().signon_realm); |
1007 EXPECT_EQ(credentials.action, form_manager.pending_credentials().action); | 1007 EXPECT_EQ(credentials.action, form_manager->pending_credentials().action); |
1008 EXPECT_TRUE(form_manager.pending_credentials().preferred); | 1008 EXPECT_TRUE(form_manager->pending_credentials().preferred); |
1009 EXPECT_EQ(credentials.username_value, | 1009 EXPECT_EQ(credentials.username_value, |
1010 form_manager.pending_credentials().username_value); | 1010 form_manager->pending_credentials().username_value); |
1011 | 1011 |
1012 // By this point, the PasswordFormManager should have promoted the new | 1012 // By this point, the PasswordFormManager should have promoted the new |
1013 // password value to be the current password, and should have wiped the | 1013 // password value to be the current password, and should have wiped the |
1014 // password element name: it is likely going to be different on a login | 1014 // password element name: it is likely going to be different on a login |
1015 // form, so it is not worth remembering them. | 1015 // form, so it is not worth remembering them. |
1016 EXPECT_EQ(credentials.new_password_value, | 1016 EXPECT_EQ(credentials.new_password_value, |
1017 form_manager.pending_credentials().password_value); | 1017 form_manager->pending_credentials().password_value); |
1018 EXPECT_TRUE(form_manager.pending_credentials().password_element.empty()); | 1018 EXPECT_TRUE(form_manager->pending_credentials().password_element.empty()); |
1019 EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty()); | 1019 EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty()); |
1020 } | 1020 } |
1021 | 1021 |
1022 TEST_F(PasswordFormManagerTest, TestUpdatePassword) { | 1022 TEST_F(PasswordFormManagerTest, TestUpdatePassword) { |
1023 fake_form_fetcher()->SetNonFederated({saved_match()}, 0u); | 1023 fake_form_fetcher()->SetNonFederated({saved_match()}, 0u); |
1024 | 1024 |
1025 // User submits credentials for the observed form using a username previously | 1025 // User submits credentials for the observed form using a username previously |
1026 // stored, but a new password. Note that the observed form may have different | 1026 // stored, but a new password. Note that the observed form may have different |
1027 // origin URL (as it does in this case) than the saved_match, but we want to | 1027 // origin URL (as it does in this case) than the saved_match, but we want to |
1028 // make sure the updated password is reflected in saved_match, because that is | 1028 // make sure the updated password is reflected in saved_match, because that is |
1029 // what we autofilled. | 1029 // what we autofilled. |
(...skipping 30 matching lines...) Expand all Loading... | |
1060 // should not serve as a source for updating meta-information stored with the | 1060 // should not serve as a source for updating meta-information stored with the |
1061 // old credentials, such as element names, as they are likely going to be | 1061 // old credentials, such as element names, as they are likely going to be |
1062 // different between change password and login forms. To test this in depth, | 1062 // different between change password and login forms. To test this in depth, |
1063 // forcibly wipe |submit_element|, which should normally trigger updating | 1063 // forcibly wipe |submit_element|, which should normally trigger updating |
1064 // this field from |observed_form| during updating as a special case. We will | 1064 // this field from |observed_form| during updating as a special case. We will |
1065 // verify in the end that this did not happen. | 1065 // verify in the end that this did not happen. |
1066 saved_match()->submit_element.clear(); | 1066 saved_match()->submit_element.clear(); |
1067 | 1067 |
1068 FakeFormFetcher fetcher; | 1068 FakeFormFetcher fetcher; |
1069 fetcher.Fetch(); | 1069 fetcher.Fetch(); |
1070 PasswordFormManager form_manager(password_manager(), client(), | 1070 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
1071 client()->driver(), *observed_form(), | 1071 password_manager(), client(), client()->driver(), *observed_form(), |
1072 base::MakeUnique<MockFormSaver>(), &fetcher); | 1072 base::MakeUnique<MockFormSaver>(), &fetcher)); |
1073 fetcher.SetNonFederated({saved_match()}, 0u); | 1073 fetcher.SetNonFederated({saved_match()}, 0u); |
1074 | 1074 |
1075 // User submits current and new credentials to the observed form. | 1075 // User submits current and new credentials to the observed form. |
1076 PasswordForm credentials(*observed_form()); | 1076 PasswordForm credentials(*observed_form()); |
1077 credentials.username_value = saved_match()->username_value; | 1077 credentials.username_value = saved_match()->username_value; |
1078 credentials.password_value = saved_match()->password_value; | 1078 credentials.password_value = saved_match()->password_value; |
1079 credentials.new_password_value = ASCIIToUTF16("test2"); | 1079 credentials.new_password_value = ASCIIToUTF16("test2"); |
1080 credentials.preferred = true; | 1080 credentials.preferred = true; |
1081 form_manager.ProvisionallySave( | 1081 form_manager->ProvisionallySave( |
1082 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 1082 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
1083 | 1083 |
1084 // Successful login. The PasswordManager would instruct PasswordFormManager | 1084 // Successful login. The PasswordManager would instruct PasswordFormManager |
1085 // to save, and since this is an update, it should know not to save as a new | 1085 // to save, and since this is an update, it should know not to save as a new |
1086 // login. | 1086 // login. |
1087 EXPECT_FALSE(form_manager.IsNewLogin()); | 1087 EXPECT_FALSE(form_manager->IsNewLogin()); |
1088 | 1088 |
1089 // By now, the PasswordFormManager should have promoted the new password value | 1089 // By now, the PasswordFormManager should have promoted the new password value |
1090 // already to be the current password, and should no longer maintain any info | 1090 // already to be the current password, and should no longer maintain any info |
1091 // about the new password. | 1091 // about the new password. |
1092 EXPECT_EQ(credentials.new_password_value, | 1092 EXPECT_EQ(credentials.new_password_value, |
1093 form_manager.pending_credentials().password_value); | 1093 form_manager->pending_credentials().password_value); |
1094 EXPECT_TRUE(form_manager.pending_credentials().new_password_element.empty()); | 1094 EXPECT_TRUE(form_manager->pending_credentials().new_password_element.empty()); |
1095 EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty()); | 1095 EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty()); |
1096 | 1096 |
1097 // Trigger saving to exercise some special case handling for updating. | 1097 // Trigger saving to exercise some special case handling for updating. |
1098 PasswordForm new_credentials; | 1098 PasswordForm new_credentials; |
1099 EXPECT_CALL(MockFormSaver::Get(&form_manager), Update(_, _, _, nullptr)) | 1099 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Update(_, _, _, nullptr)) |
1100 .WillOnce(testing::SaveArg<0>(&new_credentials)); | 1100 .WillOnce(testing::SaveArg<0>(&new_credentials)); |
1101 | 1101 |
1102 form_manager.Save(); | 1102 form_manager->Save(); |
1103 | 1103 |
1104 // No meta-information should be updated, only the password. | 1104 // No meta-information should be updated, only the password. |
1105 EXPECT_EQ(credentials.new_password_value, new_credentials.password_value); | 1105 EXPECT_EQ(credentials.new_password_value, new_credentials.password_value); |
1106 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); | 1106 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); |
1107 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); | 1107 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); |
1108 EXPECT_EQ(saved_match()->submit_element, new_credentials.submit_element); | 1108 EXPECT_EQ(saved_match()->submit_element, new_credentials.submit_element); |
1109 } | 1109 } |
1110 | 1110 |
1111 // Test that saved results are not ignored if they differ in paths for action or | 1111 // Test that saved results are not ignored if they differ in paths for action or |
1112 // origin. | 1112 // origin. |
1113 TEST_F(PasswordFormManagerTest, TestIgnoreResult_Paths) { | 1113 TEST_F(PasswordFormManagerTest, TestIgnoreResult_Paths) { |
1114 PasswordForm observed(*observed_form()); | 1114 PasswordForm observed(*observed_form()); |
1115 observed.origin = GURL("https://accounts.google.com/a/LoginAuth"); | 1115 observed.origin = GURL("https://accounts.google.com/a/LoginAuth"); |
1116 observed.action = GURL("https://accounts.google.com/a/Login"); | 1116 observed.action = GURL("https://accounts.google.com/a/Login"); |
1117 observed.signon_realm = "https://accounts.google.com"; | 1117 observed.signon_realm = "https://accounts.google.com"; |
1118 | 1118 |
1119 FakeFormFetcher fetcher; | 1119 FakeFormFetcher fetcher; |
1120 fetcher.Fetch(); | 1120 fetcher.Fetch(); |
1121 PasswordFormManager form_manager(password_manager(), client(), | 1121 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
1122 client()->driver(), observed, | 1122 password_manager(), client(), client()->driver(), observed, |
1123 base::MakeUnique<MockFormSaver>(), &fetcher); | 1123 base::MakeUnique<MockFormSaver>(), &fetcher)); |
1124 | 1124 |
1125 PasswordForm saved_form = observed; | 1125 PasswordForm saved_form = observed; |
1126 saved_form.origin = GURL("https://accounts.google.com/a/OtherLoginAuth"); | 1126 saved_form.origin = GURL("https://accounts.google.com/a/OtherLoginAuth"); |
1127 saved_form.action = GURL("https://accounts.google.com/a/OtherLogin"); | 1127 saved_form.action = GURL("https://accounts.google.com/a/OtherLogin"); |
1128 fetcher.SetNonFederated({&saved_form}, 0u); | 1128 fetcher.SetNonFederated({&saved_form}, 0u); |
1129 | 1129 |
1130 // Different paths for action / origin are okay. | 1130 // Different paths for action / origin are okay. |
1131 EXPECT_EQ(1u, form_manager.best_matches().size()); | 1131 EXPECT_EQ(1u, form_manager->best_matches().size()); |
1132 EXPECT_EQ(*form_manager.best_matches().begin()->second, saved_form); | 1132 EXPECT_EQ(*form_manager->best_matches().begin()->second, saved_form); |
1133 } | 1133 } |
1134 | 1134 |
1135 // Test that saved empty action URL is updated with the submitted action URL. | 1135 // Test that saved empty action URL is updated with the submitted action URL. |
1136 TEST_F(PasswordFormManagerTest, TestEmptyAction) { | 1136 TEST_F(PasswordFormManagerTest, TestEmptyAction) { |
1137 saved_match()->action = GURL(); | 1137 saved_match()->action = GURL(); |
1138 fake_form_fetcher()->SetNonFederated({saved_match()}, 0u); | 1138 fake_form_fetcher()->SetNonFederated({saved_match()}, 0u); |
1139 | 1139 |
1140 // User logs in with the autofilled username / password from saved_match. | 1140 // User logs in with the autofilled username / password from saved_match. |
1141 PasswordForm login = *observed_form(); | 1141 PasswordForm login = *observed_form(); |
1142 login.username_value = saved_match()->username_value; | 1142 login.username_value = saved_match()->username_value; |
(...skipping 139 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1282 TEST_F(PasswordFormManagerTest, | 1282 TEST_F(PasswordFormManagerTest, |
1283 TestSendNotBlacklistedMessage_DroppedCredentials) { | 1283 TestSendNotBlacklistedMessage_DroppedCredentials) { |
1284 // There are cases, such as when a form is made explicitly for creating a new | 1284 // There are cases, such as when a form is made explicitly for creating a new |
1285 // password, where we may ignore saved credentials. Make sure that we still | 1285 // password, where we may ignore saved credentials. Make sure that we still |
1286 // allow generation in that case. | 1286 // allow generation in that case. |
1287 PasswordForm signup_form(*observed_form()); | 1287 PasswordForm signup_form(*observed_form()); |
1288 signup_form.new_password_element = base::ASCIIToUTF16("new_password_field"); | 1288 signup_form.new_password_element = base::ASCIIToUTF16("new_password_field"); |
1289 | 1289 |
1290 FakeFormFetcher fetcher; | 1290 FakeFormFetcher fetcher; |
1291 fetcher.Fetch(); | 1291 fetcher.Fetch(); |
1292 PasswordFormManager form_manager(password_manager(), client(), | 1292 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
1293 client()->driver(), signup_form, | 1293 password_manager(), client(), client()->driver(), signup_form, |
1294 base::MakeUnique<MockFormSaver>(), &fetcher); | 1294 base::MakeUnique<MockFormSaver>(), &fetcher)); |
1295 EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_)); | 1295 EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_)); |
1296 PasswordForm simulated_result = CreateSavedMatch(false); | 1296 PasswordForm simulated_result = CreateSavedMatch(false); |
1297 fetcher.SetNonFederated({&simulated_result}, 0u); | 1297 fetcher.SetNonFederated({&simulated_result}, 0u); |
1298 } | 1298 } |
1299 | 1299 |
1300 TEST_F(PasswordFormManagerTest, | 1300 TEST_F(PasswordFormManagerTest, |
1301 TestSendNotBlacklistedMessage_BlacklistedCredentials) { | 1301 TestSendNotBlacklistedMessage_BlacklistedCredentials) { |
1302 // Signing up on a previously visited site. Credentials are found in the | 1302 // Signing up on a previously visited site. Credentials are found in the |
1303 // password store, but they are blacklisted. AllowPasswordGenerationForForm | 1303 // password store, but they are blacklisted. AllowPasswordGenerationForForm |
1304 // is still called. | 1304 // is still called. |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1434 encountered_form.signon_realm = "http://accounts.google.com/"; | 1434 encountered_form.signon_realm = "http://accounts.google.com/"; |
1435 encountered_form.action = GURL("http://accounts.google.com/Login"); | 1435 encountered_form.action = GURL("http://accounts.google.com/Login"); |
1436 encountered_form.username_element = ASCIIToUTF16("Email"); | 1436 encountered_form.username_element = ASCIIToUTF16("Email"); |
1437 encountered_form.password_element = ASCIIToUTF16("Passwd"); | 1437 encountered_form.password_element = ASCIIToUTF16("Passwd"); |
1438 encountered_form.submit_element = ASCIIToUTF16("signIn"); | 1438 encountered_form.submit_element = ASCIIToUTF16("signIn"); |
1439 | 1439 |
1440 EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_)); | 1440 EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_)); |
1441 | 1441 |
1442 FakeFormFetcher fetcher; | 1442 FakeFormFetcher fetcher; |
1443 fetcher.Fetch(); | 1443 fetcher.Fetch(); |
1444 PasswordFormManager form_manager(password_manager(), client(), | 1444 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
1445 client()->driver(), encountered_form, | 1445 password_manager(), client(), client()->driver(), encountered_form, |
1446 base::MakeUnique<MockFormSaver>(), &fetcher); | 1446 base::MakeUnique<MockFormSaver>(), &fetcher)); |
1447 | 1447 |
1448 PasswordForm incomplete_form; | 1448 PasswordForm incomplete_form; |
1449 incomplete_form.origin = GURL("http://accounts.google.com/LoginAuth"); | 1449 incomplete_form.origin = GURL("http://accounts.google.com/LoginAuth"); |
1450 incomplete_form.signon_realm = "http://accounts.google.com/"; | 1450 incomplete_form.signon_realm = "http://accounts.google.com/"; |
1451 incomplete_form.password_value = ASCIIToUTF16("my_password"); | 1451 incomplete_form.password_value = ASCIIToUTF16("my_password"); |
1452 incomplete_form.username_value = ASCIIToUTF16("my_username"); | 1452 incomplete_form.username_value = ASCIIToUTF16("my_username"); |
1453 incomplete_form.preferred = true; | 1453 incomplete_form.preferred = true; |
1454 incomplete_form.scheme = PasswordForm::SCHEME_HTML; | 1454 incomplete_form.scheme = PasswordForm::SCHEME_HTML; |
1455 | 1455 |
1456 // We expect to see this form eventually sent to the Password store. It | 1456 // We expect to see this form eventually sent to the Password store. It |
1457 // has password/username values from the store and 'username_element', | 1457 // has password/username values from the store and 'username_element', |
1458 // 'password_element', 'submit_element' and 'action' fields copied from | 1458 // 'password_element', 'submit_element' and 'action' fields copied from |
1459 // the encountered form. | 1459 // the encountered form. |
1460 PasswordForm complete_form(incomplete_form); | 1460 PasswordForm complete_form(incomplete_form); |
1461 complete_form.action = encountered_form.action; | 1461 complete_form.action = encountered_form.action; |
1462 complete_form.password_element = encountered_form.password_element; | 1462 complete_form.password_element = encountered_form.password_element; |
1463 complete_form.username_element = encountered_form.username_element; | 1463 complete_form.username_element = encountered_form.username_element; |
1464 complete_form.submit_element = encountered_form.submit_element; | 1464 complete_form.submit_element = encountered_form.submit_element; |
1465 | 1465 |
1466 PasswordForm obsolete_form(incomplete_form); | 1466 PasswordForm obsolete_form(incomplete_form); |
1467 obsolete_form.action = encountered_form.action; | 1467 obsolete_form.action = encountered_form.action; |
1468 | 1468 |
1469 // Feed the incomplete credentials to the manager. | 1469 // Feed the incomplete credentials to the manager. |
1470 fetcher.SetNonFederated({&incomplete_form}, 0u); | 1470 fetcher.SetNonFederated({&incomplete_form}, 0u); |
1471 | 1471 |
1472 form_manager.ProvisionallySave( | 1472 form_manager->ProvisionallySave( |
1473 complete_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 1473 complete_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
1474 // By now that form has been used once. | 1474 // By now that form has been used once. |
1475 complete_form.times_used = 1; | 1475 complete_form.times_used = 1; |
1476 obsolete_form.times_used = 1; | 1476 obsolete_form.times_used = 1; |
1477 | 1477 |
1478 // Check that PasswordStore receives an update request with the complete form. | 1478 // Check that PasswordStore receives an update request with the complete form. |
1479 EXPECT_CALL(MockFormSaver::Get(&form_manager), | 1479 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), |
1480 Update(complete_form, _, _, Pointee(obsolete_form))); | 1480 Update(complete_form, _, _, Pointee(obsolete_form))); |
1481 form_manager.Save(); | 1481 form_manager->Save(); |
1482 } | 1482 } |
1483 | 1483 |
1484 // Test that public-suffix-matched credentials score lower than same-origin | 1484 // Test that public-suffix-matched credentials score lower than same-origin |
1485 // ones. | 1485 // ones. |
1486 TEST_F(PasswordFormManagerTest, TestScoringPublicSuffixMatch) { | 1486 TEST_F(PasswordFormManagerTest, TestScoringPublicSuffixMatch) { |
1487 EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_)); | 1487 EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_)); |
1488 | 1488 |
1489 PasswordForm base_match = CreateSavedMatch(false); | 1489 PasswordForm base_match = CreateSavedMatch(false); |
1490 base_match.origin = GURL("http://accounts.google.com/a/ServiceLoginAuth"); | 1490 base_match.origin = GURL("http://accounts.google.com/a/ServiceLoginAuth"); |
1491 base_match.action = GURL("http://accounts.google.com/a/ServiceLogin"); | 1491 base_match.action = GURL("http://accounts.google.com/a/ServiceLogin"); |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1613 PasswordForm invalid_action_form(*observed_form()); | 1613 PasswordForm invalid_action_form(*observed_form()); |
1614 invalid_action_form.action = GURL("http://"); | 1614 invalid_action_form.action = GURL("http://"); |
1615 ASSERT_FALSE(invalid_action_form.action.is_valid()); | 1615 ASSERT_FALSE(invalid_action_form.action.is_valid()); |
1616 ASSERT_FALSE(invalid_action_form.action.is_empty()); | 1616 ASSERT_FALSE(invalid_action_form.action.is_empty()); |
1617 // Non-empty invalid action URLs should not match other actions. | 1617 // Non-empty invalid action URLs should not match other actions. |
1618 // First when the compared form has an invalid URL: | 1618 // First when the compared form has an invalid URL: |
1619 EXPECT_EQ(0, form_manager()->DoesManage(invalid_action_form, nullptr) & | 1619 EXPECT_EQ(0, form_manager()->DoesManage(invalid_action_form, nullptr) & |
1620 PasswordFormManager::RESULT_ACTION_MATCH); | 1620 PasswordFormManager::RESULT_ACTION_MATCH); |
1621 // Then when the observed form has an invalid URL: | 1621 // Then when the observed form has an invalid URL: |
1622 PasswordForm valid_action_form(*observed_form()); | 1622 PasswordForm valid_action_form(*observed_form()); |
1623 PasswordFormManager invalid_manager( | 1623 scoped_refptr<PasswordFormManager> invalid_manager(new PasswordFormManager( |
1624 password_manager(), client(), client()->driver(), invalid_action_form, | 1624 password_manager(), client(), client()->driver(), invalid_action_form, |
1625 base::MakeUnique<MockFormSaver>(), fake_form_fetcher()); | 1625 base::MakeUnique<MockFormSaver>(), fake_form_fetcher())); |
1626 EXPECT_EQ(0, invalid_manager.DoesManage(valid_action_form, nullptr) & | 1626 EXPECT_EQ(0, invalid_manager->DoesManage(valid_action_form, nullptr) & |
1627 PasswordFormManager::RESULT_ACTION_MATCH); | 1627 PasswordFormManager::RESULT_ACTION_MATCH); |
1628 } | 1628 } |
1629 | 1629 |
1630 TEST_F(PasswordFormManagerTest, EmptyActionURLsDoNotMatchNonEmpty) { | 1630 TEST_F(PasswordFormManagerTest, EmptyActionURLsDoNotMatchNonEmpty) { |
1631 PasswordForm empty_action_form(*observed_form()); | 1631 PasswordForm empty_action_form(*observed_form()); |
1632 empty_action_form.action = GURL(); | 1632 empty_action_form.action = GURL(); |
1633 ASSERT_FALSE(empty_action_form.action.is_valid()); | 1633 ASSERT_FALSE(empty_action_form.action.is_valid()); |
1634 ASSERT_TRUE(empty_action_form.action.is_empty()); | 1634 ASSERT_TRUE(empty_action_form.action.is_empty()); |
1635 // First when the compared form has an empty URL: | 1635 // First when the compared form has an empty URL: |
1636 EXPECT_EQ(0, form_manager()->DoesManage(empty_action_form, nullptr) & | 1636 EXPECT_EQ(0, form_manager()->DoesManage(empty_action_form, nullptr) & |
1637 PasswordFormManager::RESULT_ACTION_MATCH); | 1637 PasswordFormManager::RESULT_ACTION_MATCH); |
1638 // Then when the observed form has an empty URL: | 1638 // Then when the observed form has an empty URL: |
1639 PasswordForm valid_action_form(*observed_form()); | 1639 PasswordForm valid_action_form(*observed_form()); |
1640 PasswordFormManager empty_action_manager( | 1640 scoped_refptr<PasswordFormManager> empty_action_manager( |
1641 password_manager(), client(), client()->driver(), empty_action_form, | 1641 new PasswordFormManager( |
1642 base::MakeUnique<MockFormSaver>(), fake_form_fetcher()); | 1642 password_manager(), client(), client()->driver(), empty_action_form, |
1643 EXPECT_EQ(0, empty_action_manager.DoesManage(valid_action_form, nullptr) & | 1643 base::MakeUnique<MockFormSaver>(), fake_form_fetcher())); |
1644 EXPECT_EQ(0, empty_action_manager->DoesManage(valid_action_form, nullptr) & | |
1644 PasswordFormManager::RESULT_ACTION_MATCH); | 1645 PasswordFormManager::RESULT_ACTION_MATCH); |
1645 } | 1646 } |
1646 | 1647 |
1647 TEST_F(PasswordFormManagerTest, NonHTMLFormsDoNotMatchHTMLForms) { | 1648 TEST_F(PasswordFormManagerTest, NonHTMLFormsDoNotMatchHTMLForms) { |
1648 ASSERT_EQ(PasswordForm::SCHEME_HTML, observed_form()->scheme); | 1649 ASSERT_EQ(PasswordForm::SCHEME_HTML, observed_form()->scheme); |
1649 PasswordForm non_html_form(*observed_form()); | 1650 PasswordForm non_html_form(*observed_form()); |
1650 non_html_form.scheme = PasswordForm::SCHEME_DIGEST; | 1651 non_html_form.scheme = PasswordForm::SCHEME_DIGEST; |
1651 EXPECT_EQ(0, form_manager()->DoesManage(non_html_form, nullptr) & | 1652 EXPECT_EQ(0, form_manager()->DoesManage(non_html_form, nullptr) & |
1652 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); | 1653 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); |
1653 | 1654 |
1654 // The other way round: observing a non-HTML form, don't match a HTML form. | 1655 // The other way round: observing a non-HTML form, don't match a HTML form. |
1655 PasswordForm html_form(*observed_form()); | 1656 PasswordForm html_form(*observed_form()); |
1656 PasswordFormManager non_html_manager( | 1657 scoped_refptr<PasswordFormManager> non_html_manager(new PasswordFormManager( |
1657 password_manager(), client(), kNoDriver, non_html_form, | 1658 password_manager(), client(), kNoDriver, non_html_form, |
1658 base::MakeUnique<MockFormSaver>(), fake_form_fetcher()); | 1659 base::MakeUnique<MockFormSaver>(), fake_form_fetcher())); |
1659 EXPECT_EQ(0, non_html_manager.DoesManage(html_form, nullptr) & | 1660 EXPECT_EQ(0, non_html_manager->DoesManage(html_form, nullptr) & |
1660 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); | 1661 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); |
1661 } | 1662 } |
1662 | 1663 |
1663 TEST_F(PasswordFormManagerTest, OriginCheck_HostsMatchExactly) { | 1664 TEST_F(PasswordFormManagerTest, OriginCheck_HostsMatchExactly) { |
1664 // Host part of origins must match exactly, not just by prefix. | 1665 // Host part of origins must match exactly, not just by prefix. |
1665 PasswordForm form_longer_host(*observed_form()); | 1666 PasswordForm form_longer_host(*observed_form()); |
1666 form_longer_host.origin = GURL("http://accounts.google.com.au/a/LoginAuth"); | 1667 form_longer_host.origin = GURL("http://accounts.google.com.au/a/LoginAuth"); |
1667 // Check that accounts.google.com does not match accounts.google.com.au. | 1668 // Check that accounts.google.com does not match accounts.google.com.au. |
1668 EXPECT_EQ(0, form_manager()->DoesManage(form_longer_host, nullptr) & | 1669 EXPECT_EQ(0, form_manager()->DoesManage(form_longer_host, nullptr) & |
1669 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); | 1670 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); |
(...skipping 13 matching lines...) Expand all Loading... | |
1683 // If the origin URL scheme of the compared form is not more secure than that | 1684 // If the origin URL scheme of the compared form is not more secure than that |
1684 // of the observed form, then the paths must match exactly. | 1685 // of the observed form, then the paths must match exactly. |
1685 PasswordForm form_longer_path(*observed_form()); | 1686 PasswordForm form_longer_path(*observed_form()); |
1686 form_longer_path.origin = GURL("http://accounts.google.com/a/LoginAuth/sec"); | 1687 form_longer_path.origin = GURL("http://accounts.google.com/a/LoginAuth/sec"); |
1687 // Check that /a/LoginAuth does not match /a/LoginAuth/more. | 1688 // Check that /a/LoginAuth does not match /a/LoginAuth/more. |
1688 EXPECT_EQ(0, form_manager()->DoesManage(form_longer_path, nullptr) & | 1689 EXPECT_EQ(0, form_manager()->DoesManage(form_longer_path, nullptr) & |
1689 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); | 1690 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); |
1690 | 1691 |
1691 PasswordForm secure_observed_form(*observed_form()); | 1692 PasswordForm secure_observed_form(*observed_form()); |
1692 secure_observed_form.origin = GURL("https://accounts.google.com/a/LoginAuth"); | 1693 secure_observed_form.origin = GURL("https://accounts.google.com/a/LoginAuth"); |
1693 PasswordFormManager secure_manager( | 1694 scoped_refptr<PasswordFormManager> secure_manager(new PasswordFormManager( |
1694 password_manager(), client(), client()->driver(), secure_observed_form, | 1695 password_manager(), client(), client()->driver(), secure_observed_form, |
1695 base::MakeUnique<MockFormSaver>(), fake_form_fetcher()); | 1696 base::MakeUnique<MockFormSaver>(), fake_form_fetcher())); |
1696 // Also for HTTPS in the observed form, and HTTP in the compared form, an | 1697 // Also for HTTPS in the observed form, and HTTP in the compared form, an |
1697 // exact path match is expected. | 1698 // exact path match is expected. |
1698 EXPECT_EQ(0, secure_manager.DoesManage(form_longer_path, nullptr) & | 1699 EXPECT_EQ(0, secure_manager->DoesManage(form_longer_path, nullptr) & |
1699 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); | 1700 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); |
1700 // Not even upgrade to HTTPS in the compared form should help. | 1701 // Not even upgrade to HTTPS in the compared form should help. |
1701 form_longer_path.origin = GURL("https://accounts.google.com/a/LoginAuth/sec"); | 1702 form_longer_path.origin = GURL("https://accounts.google.com/a/LoginAuth/sec"); |
1702 EXPECT_EQ(0, secure_manager.DoesManage(form_longer_path, nullptr) & | 1703 EXPECT_EQ(0, secure_manager->DoesManage(form_longer_path, nullptr) & |
1703 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); | 1704 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); |
1704 } | 1705 } |
1705 | 1706 |
1706 TEST_F(PasswordFormManagerTest, OriginCheck_OnlyOriginsMatch) { | 1707 TEST_F(PasswordFormManagerTest, OriginCheck_OnlyOriginsMatch) { |
1707 // Make sure DoesManage() can distinguish when only origins match. | 1708 // Make sure DoesManage() can distinguish when only origins match. |
1708 | 1709 |
1709 PasswordForm different_html_attributes(*observed_form()); | 1710 PasswordForm different_html_attributes(*observed_form()); |
1710 different_html_attributes.password_element = ASCIIToUTF16("random_pass"); | 1711 different_html_attributes.password_element = ASCIIToUTF16("random_pass"); |
1711 different_html_attributes.username_element = ASCIIToUTF16("random_user"); | 1712 different_html_attributes.username_element = ASCIIToUTF16("random_user"); |
1712 | 1713 |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1780 EXPECT_EQ(ASCIIToUTF16("third"), credentials_to_update[0].password_value); | 1781 EXPECT_EQ(ASCIIToUTF16("third"), credentials_to_update[0].password_value); |
1781 EXPECT_FALSE(credentials_to_update[0].password_element.empty()); | 1782 EXPECT_FALSE(credentials_to_update[0].password_element.empty()); |
1782 EXPECT_TRUE(credentials_to_update[0].username_element.empty()); | 1783 EXPECT_TRUE(credentials_to_update[0].username_element.empty()); |
1783 } | 1784 } |
1784 | 1785 |
1785 TEST_F(PasswordFormManagerTest, UploadFormData_NewPassword) { | 1786 TEST_F(PasswordFormManagerTest, UploadFormData_NewPassword) { |
1786 // For newly saved passwords, upload a password vote for autofill::PASSWORD. | 1787 // For newly saved passwords, upload a password vote for autofill::PASSWORD. |
1787 // Don't vote for the username field yet. | 1788 // Don't vote for the username field yet. |
1788 FakeFormFetcher fetcher; | 1789 FakeFormFetcher fetcher; |
1789 fetcher.Fetch(); | 1790 fetcher.Fetch(); |
1790 PasswordFormManager form_manager( | 1791 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
1791 password_manager(), client(), client()->driver(), *saved_match(), | 1792 password_manager(), client(), client()->driver(), *saved_match(), |
1792 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 1793 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
1793 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 1794 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
1794 | 1795 |
1795 PasswordForm form_to_save(*saved_match()); | 1796 PasswordForm form_to_save(*saved_match()); |
1796 form_to_save.preferred = true; | 1797 form_to_save.preferred = true; |
1797 form_to_save.username_value = ASCIIToUTF16("username"); | 1798 form_to_save.username_value = ASCIIToUTF16("username"); |
1798 form_to_save.password_value = ASCIIToUTF16("1234"); | 1799 form_to_save.password_value = ASCIIToUTF16("1234"); |
1799 | 1800 |
1800 autofill::ServerFieldTypeSet expected_available_field_types; | 1801 autofill::ServerFieldTypeSet expected_available_field_types; |
1801 expected_available_field_types.insert(autofill::PASSWORD); | 1802 expected_available_field_types.insert(autofill::PASSWORD); |
1802 EXPECT_CALL( | 1803 EXPECT_CALL( |
1803 *client()->mock_driver()->mock_autofill_download_manager(), | 1804 *client()->mock_driver()->mock_autofill_download_manager(), |
1804 StartUploadRequest(_, false, expected_available_field_types, _, true)); | 1805 StartUploadRequest(_, false, expected_available_field_types, _, true)); |
1805 form_manager.ProvisionallySave( | 1806 form_manager->ProvisionallySave( |
1806 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 1807 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
1807 form_manager.Save(); | 1808 form_manager->Save(); |
1808 } | 1809 } |
1809 | 1810 |
1810 TEST_F(PasswordFormManagerTest, UploadFormData_NewPassword_Blacklist) { | 1811 TEST_F(PasswordFormManagerTest, UploadFormData_NewPassword_Blacklist) { |
1811 // Do not upload a vote if the user is blacklisting the form. | 1812 // Do not upload a vote if the user is blacklisting the form. |
1812 FakeFormFetcher fetcher; | 1813 FakeFormFetcher fetcher; |
1813 fetcher.Fetch(); | 1814 fetcher.Fetch(); |
1814 PasswordFormManager blacklist_form_manager( | 1815 scoped_refptr<PasswordFormManager> blacklist_form_manager( |
1815 password_manager(), client(), client()->driver(), *saved_match(), | 1816 new PasswordFormManager( |
1816 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 1817 password_manager(), client(), client()->driver(), *saved_match(), |
1818 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); | |
1817 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 1819 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
1818 | 1820 |
1819 autofill::ServerFieldTypeSet expected_available_field_types; | 1821 autofill::ServerFieldTypeSet expected_available_field_types; |
1820 expected_available_field_types.insert(autofill::USERNAME); | 1822 expected_available_field_types.insert(autofill::USERNAME); |
1821 expected_available_field_types.insert(autofill::PASSWORD); | 1823 expected_available_field_types.insert(autofill::PASSWORD); |
1822 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 1824 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
1823 StartUploadRequest(_, _, expected_available_field_types, _, true)) | 1825 StartUploadRequest(_, _, expected_available_field_types, _, true)) |
1824 .Times(0); | 1826 .Times(0); |
1825 blacklist_form_manager.PermanentlyBlacklist(); | 1827 blacklist_form_manager->PermanentlyBlacklist(); |
1826 } | 1828 } |
1827 | 1829 |
1828 TEST_F(PasswordFormManagerTest, UploadPasswordForm) { | 1830 TEST_F(PasswordFormManagerTest, UploadPasswordForm) { |
1829 autofill::FormData observed_form_data; | 1831 autofill::FormData observed_form_data; |
1830 autofill::FormFieldData field; | 1832 autofill::FormFieldData field; |
1831 field.label = ASCIIToUTF16("Email"); | 1833 field.label = ASCIIToUTF16("Email"); |
1832 field.name = ASCIIToUTF16("observed-username-field"); | 1834 field.name = ASCIIToUTF16("observed-username-field"); |
1833 field.form_control_type = "text"; | 1835 field.form_control_type = "text"; |
1834 observed_form_data.fields.push_back(field); | 1836 observed_form_data.fields.push_back(field); |
1835 | 1837 |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1900 PasswordForm form; | 1902 PasswordForm form; |
1901 form.origin = GURL(example_url); | 1903 form.origin = GURL(example_url); |
1902 form.signon_realm = example_url; | 1904 form.signon_realm = example_url; |
1903 form.action = GURL(example_url); | 1905 form.action = GURL(example_url); |
1904 form.username_element = ASCIIToUTF16("u"); | 1906 form.username_element = ASCIIToUTF16("u"); |
1905 form.password_element = ASCIIToUTF16("p"); | 1907 form.password_element = ASCIIToUTF16("p"); |
1906 form.submit_element = ASCIIToUTF16("s"); | 1908 form.submit_element = ASCIIToUTF16("s"); |
1907 | 1909 |
1908 FakeFormFetcher fetcher; | 1910 FakeFormFetcher fetcher; |
1909 fetcher.Fetch(); | 1911 fetcher.Fetch(); |
1910 PasswordFormManager form_manager(password_manager(), client(), | 1912 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
1911 client()->driver(), form, | 1913 password_manager(), client(), client()->driver(), form, |
1912 base::MakeUnique<MockFormSaver>(), &fetcher); | 1914 base::MakeUnique<MockFormSaver>(), &fetcher)); |
1913 | 1915 |
1914 // Suddenly, the frame and its driver disappear. | 1916 // Suddenly, the frame and its driver disappear. |
1915 client()->KillDriver(); | 1917 client()->KillDriver(); |
1916 | 1918 |
1917 fetcher.SetNonFederated({&form}, 0u); | 1919 fetcher.SetNonFederated({&form}, 0u); |
1918 } | 1920 } |
1919 | 1921 |
1920 TEST_F(PasswordFormManagerTest, PreferredMatchIsUpToDate) { | 1922 TEST_F(PasswordFormManagerTest, PreferredMatchIsUpToDate) { |
1921 // Check that preferred_match() is always a member of best_matches(). | 1923 // Check that preferred_match() is always a member of best_matches(). |
1922 PasswordForm form = *observed_form(); | 1924 PasswordForm form = *observed_form(); |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1980 } | 1982 } |
1981 | 1983 |
1982 TEST_F(PasswordFormManagerTest, TestSuggestingPasswordChangeForms) { | 1984 TEST_F(PasswordFormManagerTest, TestSuggestingPasswordChangeForms) { |
1983 // Suggesting password on the password change form on the previously visited | 1985 // Suggesting password on the password change form on the previously visited |
1984 // site. Credentials are found in the password store, and are not blacklisted. | 1986 // site. Credentials are found in the password store, and are not blacklisted. |
1985 PasswordForm observed_change_password_form = *observed_form(); | 1987 PasswordForm observed_change_password_form = *observed_form(); |
1986 observed_change_password_form.new_password_element = | 1988 observed_change_password_form.new_password_element = |
1987 base::ASCIIToUTF16("new_pwd"); | 1989 base::ASCIIToUTF16("new_pwd"); |
1988 FakeFormFetcher fetcher; | 1990 FakeFormFetcher fetcher; |
1989 fetcher.Fetch(); | 1991 fetcher.Fetch(); |
1990 PasswordFormManager manager_creds( | 1992 scoped_refptr<PasswordFormManager> manager_creds( |
1991 password_manager(), client(), client()->driver(), | 1993 new PasswordFormManager(password_manager(), client(), client()->driver(), |
1992 observed_change_password_form, base::MakeUnique<MockFormSaver>(), | 1994 observed_change_password_form, |
1993 &fetcher); | 1995 base::MakeUnique<MockFormSaver>(), &fetcher)); |
1994 | 1996 |
1995 autofill::PasswordFormFillData fill_data; | 1997 autofill::PasswordFormFillData fill_data; |
1996 EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_)) | 1998 EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_)) |
1997 .WillOnce(SaveArg<0>(&fill_data)); | 1999 .WillOnce(SaveArg<0>(&fill_data)); |
1998 | 2000 |
1999 PasswordForm result = CreateSavedMatch(false); | 2001 PasswordForm result = CreateSavedMatch(false); |
2000 fetcher.SetNonFederated({&result}, 0u); | 2002 fetcher.SetNonFederated({&result}, 0u); |
2001 EXPECT_EQ(1u, manager_creds.best_matches().size()); | 2003 EXPECT_EQ(1u, manager_creds->best_matches().size()); |
2002 EXPECT_EQ(0u, fill_data.additional_logins.size()); | 2004 EXPECT_EQ(0u, fill_data.additional_logins.size()); |
2003 EXPECT_TRUE(fill_data.wait_for_username); | 2005 EXPECT_TRUE(fill_data.wait_for_username); |
2004 } | 2006 } |
2005 | 2007 |
2006 TEST_F(PasswordFormManagerTest, TestUpdateMethod) { | 2008 TEST_F(PasswordFormManagerTest, TestUpdateMethod) { |
2007 // Add a new password field to the test form. The PasswordFormManager should | 2009 // Add a new password field to the test form. The PasswordFormManager should |
2008 // save the password from this field, instead of the current password field. | 2010 // save the password from this field, instead of the current password field. |
2009 observed_form()->new_password_element = ASCIIToUTF16("NewPasswd"); | 2011 observed_form()->new_password_element = ASCIIToUTF16("NewPasswd"); |
2010 autofill::FormFieldData field; | 2012 autofill::FormFieldData field; |
2011 field.label = ASCIIToUTF16("NewPasswd"); | 2013 field.label = ASCIIToUTF16("NewPasswd"); |
2012 field.name = ASCIIToUTF16("NewPasswd"); | 2014 field.name = ASCIIToUTF16("NewPasswd"); |
2013 field.form_control_type = "password"; | 2015 field.form_control_type = "password"; |
2014 observed_form()->form_data.fields.push_back(field); | 2016 observed_form()->form_data.fields.push_back(field); |
2015 | 2017 |
2016 // Given that |observed_form| was most likely a change password form, it | 2018 // Given that |observed_form| was most likely a change password form, it |
2017 // should not serve as a source for updating meta-information stored with the | 2019 // should not serve as a source for updating meta-information stored with the |
2018 // old credentials, such as element names, as they are likely going to be | 2020 // old credentials, such as element names, as they are likely going to be |
2019 // different between change password and login forms. To test this in depth, | 2021 // different between change password and login forms. To test this in depth, |
2020 // forcibly wipe |submit_element|, which should normally trigger updating | 2022 // forcibly wipe |submit_element|, which should normally trigger updating |
2021 // this field from |observed_form| during updating as a special case. We will | 2023 // this field from |observed_form| during updating as a special case. We will |
2022 // verify in the end that this did not happen. | 2024 // verify in the end that this did not happen. |
2023 saved_match()->submit_element.clear(); | 2025 saved_match()->submit_element.clear(); |
2024 | 2026 |
2025 FakeFormFetcher fetcher; | 2027 FakeFormFetcher fetcher; |
2026 fetcher.Fetch(); | 2028 fetcher.Fetch(); |
2027 PasswordFormManager form_manager(password_manager(), client(), | 2029 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
2028 client()->driver(), *observed_form(), | 2030 password_manager(), client(), client()->driver(), *observed_form(), |
2029 base::MakeUnique<MockFormSaver>(), &fetcher); | 2031 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2030 | 2032 |
2031 fetcher.SetNonFederated({saved_match()}, 0u); | 2033 fetcher.SetNonFederated({saved_match()}, 0u); |
2032 | 2034 |
2033 // User submits current and new credentials to the observed form. | 2035 // User submits current and new credentials to the observed form. |
2034 PasswordForm credentials(*observed_form()); | 2036 PasswordForm credentials(*observed_form()); |
2035 credentials.username_element.clear(); | 2037 credentials.username_element.clear(); |
2036 credentials.password_value = saved_match()->password_value; | 2038 credentials.password_value = saved_match()->password_value; |
2037 credentials.new_password_value = ASCIIToUTF16("test2"); | 2039 credentials.new_password_value = ASCIIToUTF16("test2"); |
2038 credentials.preferred = true; | 2040 credentials.preferred = true; |
2039 form_manager.ProvisionallySave( | 2041 form_manager->ProvisionallySave( |
2040 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2042 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2041 | 2043 |
2042 // Successful login. The PasswordManager would instruct PasswordFormManager | 2044 // Successful login. The PasswordManager would instruct PasswordFormManager |
2043 // to save, and since this is an update, it should know not to save as a new | 2045 // to save, and since this is an update, it should know not to save as a new |
2044 // login. | 2046 // login. |
2045 EXPECT_FALSE(form_manager.IsNewLogin()); | 2047 EXPECT_FALSE(form_manager->IsNewLogin()); |
2046 EXPECT_FALSE( | 2048 EXPECT_FALSE( |
2047 form_manager.is_possible_change_password_form_without_username()); | 2049 form_manager->is_possible_change_password_form_without_username()); |
2048 | 2050 |
2049 // By now, the PasswordFormManager should have promoted the new password value | 2051 // By now, the PasswordFormManager should have promoted the new password value |
2050 // already to be the current password, and should no longer maintain any info | 2052 // already to be the current password, and should no longer maintain any info |
2051 // about the new password value. | 2053 // about the new password value. |
2052 EXPECT_EQ(credentials.new_password_value, | 2054 EXPECT_EQ(credentials.new_password_value, |
2053 form_manager.pending_credentials().password_value); | 2055 form_manager->pending_credentials().password_value); |
2054 EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty()); | 2056 EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty()); |
2055 | 2057 |
2056 // Trigger saving to exercise some special case handling during updating. | 2058 // Trigger saving to exercise some special case handling during updating. |
2057 PasswordForm new_credentials; | 2059 PasswordForm new_credentials; |
2058 EXPECT_CALL(MockFormSaver::Get(&form_manager), Update(_, _, _, nullptr)) | 2060 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Update(_, _, _, nullptr)) |
2059 .WillOnce(SaveArg<0>(&new_credentials)); | 2061 .WillOnce(SaveArg<0>(&new_credentials)); |
2060 | 2062 |
2061 form_manager.Update(*saved_match()); | 2063 form_manager->Update(*saved_match()); |
2062 | 2064 |
2063 // No meta-information should be updated, only the password. | 2065 // No meta-information should be updated, only the password. |
2064 EXPECT_EQ(credentials.new_password_value, new_credentials.password_value); | 2066 EXPECT_EQ(credentials.new_password_value, new_credentials.password_value); |
2065 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); | 2067 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); |
2066 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); | 2068 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); |
2067 EXPECT_EQ(saved_match()->submit_element, new_credentials.submit_element); | 2069 EXPECT_EQ(saved_match()->submit_element, new_credentials.submit_element); |
2068 } | 2070 } |
2069 | 2071 |
2070 TEST_F(PasswordFormManagerTest, TestUpdateNoUsernameTextfieldPresent) { | 2072 TEST_F(PasswordFormManagerTest, TestUpdateNoUsernameTextfieldPresent) { |
2071 // Add a new password field to the test form and insert a |username_value| | 2073 // Add a new password field to the test form and insert a |username_value| |
(...skipping 10 matching lines...) Expand all Loading... | |
2082 // should not serve as a source for updating meta-information stored with the | 2084 // should not serve as a source for updating meta-information stored with the |
2083 // old credentials, such as element names, as they are likely going to be | 2085 // old credentials, such as element names, as they are likely going to be |
2084 // different between change password and login forms. To test this in depth, | 2086 // different between change password and login forms. To test this in depth, |
2085 // forcibly wipe |submit_element|, which should normally trigger updating this | 2087 // forcibly wipe |submit_element|, which should normally trigger updating this |
2086 // field from |observed_form| during updating as a special case. We | 2088 // field from |observed_form| during updating as a special case. We |
2087 // will verify in the end that this did not happen. | 2089 // will verify in the end that this did not happen. |
2088 saved_match()->submit_element.clear(); | 2090 saved_match()->submit_element.clear(); |
2089 | 2091 |
2090 FakeFormFetcher fetcher; | 2092 FakeFormFetcher fetcher; |
2091 fetcher.Fetch(); | 2093 fetcher.Fetch(); |
2092 PasswordFormManager form_manager(password_manager(), client(), | 2094 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
2093 client()->driver(), *observed_form(), | 2095 password_manager(), client(), client()->driver(), *observed_form(), |
2094 base::MakeUnique<MockFormSaver>(), &fetcher); | 2096 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2095 | 2097 |
2096 fetcher.SetNonFederated({saved_match()}, 0u); | 2098 fetcher.SetNonFederated({saved_match()}, 0u); |
2097 | 2099 |
2098 // User submits current and new credentials to the observed form. | 2100 // User submits current and new credentials to the observed form. |
2099 PasswordForm credentials(*observed_form()); | 2101 PasswordForm credentials(*observed_form()); |
2100 // The |username_value| contains a text that's unlikely to be real username. | 2102 // The |username_value| contains a text that's unlikely to be real username. |
2101 credentials.username_value = ASCIIToUTF16("3"); | 2103 credentials.username_value = ASCIIToUTF16("3"); |
2102 credentials.password_value = saved_match()->password_value; | 2104 credentials.password_value = saved_match()->password_value; |
2103 credentials.new_password_value = ASCIIToUTF16("test2"); | 2105 credentials.new_password_value = ASCIIToUTF16("test2"); |
2104 credentials.preferred = true; | 2106 credentials.preferred = true; |
2105 form_manager.ProvisionallySave( | 2107 form_manager->ProvisionallySave( |
2106 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2108 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2107 | 2109 |
2108 // Successful login. The PasswordManager would instruct PasswordFormManager | 2110 // Successful login. The PasswordManager would instruct PasswordFormManager |
2109 // to save, and since this is an update, it should know not to save as a new | 2111 // to save, and since this is an update, it should know not to save as a new |
2110 // login. | 2112 // login. |
2111 EXPECT_FALSE(form_manager.IsNewLogin()); | 2113 EXPECT_FALSE(form_manager->IsNewLogin()); |
2112 EXPECT_TRUE(form_manager.is_possible_change_password_form_without_username()); | 2114 EXPECT_TRUE( |
2115 form_manager->is_possible_change_password_form_without_username()); | |
2113 | 2116 |
2114 // By now, the PasswordFormManager should have promoted the new password value | 2117 // By now, the PasswordFormManager should have promoted the new password value |
2115 // already to be the current password, and should no longer maintain any info | 2118 // already to be the current password, and should no longer maintain any info |
2116 // about the new password value. | 2119 // about the new password value. |
2117 EXPECT_EQ(saved_match()->username_value, | 2120 EXPECT_EQ(saved_match()->username_value, |
2118 form_manager.pending_credentials().username_value); | 2121 form_manager->pending_credentials().username_value); |
2119 EXPECT_EQ(credentials.new_password_value, | 2122 EXPECT_EQ(credentials.new_password_value, |
2120 form_manager.pending_credentials().password_value); | 2123 form_manager->pending_credentials().password_value); |
2121 EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty()); | 2124 EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty()); |
2122 | 2125 |
2123 // Trigger saving to exercise some special case handling during updating. | 2126 // Trigger saving to exercise some special case handling during updating. |
2124 PasswordForm new_credentials; | 2127 PasswordForm new_credentials; |
2125 EXPECT_CALL(MockFormSaver::Get(&form_manager), Update(_, _, _, nullptr)) | 2128 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Update(_, _, _, nullptr)) |
2126 .WillOnce(SaveArg<0>(&new_credentials)); | 2129 .WillOnce(SaveArg<0>(&new_credentials)); |
2127 | 2130 |
2128 form_manager.Update(form_manager.pending_credentials()); | 2131 form_manager->Update(form_manager->pending_credentials()); |
2129 | 2132 |
2130 // No other information than password value should be updated. In particular | 2133 // No other information than password value should be updated. In particular |
2131 // not the username. | 2134 // not the username. |
2132 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); | 2135 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); |
2133 EXPECT_EQ(credentials.new_password_value, new_credentials.password_value); | 2136 EXPECT_EQ(credentials.new_password_value, new_credentials.password_value); |
2134 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); | 2137 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); |
2135 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); | 2138 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); |
2136 EXPECT_EQ(saved_match()->submit_element, new_credentials.submit_element); | 2139 EXPECT_EQ(saved_match()->submit_element, new_credentials.submit_element); |
2137 } | 2140 } |
2138 | 2141 |
2139 // Test that if WipeStoreCopyIfOutdated is called before password store | 2142 // Test that if WipeStoreCopyIfOutdated is called before password store |
2140 // callback, the UMA is signalled accordingly. | 2143 // callback, the UMA is signalled accordingly. |
2141 TEST_F(PasswordFormManagerTest, WipeStoreCopyIfOutdated_BeforeStoreCallback) { | 2144 TEST_F(PasswordFormManagerTest, WipeStoreCopyIfOutdated_BeforeStoreCallback) { |
2142 PasswordForm form(*saved_match()); | 2145 PasswordForm form(*saved_match()); |
2143 form.password_value = ASCIIToUTF16("nonempty-password"); | 2146 form.password_value = ASCIIToUTF16("nonempty-password"); |
2144 | 2147 |
2145 FakeFormFetcher fetcher; | 2148 FakeFormFetcher fetcher; |
2146 fetcher.Fetch(); | 2149 fetcher.Fetch(); |
2147 PasswordFormManager form_manager(password_manager(), client(), | 2150 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
2148 client()->driver(), form, | 2151 password_manager(), client(), client()->driver(), form, |
2149 base::MakeUnique<MockFormSaver>(), &fetcher); | 2152 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2150 // The creation of |fetcher| keeps it waiting for store results. This test | 2153 // The creation of |fetcher| keeps it waiting for store results. This test |
2151 // keeps the fetcher waiting on purpose. | 2154 // keeps the fetcher waiting on purpose. |
2152 | 2155 |
2153 PasswordForm submitted_form(form); | 2156 PasswordForm submitted_form(form); |
2154 submitted_form.password_value += ASCIIToUTF16("add stuff, make it different"); | 2157 submitted_form.password_value += ASCIIToUTF16("add stuff, make it different"); |
2155 form_manager.ProvisionallySave( | 2158 form_manager->ProvisionallySave( |
2156 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2159 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2157 | 2160 |
2158 base::HistogramTester histogram_tester; | 2161 base::HistogramTester histogram_tester; |
2159 EXPECT_CALL(MockFormSaver::Get(&form_manager), | 2162 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), |
2160 WipeOutdatedCopies(form_manager.pending_credentials(), _, _)); | 2163 WipeOutdatedCopies(form_manager->pending_credentials(), _, _)); |
2161 form_manager.WipeStoreCopyIfOutdated(); | 2164 form_manager->WipeStoreCopyIfOutdated(); |
2162 histogram_tester.ExpectUniqueSample("PasswordManager.StoreReadyWhenWiping", 0, | 2165 histogram_tester.ExpectUniqueSample("PasswordManager.StoreReadyWhenWiping", 0, |
2163 1); | 2166 1); |
2164 } | 2167 } |
2165 | 2168 |
2166 TEST_F(PasswordFormManagerTest, GenerationStatusChangedWithPassword) { | 2169 TEST_F(PasswordFormManagerTest, GenerationStatusChangedWithPassword) { |
2167 PasswordForm generated_form = *observed_form(); | 2170 PasswordForm generated_form = *observed_form(); |
2168 generated_form.type = PasswordForm::TYPE_GENERATED; | 2171 generated_form.type = PasswordForm::TYPE_GENERATED; |
2169 generated_form.username_value = ASCIIToUTF16("username"); | 2172 generated_form.username_value = ASCIIToUTF16("username"); |
2170 generated_form.password_value = ASCIIToUTF16("password2"); | 2173 generated_form.password_value = ASCIIToUTF16("password2"); |
2171 generated_form.preferred = true; | 2174 generated_form.preferred = true; |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2270 bool kFalseTrue[] = {false, true}; | 2273 bool kFalseTrue[] = {false, true}; |
2271 for (autofill::ServerFieldType vote : kChangePasswordVotes) { | 2274 for (autofill::ServerFieldType vote : kChangePasswordVotes) { |
2272 for (bool has_confirmation_field : kFalseTrue) | 2275 for (bool has_confirmation_field : kFalseTrue) |
2273 ChangePasswordUploadTest(vote, has_confirmation_field); | 2276 ChangePasswordUploadTest(vote, has_confirmation_field); |
2274 } | 2277 } |
2275 } | 2278 } |
2276 | 2279 |
2277 TEST_F(PasswordFormManagerTest, TestUpdatePSLMatchedCredentials) { | 2280 TEST_F(PasswordFormManagerTest, TestUpdatePSLMatchedCredentials) { |
2278 FakeFormFetcher fetcher; | 2281 FakeFormFetcher fetcher; |
2279 fetcher.Fetch(); | 2282 fetcher.Fetch(); |
2280 PasswordFormManager form_manager(password_manager(), client(), | 2283 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
2281 client()->driver(), *observed_form(), | 2284 password_manager(), client(), client()->driver(), *observed_form(), |
2282 base::MakeUnique<MockFormSaver>(), &fetcher); | 2285 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2283 fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u); | 2286 fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u); |
2284 | 2287 |
2285 // User submits a credentials with an old username and a new password. | 2288 // User submits a credentials with an old username and a new password. |
2286 PasswordForm credentials(*observed_form()); | 2289 PasswordForm credentials(*observed_form()); |
2287 credentials.username_value = saved_match()->username_value; | 2290 credentials.username_value = saved_match()->username_value; |
2288 credentials.password_value = ASCIIToUTF16("new_password"); | 2291 credentials.password_value = ASCIIToUTF16("new_password"); |
2289 credentials.preferred = true; | 2292 credentials.preferred = true; |
2290 form_manager.ProvisionallySave( | 2293 form_manager->ProvisionallySave( |
2291 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2294 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2292 | 2295 |
2293 // Successful login. The PasswordManager would instruct PasswordFormManager | 2296 // Successful login. The PasswordManager would instruct PasswordFormManager |
2294 // to save, and since this is an update, it should know not to save as a new | 2297 // to save, and since this is an update, it should know not to save as a new |
2295 // login. | 2298 // login. |
2296 EXPECT_FALSE(form_manager.IsNewLogin()); | 2299 EXPECT_FALSE(form_manager->IsNewLogin()); |
2297 | 2300 |
2298 // Trigger saving to exercise some special case handling during updating. | 2301 // Trigger saving to exercise some special case handling during updating. |
2299 PasswordForm new_credentials; | 2302 PasswordForm new_credentials; |
2300 std::vector<autofill::PasswordForm> credentials_to_update; | 2303 std::vector<autofill::PasswordForm> credentials_to_update; |
2301 EXPECT_CALL(MockFormSaver::Get(&form_manager), Update(_, _, _, nullptr)) | 2304 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Update(_, _, _, nullptr)) |
2302 .WillOnce(testing::DoAll(SaveArg<0>(&new_credentials), | 2305 .WillOnce(testing::DoAll(SaveArg<0>(&new_credentials), |
2303 SaveArgPointee<2>(&credentials_to_update))); | 2306 SaveArgPointee<2>(&credentials_to_update))); |
2304 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 2307 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
2305 StartUploadRequest(_, false, _, _, true)); | 2308 StartUploadRequest(_, false, _, _, true)); |
2306 | 2309 |
2307 form_manager.Save(); | 2310 form_manager->Save(); |
2308 | 2311 |
2309 // No meta-information should be updated, only the password. | 2312 // No meta-information should be updated, only the password. |
2310 EXPECT_EQ(credentials.password_value, new_credentials.password_value); | 2313 EXPECT_EQ(credentials.password_value, new_credentials.password_value); |
2311 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); | 2314 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); |
2312 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); | 2315 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); |
2313 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); | 2316 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); |
2314 EXPECT_EQ(saved_match()->origin, new_credentials.origin); | 2317 EXPECT_EQ(saved_match()->origin, new_credentials.origin); |
2315 | 2318 |
2316 ASSERT_EQ(1u, credentials_to_update.size()); | 2319 ASSERT_EQ(1u, credentials_to_update.size()); |
2317 EXPECT_EQ(credentials.password_value, | 2320 EXPECT_EQ(credentials.password_value, |
2318 credentials_to_update[0].password_value); | 2321 credentials_to_update[0].password_value); |
2319 EXPECT_EQ(psl_saved_match()->username_element, | 2322 EXPECT_EQ(psl_saved_match()->username_element, |
2320 credentials_to_update[0].username_element); | 2323 credentials_to_update[0].username_element); |
2321 EXPECT_EQ(psl_saved_match()->username_element, | 2324 EXPECT_EQ(psl_saved_match()->username_element, |
2322 credentials_to_update[0].username_element); | 2325 credentials_to_update[0].username_element); |
2323 EXPECT_EQ(psl_saved_match()->password_element, | 2326 EXPECT_EQ(psl_saved_match()->password_element, |
2324 credentials_to_update[0].password_element); | 2327 credentials_to_update[0].password_element); |
2325 EXPECT_EQ(psl_saved_match()->origin, credentials_to_update[0].origin); | 2328 EXPECT_EQ(psl_saved_match()->origin, credentials_to_update[0].origin); |
2326 } | 2329 } |
2327 | 2330 |
2328 TEST_F(PasswordFormManagerTest, | 2331 TEST_F(PasswordFormManagerTest, |
2329 TestNotUpdatePSLMatchedCredentialsWithAnotherUsername) { | 2332 TestNotUpdatePSLMatchedCredentialsWithAnotherUsername) { |
2330 FakeFormFetcher fetcher; | 2333 FakeFormFetcher fetcher; |
2331 fetcher.Fetch(); | 2334 fetcher.Fetch(); |
2332 PasswordFormManager form_manager(password_manager(), client(), | 2335 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
2333 client()->driver(), *observed_form(), | 2336 password_manager(), client(), client()->driver(), *observed_form(), |
2334 base::MakeUnique<MockFormSaver>(), &fetcher); | 2337 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2335 psl_saved_match()->username_value += ASCIIToUTF16("1"); | 2338 psl_saved_match()->username_value += ASCIIToUTF16("1"); |
2336 fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u); | 2339 fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u); |
2337 | 2340 |
2338 // User submits a credentials with an old username and a new password. | 2341 // User submits a credentials with an old username and a new password. |
2339 PasswordForm credentials(*observed_form()); | 2342 PasswordForm credentials(*observed_form()); |
2340 credentials.username_value = saved_match()->username_value; | 2343 credentials.username_value = saved_match()->username_value; |
2341 credentials.password_value = ASCIIToUTF16("new_password"); | 2344 credentials.password_value = ASCIIToUTF16("new_password"); |
2342 credentials.preferred = true; | 2345 credentials.preferred = true; |
2343 form_manager.ProvisionallySave( | 2346 form_manager->ProvisionallySave( |
2344 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2347 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2345 | 2348 |
2346 // Successful login. The PasswordManager would instruct PasswordFormManager | 2349 // Successful login. The PasswordManager would instruct PasswordFormManager |
2347 // to save, and since this is an update, it should know not to save as a new | 2350 // to save, and since this is an update, it should know not to save as a new |
2348 // login. | 2351 // login. |
2349 EXPECT_FALSE(form_manager.IsNewLogin()); | 2352 EXPECT_FALSE(form_manager->IsNewLogin()); |
2350 | 2353 |
2351 // Trigger saving to exercise some special case handling during updating. | 2354 // Trigger saving to exercise some special case handling during updating. |
2352 PasswordForm new_credentials; | 2355 PasswordForm new_credentials; |
2353 EXPECT_CALL(MockFormSaver::Get(&form_manager), | 2356 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), |
2354 Update(_, _, Pointee(IsEmpty()), nullptr)) | 2357 Update(_, _, Pointee(IsEmpty()), nullptr)) |
2355 .WillOnce(testing::SaveArg<0>(&new_credentials)); | 2358 .WillOnce(testing::SaveArg<0>(&new_credentials)); |
2356 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 2359 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
2357 StartUploadRequest(_, false, _, _, true)); | 2360 StartUploadRequest(_, false, _, _, true)); |
2358 | 2361 |
2359 form_manager.Save(); | 2362 form_manager->Save(); |
2360 | 2363 |
2361 // No meta-information should be updated, only the password. | 2364 // No meta-information should be updated, only the password. |
2362 EXPECT_EQ(credentials.password_value, new_credentials.password_value); | 2365 EXPECT_EQ(credentials.password_value, new_credentials.password_value); |
2363 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); | 2366 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); |
2364 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); | 2367 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); |
2365 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); | 2368 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); |
2366 EXPECT_EQ(saved_match()->origin, new_credentials.origin); | 2369 EXPECT_EQ(saved_match()->origin, new_credentials.origin); |
2367 } | 2370 } |
2368 | 2371 |
2369 TEST_F(PasswordFormManagerTest, | 2372 TEST_F(PasswordFormManagerTest, |
2370 TestNotUpdatePSLMatchedCredentialsWithAnotherPassword) { | 2373 TestNotUpdatePSLMatchedCredentialsWithAnotherPassword) { |
2371 FakeFormFetcher fetcher; | 2374 FakeFormFetcher fetcher; |
2372 fetcher.Fetch(); | 2375 fetcher.Fetch(); |
2373 PasswordFormManager form_manager(password_manager(), client(), | 2376 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
2374 client()->driver(), *observed_form(), | 2377 password_manager(), client(), client()->driver(), *observed_form(), |
2375 base::MakeUnique<MockFormSaver>(), &fetcher); | 2378 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2376 psl_saved_match()->password_value += ASCIIToUTF16("1"); | 2379 psl_saved_match()->password_value += ASCIIToUTF16("1"); |
2377 fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u); | 2380 fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u); |
2378 | 2381 |
2379 // User submits a credentials with an old username and a new password. | 2382 // User submits a credentials with an old username and a new password. |
2380 PasswordForm credentials(*observed_form()); | 2383 PasswordForm credentials(*observed_form()); |
2381 credentials.username_value = saved_match()->username_value; | 2384 credentials.username_value = saved_match()->username_value; |
2382 credentials.password_value = ASCIIToUTF16("new_password"); | 2385 credentials.password_value = ASCIIToUTF16("new_password"); |
2383 credentials.preferred = true; | 2386 credentials.preferred = true; |
2384 form_manager.ProvisionallySave( | 2387 form_manager->ProvisionallySave( |
2385 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2388 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2386 | 2389 |
2387 // Successful login. The PasswordManager would instruct PasswordFormManager | 2390 // Successful login. The PasswordManager would instruct PasswordFormManager |
2388 // to save, and since this is an update, it should know not to save as a new | 2391 // to save, and since this is an update, it should know not to save as a new |
2389 // login. | 2392 // login. |
2390 EXPECT_FALSE(form_manager.IsNewLogin()); | 2393 EXPECT_FALSE(form_manager->IsNewLogin()); |
2391 | 2394 |
2392 // Trigger saving to exercise some special case handling during updating. | 2395 // Trigger saving to exercise some special case handling during updating. |
2393 PasswordForm new_credentials; | 2396 PasswordForm new_credentials; |
2394 EXPECT_CALL(MockFormSaver::Get(&form_manager), | 2397 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), |
2395 Update(_, _, Pointee(IsEmpty()), nullptr)) | 2398 Update(_, _, Pointee(IsEmpty()), nullptr)) |
2396 .WillOnce(testing::SaveArg<0>(&new_credentials)); | 2399 .WillOnce(testing::SaveArg<0>(&new_credentials)); |
2397 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 2400 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
2398 StartUploadRequest(_, false, _, _, true)); | 2401 StartUploadRequest(_, false, _, _, true)); |
2399 | 2402 |
2400 form_manager.Save(); | 2403 form_manager->Save(); |
2401 | 2404 |
2402 // No meta-information should be updated, only the password. | 2405 // No meta-information should be updated, only the password. |
2403 EXPECT_EQ(credentials.password_value, new_credentials.password_value); | 2406 EXPECT_EQ(credentials.password_value, new_credentials.password_value); |
2404 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); | 2407 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); |
2405 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); | 2408 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); |
2406 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); | 2409 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); |
2407 EXPECT_EQ(saved_match()->origin, new_credentials.origin); | 2410 EXPECT_EQ(saved_match()->origin, new_credentials.origin); |
2408 } | 2411 } |
2409 | 2412 |
2410 TEST_F(PasswordFormManagerTest, TestNotUpdateWhenOnlyPSLMatched) { | 2413 TEST_F(PasswordFormManagerTest, TestNotUpdateWhenOnlyPSLMatched) { |
2411 FakeFormFetcher fetcher; | 2414 FakeFormFetcher fetcher; |
2412 fetcher.Fetch(); | 2415 fetcher.Fetch(); |
2413 PasswordFormManager form_manager(password_manager(), client(), | 2416 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
2414 client()->driver(), *observed_form(), | 2417 password_manager(), client(), client()->driver(), *observed_form(), |
2415 base::MakeUnique<MockFormSaver>(), &fetcher); | 2418 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2416 fetcher.SetNonFederated({psl_saved_match()}, 0u); | 2419 fetcher.SetNonFederated({psl_saved_match()}, 0u); |
2417 | 2420 |
2418 // User submits a credentials with an old username and a new password. | 2421 // User submits a credentials with an old username and a new password. |
2419 PasswordForm credentials(*observed_form()); | 2422 PasswordForm credentials(*observed_form()); |
2420 credentials.username_value = saved_match()->username_value; | 2423 credentials.username_value = saved_match()->username_value; |
2421 credentials.password_value = ASCIIToUTF16("new_password"); | 2424 credentials.password_value = ASCIIToUTF16("new_password"); |
2422 credentials.preferred = true; | 2425 credentials.preferred = true; |
2423 form_manager.ProvisionallySave( | 2426 form_manager->ProvisionallySave( |
2424 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2427 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2425 | 2428 |
2426 EXPECT_TRUE(form_manager.IsNewLogin()); | 2429 EXPECT_TRUE(form_manager->IsNewLogin()); |
2427 | 2430 |
2428 // PSL matched credential should not be updated, since we are not sure that | 2431 // PSL matched credential should not be updated, since we are not sure that |
2429 // this is the same credential as submitted one. | 2432 // this is the same credential as submitted one. |
2430 PasswordForm new_credentials; | 2433 PasswordForm new_credentials; |
2431 EXPECT_CALL(MockFormSaver::Get(&form_manager), Save(_, _, nullptr)) | 2434 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Save(_, _, nullptr)) |
2432 .WillOnce(testing::SaveArg<0>(&new_credentials)); | 2435 .WillOnce(testing::SaveArg<0>(&new_credentials)); |
2433 | 2436 |
2434 form_manager.Save(); | 2437 form_manager->Save(); |
2435 | 2438 |
2436 EXPECT_EQ(credentials.password_value, new_credentials.password_value); | 2439 EXPECT_EQ(credentials.password_value, new_credentials.password_value); |
2437 EXPECT_EQ(credentials.username_value, new_credentials.username_value); | 2440 EXPECT_EQ(credentials.username_value, new_credentials.username_value); |
2438 EXPECT_EQ(credentials.password_element, new_credentials.password_element); | 2441 EXPECT_EQ(credentials.password_element, new_credentials.password_element); |
2439 EXPECT_EQ(credentials.username_element, new_credentials.username_element); | 2442 EXPECT_EQ(credentials.username_element, new_credentials.username_element); |
2440 EXPECT_EQ(credentials.origin, new_credentials.origin); | 2443 EXPECT_EQ(credentials.origin, new_credentials.origin); |
2441 } | 2444 } |
2442 | 2445 |
2443 TEST_F(PasswordFormManagerTest, | 2446 TEST_F(PasswordFormManagerTest, |
2444 TestSavingOnChangePasswordFormGenerationNoStoredForms) { | 2447 TestSavingOnChangePasswordFormGenerationNoStoredForms) { |
(...skipping 114 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2559 field.name = ASCIIToUTF16("Passwd"); | 2562 field.name = ASCIIToUTF16("Passwd"); |
2560 field.form_control_type = "password"; | 2563 field.form_control_type = "password"; |
2561 observed_form()->form_data.fields.push_back(field); | 2564 observed_form()->form_data.fields.push_back(field); |
2562 | 2565 |
2563 field.label = ASCIIToUTF16("new password"); | 2566 field.label = ASCIIToUTF16("new password"); |
2564 field.name = ASCIIToUTF16("NewPasswd"); | 2567 field.name = ASCIIToUTF16("NewPasswd"); |
2565 observed_form()->form_data.fields.push_back(field); | 2568 observed_form()->form_data.fields.push_back(field); |
2566 | 2569 |
2567 FakeFormFetcher fetcher; | 2570 FakeFormFetcher fetcher; |
2568 fetcher.Fetch(); | 2571 fetcher.Fetch(); |
2569 PasswordFormManager form_manager(password_manager(), client(), | 2572 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
2570 client()->driver(), *observed_form(), | 2573 password_manager(), client(), client()->driver(), *observed_form(), |
2571 base::MakeUnique<MockFormSaver>(), &fetcher); | 2574 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2572 fetcher.SetNonFederated({saved_match()}, 0u); | 2575 fetcher.SetNonFederated({saved_match()}, 0u); |
2573 | 2576 |
2574 // User submits current and new credentials to the observed form. | 2577 // User submits current and new credentials to the observed form. |
2575 PasswordForm submitted_form(*observed_form()); | 2578 PasswordForm submitted_form(*observed_form()); |
2576 submitted_form.password_value = saved_match()->password_value; | 2579 submitted_form.password_value = saved_match()->password_value; |
2577 submitted_form.new_password_value = ASCIIToUTF16("test2"); | 2580 submitted_form.new_password_value = ASCIIToUTF16("test2"); |
2578 submitted_form.preferred = true; | 2581 submitted_form.preferred = true; |
2579 form_manager.ProvisionallySave( | 2582 form_manager->ProvisionallySave( |
2580 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2583 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2581 | 2584 |
2582 // Successful login. The PasswordManager would instruct PasswordFormManager | 2585 // Successful login. The PasswordManager would instruct PasswordFormManager |
2583 // to update. | 2586 // to update. |
2584 EXPECT_FALSE(form_manager.IsNewLogin()); | 2587 EXPECT_FALSE(form_manager->IsNewLogin()); |
2585 EXPECT_TRUE(form_manager.is_possible_change_password_form_without_username()); | 2588 EXPECT_TRUE( |
2589 form_manager->is_possible_change_password_form_without_username()); | |
2586 | 2590 |
2587 // By now, the PasswordFormManager should have promoted the new password | 2591 // By now, the PasswordFormManager should have promoted the new password |
2588 // value already to be the current password, and should no longer maintain | 2592 // value already to be the current password, and should no longer maintain |
2589 // any info about the new password value. | 2593 // any info about the new password value. |
2590 EXPECT_EQ(submitted_form.new_password_value, | 2594 EXPECT_EQ(submitted_form.new_password_value, |
2591 form_manager.pending_credentials().password_value); | 2595 form_manager->pending_credentials().password_value); |
2592 EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty()); | 2596 EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty()); |
2593 | 2597 |
2594 std::map<base::string16, autofill::ServerFieldType> expected_types; | 2598 std::map<base::string16, autofill::ServerFieldType> expected_types; |
2595 expected_types[observed_form()->password_element] = autofill::PASSWORD; | 2599 expected_types[observed_form()->password_element] = autofill::PASSWORD; |
2596 expected_types[observed_form()->new_password_element] = | 2600 expected_types[observed_form()->new_password_element] = |
2597 autofill::NEW_PASSWORD; | 2601 autofill::NEW_PASSWORD; |
2598 | 2602 |
2599 autofill::ServerFieldTypeSet expected_available_field_types; | 2603 autofill::ServerFieldTypeSet expected_available_field_types; |
2600 expected_available_field_types.insert(autofill::PASSWORD); | 2604 expected_available_field_types.insert(autofill::PASSWORD); |
2601 expected_available_field_types.insert(autofill::NEW_PASSWORD); | 2605 expected_available_field_types.insert(autofill::NEW_PASSWORD); |
2602 | 2606 |
2603 std::string observed_form_signature = | 2607 std::string observed_form_signature = |
2604 autofill::FormStructure(observed_form()->form_data).FormSignatureAsStr(); | 2608 autofill::FormStructure(observed_form()->form_data).FormSignatureAsStr(); |
2605 | 2609 |
2606 std::string expected_login_signature = | 2610 std::string expected_login_signature = |
2607 autofill::FormStructure(saved_match()->form_data).FormSignatureAsStr(); | 2611 autofill::FormStructure(saved_match()->form_data).FormSignatureAsStr(); |
2608 | 2612 |
2609 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 2613 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
2610 StartUploadRequest(CheckUploadedAutofillTypesAndSignature( | 2614 StartUploadRequest(CheckUploadedAutofillTypesAndSignature( |
2611 observed_form_signature, expected_types, | 2615 observed_form_signature, expected_types, |
2612 false /* expect_generation_vote */), | 2616 false /* expect_generation_vote */), |
2613 false, expected_available_field_types, | 2617 false, expected_available_field_types, |
2614 expected_login_signature, true)); | 2618 expected_login_signature, true)); |
2615 | 2619 |
2616 form_manager.Update(*saved_match()); | 2620 form_manager->Update(*saved_match()); |
2617 } | 2621 } |
2618 | 2622 |
2619 // Checks uploading a vote about the usage of the password generation popup. | 2623 // Checks uploading a vote about the usage of the password generation popup. |
2620 TEST_F(PasswordFormManagerTest, GeneratedVoteUpload) { | 2624 TEST_F(PasswordFormManagerTest, GeneratedVoteUpload) { |
2621 bool kFalseTrue[] = {false, true}; | 2625 bool kFalseTrue[] = {false, true}; |
2622 SavePromptInteraction kSavePromptInterations[] = {SAVE, NEVER, | 2626 SavePromptInteraction kSavePromptInterations[] = {SAVE, NEVER, |
2623 NO_INTERACTION}; | 2627 NO_INTERACTION}; |
2624 for (bool is_manual_generation : kFalseTrue) { | 2628 for (bool is_manual_generation : kFalseTrue) { |
2625 for (bool is_change_password_form : kFalseTrue) { | 2629 for (bool is_change_password_form : kFalseTrue) { |
2626 for (bool has_generated_password : kFalseTrue) { | 2630 for (bool has_generated_password : kFalseTrue) { |
(...skipping 15 matching lines...) Expand all Loading... | |
2642 form.form_data = saved_match()->form_data; | 2646 form.form_data = saved_match()->form_data; |
2643 | 2647 |
2644 // Create submitted form. | 2648 // Create submitted form. |
2645 PasswordForm submitted_form(form); | 2649 PasswordForm submitted_form(form); |
2646 submitted_form.preferred = true; | 2650 submitted_form.preferred = true; |
2647 submitted_form.username_value = saved_match()->username_value; | 2651 submitted_form.username_value = saved_match()->username_value; |
2648 submitted_form.password_value = saved_match()->password_value; | 2652 submitted_form.password_value = saved_match()->password_value; |
2649 | 2653 |
2650 FakeFormFetcher fetcher; | 2654 FakeFormFetcher fetcher; |
2651 fetcher.Fetch(); | 2655 fetcher.Fetch(); |
2652 PasswordFormManager form_manager( | 2656 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
2653 password_manager(), client(), client()->driver(), form, | 2657 password_manager(), client(), client()->driver(), form, |
2654 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 2658 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
2655 base::string16 generation_element = form.password_element; | 2659 base::string16 generation_element = form.password_element; |
2656 if (found_generation_element) | 2660 if (found_generation_element) |
2657 form_manager.SaveGenerationFieldDetectedByClassifier(generation_element); | 2661 form_manager->SaveGenerationFieldDetectedByClassifier(generation_element); |
2658 else | 2662 else |
2659 form_manager.SaveGenerationFieldDetectedByClassifier(base::string16()); | 2663 form_manager->SaveGenerationFieldDetectedByClassifier(base::string16()); |
2660 | 2664 |
2661 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 2665 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
2662 | 2666 |
2663 autofill::FormStructure form_structure(submitted_form.form_data); | 2667 autofill::FormStructure form_structure(submitted_form.form_data); |
2664 | 2668 |
2665 EXPECT_CALL( | 2669 EXPECT_CALL( |
2666 *client()->mock_driver()->mock_autofill_download_manager(), | 2670 *client()->mock_driver()->mock_autofill_download_manager(), |
2667 StartUploadRequest(CheckUploadedFormClassifierVote( | 2671 StartUploadRequest(CheckUploadedFormClassifierVote( |
2668 found_generation_element, generation_element), | 2672 found_generation_element, generation_element), |
2669 false, _, _, true)); | 2673 false, _, _, true)); |
2670 | 2674 |
2671 form_manager.ProvisionallySave( | 2675 form_manager->ProvisionallySave( |
2672 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2676 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2673 form_manager.Save(); | 2677 form_manager->Save(); |
2674 } | 2678 } |
2675 } | 2679 } |
2676 | 2680 |
2677 TEST_F(PasswordFormManagerTest, FieldPropertiesMasksUpload) { | 2681 TEST_F(PasswordFormManagerTest, FieldPropertiesMasksUpload) { |
2678 PasswordForm form(*observed_form()); | 2682 PasswordForm form(*observed_form()); |
2679 form.form_data = saved_match()->form_data; | 2683 form.form_data = saved_match()->form_data; |
2680 | 2684 |
2681 // Create submitted form. | 2685 // Create submitted form. |
2682 PasswordForm submitted_form(form); | 2686 PasswordForm submitted_form(form); |
2683 submitted_form.preferred = true; | 2687 submitted_form.preferred = true; |
2684 submitted_form.username_value = saved_match()->username_value; | 2688 submitted_form.username_value = saved_match()->username_value; |
2685 submitted_form.password_value = saved_match()->password_value; | 2689 submitted_form.password_value = saved_match()->password_value; |
2686 | 2690 |
2687 FakeFormFetcher fetcher; | 2691 FakeFormFetcher fetcher; |
2688 fetcher.Fetch(); | 2692 fetcher.Fetch(); |
2689 PasswordFormManager form_manager( | 2693 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
2690 password_manager(), client(), client()->driver(), form, | 2694 password_manager(), client(), client()->driver(), form, |
2691 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 2695 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
2692 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 2696 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
2693 | 2697 |
2694 DCHECK_EQ(3U, form.form_data.fields.size()); | 2698 DCHECK_EQ(3U, form.form_data.fields.size()); |
2695 submitted_form.form_data.fields[1].properties_mask = | 2699 submitted_form.form_data.fields[1].properties_mask = |
2696 FieldPropertiesFlags::USER_TYPED; | 2700 FieldPropertiesFlags::USER_TYPED; |
2697 submitted_form.form_data.fields[2].properties_mask = | 2701 submitted_form.form_data.fields[2].properties_mask = |
2698 FieldPropertiesFlags::USER_TYPED; | 2702 FieldPropertiesFlags::USER_TYPED; |
2699 | 2703 |
2700 std::map<base::string16, autofill::FieldPropertiesMask> | 2704 std::map<base::string16, autofill::FieldPropertiesMask> |
2701 expected_field_properties; | 2705 expected_field_properties; |
2702 for (const autofill::FormFieldData& field : submitted_form.form_data.fields) | 2706 for (const autofill::FormFieldData& field : submitted_form.form_data.fields) |
2703 if (field.properties_mask) | 2707 if (field.properties_mask) |
2704 expected_field_properties[field.name] = field.properties_mask; | 2708 expected_field_properties[field.name] = field.properties_mask; |
2705 | 2709 |
2706 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 2710 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
2707 StartUploadRequest( | 2711 StartUploadRequest( |
2708 CheckFieldPropertiesMasksUpload(expected_field_properties), | 2712 CheckFieldPropertiesMasksUpload(expected_field_properties), |
2709 false, _, _, true)); | 2713 false, _, _, true)); |
2710 form_manager.ProvisionallySave( | 2714 form_manager->ProvisionallySave( |
2711 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2715 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2712 form_manager.Save(); | 2716 form_manager->Save(); |
2713 } | 2717 } |
2714 | 2718 |
2715 TEST_F(PasswordFormManagerTest, TestSavingAPIFormsWithSamePassword) { | 2719 TEST_F(PasswordFormManagerTest, TestSavingAPIFormsWithSamePassword) { |
2716 // Turn |observed_form| and |saved_match| to API created forms. | 2720 // Turn |observed_form| and |saved_match| to API created forms. |
2717 observed_form()->username_element.clear(); | 2721 observed_form()->username_element.clear(); |
2718 observed_form()->type = autofill::PasswordForm::TYPE_API; | 2722 observed_form()->type = autofill::PasswordForm::TYPE_API; |
2719 saved_match()->username_element.clear(); | 2723 saved_match()->username_element.clear(); |
2720 saved_match()->type = autofill::PasswordForm::TYPE_API; | 2724 saved_match()->type = autofill::PasswordForm::TYPE_API; |
2721 | 2725 |
2722 FakeFormFetcher fetcher; | 2726 FakeFormFetcher fetcher; |
2723 fetcher.Fetch(); | 2727 fetcher.Fetch(); |
2724 PasswordFormManager form_manager(password_manager(), client(), | 2728 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
2725 client()->driver(), *observed_form(), | 2729 password_manager(), client(), client()->driver(), *observed_form(), |
2726 base::MakeUnique<MockFormSaver>(), &fetcher); | 2730 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2727 fetcher.SetNonFederated({saved_match()}, 0u); | 2731 fetcher.SetNonFederated({saved_match()}, 0u); |
2728 | 2732 |
2729 // User submits new credentials with the same password as in already saved | 2733 // User submits new credentials with the same password as in already saved |
2730 // one. | 2734 // one. |
2731 PasswordForm credentials(*observed_form()); | 2735 PasswordForm credentials(*observed_form()); |
2732 credentials.username_value = | 2736 credentials.username_value = |
2733 saved_match()->username_value + ASCIIToUTF16("1"); | 2737 saved_match()->username_value + ASCIIToUTF16("1"); |
2734 credentials.password_value = saved_match()->password_value; | 2738 credentials.password_value = saved_match()->password_value; |
2735 credentials.preferred = true; | 2739 credentials.preferred = true; |
2736 | 2740 |
2737 form_manager.ProvisionallySave( | 2741 form_manager->ProvisionallySave( |
2738 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2742 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2739 | 2743 |
2740 EXPECT_TRUE(form_manager.IsNewLogin()); | 2744 EXPECT_TRUE(form_manager->IsNewLogin()); |
2741 | 2745 |
2742 PasswordForm new_credentials; | 2746 PasswordForm new_credentials; |
2743 EXPECT_CALL(MockFormSaver::Get(&form_manager), Save(_, _, nullptr)) | 2747 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Save(_, _, nullptr)) |
2744 .WillOnce(SaveArg<0>(&new_credentials)); | 2748 .WillOnce(SaveArg<0>(&new_credentials)); |
2745 | 2749 |
2746 form_manager.Save(); | 2750 form_manager->Save(); |
2747 | 2751 |
2748 EXPECT_EQ(saved_match()->username_value + ASCIIToUTF16("1"), | 2752 EXPECT_EQ(saved_match()->username_value + ASCIIToUTF16("1"), |
2749 new_credentials.username_value); | 2753 new_credentials.username_value); |
2750 EXPECT_EQ(saved_match()->password_value, new_credentials.password_value); | 2754 EXPECT_EQ(saved_match()->password_value, new_credentials.password_value); |
2751 EXPECT_EQ(base::string16(), new_credentials.username_element); | 2755 EXPECT_EQ(base::string16(), new_credentials.username_element); |
2752 EXPECT_EQ(autofill::PasswordForm::TYPE_API, new_credentials.type); | 2756 EXPECT_EQ(autofill::PasswordForm::TYPE_API, new_credentials.type); |
2753 } | 2757 } |
2754 | 2758 |
2755 TEST_F(PasswordFormManagerTest, SkipZeroClickIntact) { | 2759 TEST_F(PasswordFormManagerTest, SkipZeroClickIntact) { |
2756 saved_match()->skip_zero_click = true; | 2760 saved_match()->skip_zero_click = true; |
(...skipping 23 matching lines...) Expand all Loading... | |
2780 ASSERT_EQ(1u, credentials_to_update.size()); | 2784 ASSERT_EQ(1u, credentials_to_update.size()); |
2781 EXPECT_TRUE(credentials_to_update[0].skip_zero_click); | 2785 EXPECT_TRUE(credentials_to_update[0].skip_zero_click); |
2782 } | 2786 } |
2783 | 2787 |
2784 TEST_F(PasswordFormManagerTest, ProbablyAccountCreationUpload) { | 2788 TEST_F(PasswordFormManagerTest, ProbablyAccountCreationUpload) { |
2785 PasswordForm form(*observed_form()); | 2789 PasswordForm form(*observed_form()); |
2786 form.form_data = saved_match()->form_data; | 2790 form.form_data = saved_match()->form_data; |
2787 | 2791 |
2788 FakeFormFetcher fetcher; | 2792 FakeFormFetcher fetcher; |
2789 fetcher.Fetch(); | 2793 fetcher.Fetch(); |
2790 PasswordFormManager form_manager( | 2794 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
2791 password_manager(), client(), client()->driver(), form, | 2795 password_manager(), client(), client()->driver(), form, |
2792 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 2796 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
2793 | 2797 |
2794 PasswordForm form_to_save(form); | 2798 PasswordForm form_to_save(form); |
2795 form_to_save.preferred = true; | 2799 form_to_save.preferred = true; |
2796 form_to_save.username_element = ASCIIToUTF16("observed-username-field"); | 2800 form_to_save.username_element = ASCIIToUTF16("observed-username-field"); |
2797 form_to_save.username_value = saved_match()->username_value; | 2801 form_to_save.username_value = saved_match()->username_value; |
2798 form_to_save.password_value = saved_match()->password_value; | 2802 form_to_save.password_value = saved_match()->password_value; |
2799 form_to_save.does_look_like_signup_form = true; | 2803 form_to_save.does_look_like_signup_form = true; |
2800 | 2804 |
2801 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 2805 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
2802 | 2806 |
2803 autofill::FormStructure pending_structure(form_to_save.form_data); | 2807 autofill::FormStructure pending_structure(form_to_save.form_data); |
2804 autofill::ServerFieldTypeSet expected_available_field_types; | 2808 autofill::ServerFieldTypeSet expected_available_field_types; |
2805 std::map<base::string16, autofill::ServerFieldType> expected_types; | 2809 std::map<base::string16, autofill::ServerFieldType> expected_types; |
2806 expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE; | 2810 expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE; |
2807 expected_types[saved_match()->username_element] = autofill::UNKNOWN_TYPE; | 2811 expected_types[saved_match()->username_element] = autofill::UNKNOWN_TYPE; |
2808 expected_available_field_types.insert( | 2812 expected_available_field_types.insert( |
2809 autofill::PROBABLY_ACCOUNT_CREATION_PASSWORD); | 2813 autofill::PROBABLY_ACCOUNT_CREATION_PASSWORD); |
2810 expected_types[saved_match()->password_element] = | 2814 expected_types[saved_match()->password_element] = |
2811 autofill::PROBABLY_ACCOUNT_CREATION_PASSWORD; | 2815 autofill::PROBABLY_ACCOUNT_CREATION_PASSWORD; |
2812 | 2816 |
2813 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 2817 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
2814 StartUploadRequest( | 2818 StartUploadRequest( |
2815 CheckUploadedAutofillTypesAndSignature( | 2819 CheckUploadedAutofillTypesAndSignature( |
2816 pending_structure.FormSignatureAsStr(), expected_types, | 2820 pending_structure.FormSignatureAsStr(), expected_types, |
2817 false /* expect_generation_vote */), | 2821 false /* expect_generation_vote */), |
2818 false, expected_available_field_types, std::string(), true)); | 2822 false, expected_available_field_types, std::string(), true)); |
2819 | 2823 |
2820 form_manager.ProvisionallySave( | 2824 form_manager->ProvisionallySave( |
2821 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2825 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2822 form_manager.Save(); | 2826 form_manager->Save(); |
2823 } | 2827 } |
2824 | 2828 |
2825 TEST_F(PasswordFormManagerFillOnAccountSelectTest, ProcessFrame) { | 2829 TEST_F(PasswordFormManagerFillOnAccountSelectTest, ProcessFrame) { |
2826 EXPECT_CALL(*client()->mock_driver(), | 2830 EXPECT_CALL(*client()->mock_driver(), |
2827 ShowInitialPasswordAccountSuggestions(_)); | 2831 ShowInitialPasswordAccountSuggestions(_)); |
2828 fake_form_fetcher()->SetNonFederated({saved_match()}, 0u); | 2832 fake_form_fetcher()->SetNonFederated({saved_match()}, 0u); |
2829 } | 2833 } |
2830 | 2834 |
2831 // Check that PasswordFormManager records | 2835 // Check that PasswordFormManager records |
2832 // PasswordManager_LoginFollowingAutofill as part of processing a credential | 2836 // PasswordManager_LoginFollowingAutofill as part of processing a credential |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2868 static_cast<PasswordForm::Scheme>(correct); | 2872 static_cast<PasswordForm::Scheme>(correct); |
2869 const PasswordForm::Scheme kWrongScheme = | 2873 const PasswordForm::Scheme kWrongScheme = |
2870 static_cast<PasswordForm::Scheme>(wrong); | 2874 static_cast<PasswordForm::Scheme>(wrong); |
2871 SCOPED_TRACE(testing::Message() << "Correct scheme = " << kCorrectScheme | 2875 SCOPED_TRACE(testing::Message() << "Correct scheme = " << kCorrectScheme |
2872 << ", wrong scheme = " << kWrongScheme); | 2876 << ", wrong scheme = " << kWrongScheme); |
2873 | 2877 |
2874 PasswordForm observed = *observed_form(); | 2878 PasswordForm observed = *observed_form(); |
2875 observed.scheme = kCorrectScheme; | 2879 observed.scheme = kCorrectScheme; |
2876 FakeFormFetcher fetcher; | 2880 FakeFormFetcher fetcher; |
2877 fetcher.Fetch(); | 2881 fetcher.Fetch(); |
2878 PasswordFormManager form_manager( | 2882 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
2879 password_manager(), client(), | 2883 password_manager(), client(), |
2880 (kCorrectScheme == PasswordForm::SCHEME_HTML ? client()->driver() | 2884 (kCorrectScheme == PasswordForm::SCHEME_HTML ? client()->driver() |
2881 : nullptr), | 2885 : nullptr), |
2882 observed, base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 2886 observed, base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
2883 | 2887 |
2884 PasswordForm match = *saved_match(); | 2888 PasswordForm match = *saved_match(); |
2885 match.scheme = kCorrectScheme; | 2889 match.scheme = kCorrectScheme; |
2886 | 2890 |
2887 PasswordForm non_match = match; | 2891 PasswordForm non_match = match; |
2888 non_match.scheme = kWrongScheme; | 2892 non_match.scheme = kWrongScheme; |
2889 | 2893 |
2890 // First try putting the correct scheme first in returned matches. | 2894 // First try putting the correct scheme first in returned matches. |
2891 static_cast<FormFetcher::Consumer*>(&form_manager) | 2895 static_cast<FormFetcher::Consumer*>(form_manager.get()) |
2892 ->ProcessMatches({&match, &non_match}, 0u); | 2896 ->ProcessMatches({&match, &non_match}, 0u); |
2893 | 2897 |
2894 EXPECT_EQ(1u, form_manager.best_matches().size()); | 2898 EXPECT_EQ(1u, form_manager->best_matches().size()); |
2895 EXPECT_EQ(kCorrectScheme, | 2899 EXPECT_EQ(kCorrectScheme, |
2896 form_manager.best_matches().begin()->second->scheme); | 2900 form_manager->best_matches().begin()->second->scheme); |
2897 | 2901 |
2898 // Now try putting the correct scheme last in returned matches. | 2902 // Now try putting the correct scheme last in returned matches. |
2899 static_cast<FormFetcher::Consumer*>(&form_manager) | 2903 static_cast<FormFetcher::Consumer*>(form_manager.get()) |
2900 ->ProcessMatches({&non_match, &match}, 0u); | 2904 ->ProcessMatches({&non_match, &match}, 0u); |
2901 | 2905 |
2902 EXPECT_EQ(1u, form_manager.best_matches().size()); | 2906 EXPECT_EQ(1u, form_manager->best_matches().size()); |
2903 EXPECT_EQ(kCorrectScheme, | 2907 EXPECT_EQ(kCorrectScheme, |
2904 form_manager.best_matches().begin()->second->scheme); | 2908 form_manager->best_matches().begin()->second->scheme); |
2905 } | 2909 } |
2906 } | 2910 } |
2907 } | 2911 } |
2908 | 2912 |
2909 // Ensure that DoesManage takes into consideration drivers when origins are | 2913 // Ensure that DoesManage takes into consideration drivers when origins are |
2910 // different. | 2914 // different. |
2911 TEST_F(PasswordFormManagerTest, DoesManageDifferentOrigins) { | 2915 TEST_F(PasswordFormManagerTest, DoesManageDifferentOrigins) { |
2912 for (bool same_drivers : {false, true}) { | 2916 for (bool same_drivers : {false, true}) { |
2913 PasswordForm submitted_form(*observed_form()); | 2917 PasswordForm submitted_form(*observed_form()); |
2914 observed_form()->origin = GURL("http://accounts.google.com/a/Login"); | 2918 observed_form()->origin = GURL("http://accounts.google.com/a/Login"); |
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3039 | 3043 |
3040 EXPECT_THAT(credentials_to_update, IsEmpty()); | 3044 EXPECT_THAT(credentials_to_update, IsEmpty()); |
3041 } | 3045 } |
3042 | 3046 |
3043 // Check that on changing FormFetcher, the PasswordFormManager removes itself | 3047 // Check that on changing FormFetcher, the PasswordFormManager removes itself |
3044 // from consuming the old one. | 3048 // from consuming the old one. |
3045 TEST_F(PasswordFormManagerTest, DropFetcherOnDestruction) { | 3049 TEST_F(PasswordFormManagerTest, DropFetcherOnDestruction) { |
3046 MockFormFetcher fetcher; | 3050 MockFormFetcher fetcher; |
3047 FormFetcher::Consumer* added_consumer = nullptr; | 3051 FormFetcher::Consumer* added_consumer = nullptr; |
3048 EXPECT_CALL(fetcher, AddConsumer(_)).WillOnce(SaveArg<0>(&added_consumer)); | 3052 EXPECT_CALL(fetcher, AddConsumer(_)).WillOnce(SaveArg<0>(&added_consumer)); |
3049 auto form_manager = base::MakeUnique<PasswordFormManager>( | 3053 auto form_manager = base::MakeRefCounted<PasswordFormManager>( |
3050 password_manager(), client(), client()->driver(), *observed_form(), | 3054 password_manager(), client(), client()->driver(), *observed_form(), |
3051 base::MakeUnique<MockFormSaver>(), &fetcher); | 3055 base::MakeUnique<MockFormSaver>(), &fetcher); |
3052 EXPECT_EQ(form_manager.get(), added_consumer); | 3056 EXPECT_EQ(form_manager.get(), added_consumer); |
3053 | 3057 |
3054 EXPECT_CALL(fetcher, RemoveConsumer(form_manager.get())); | 3058 EXPECT_CALL(fetcher, RemoveConsumer(form_manager.get())); |
3055 form_manager.reset(); | 3059 form_manager = nullptr; |
3056 } | 3060 } |
3057 | 3061 |
3058 // Check that if asked to take ownership of the same FormFetcher which it had | 3062 // Check that if asked to take ownership of the same FormFetcher which it had |
3059 // consumed before, the PasswordFormManager does not add itself as a consumer | 3063 // consumed before, the PasswordFormManager does not add itself as a consumer |
3060 // again. | 3064 // again. |
3061 TEST_F(PasswordFormManagerTest, GrabFetcher_Same) { | 3065 TEST_F(PasswordFormManagerTest, GrabFetcher_Same) { |
3062 auto fetcher = base::MakeUnique<MockFormFetcher>(); | 3066 auto fetcher = base::MakeUnique<MockFormFetcher>(); |
3063 fetcher->Fetch(); | 3067 fetcher->Fetch(); |
3064 PasswordFormManager form_manager( | 3068 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
3065 password_manager(), client(), client()->driver(), *observed_form(), | 3069 password_manager(), client(), client()->driver(), *observed_form(), |
3066 base::MakeUnique<MockFormSaver>(), fetcher.get()); | 3070 base::MakeUnique<MockFormSaver>(), fetcher.get())); |
3067 | 3071 |
3068 EXPECT_CALL(*fetcher, AddConsumer(_)).Times(0); | 3072 EXPECT_CALL(*fetcher, AddConsumer(_)).Times(0); |
3069 EXPECT_CALL(*fetcher, RemoveConsumer(_)).Times(0); | 3073 EXPECT_CALL(*fetcher, RemoveConsumer(_)).Times(0); |
3070 form_manager.GrabFetcher(std::move(fetcher)); | 3074 form_manager->GrabFetcher(std::move(fetcher)); |
3071 // There will be a RemoveConsumer call as soon as form_manager goes out of | 3075 // There will be a RemoveConsumer call as soon as form_manager goes out of |
3072 // scope, but the test needs to ensure that there is none as a result of | 3076 // scope, but the test needs to ensure that there is none as a result of |
3073 // GrabFetcher. | 3077 // GrabFetcher. |
3074 Mock::VerifyAndClearExpectations(form_manager.form_fetcher()); | 3078 Mock::VerifyAndClearExpectations(form_manager->form_fetcher()); |
3075 } | 3079 } |
3076 | 3080 |
3077 // Check that if asked to take ownership of a different FormFetcher than which | 3081 // Check that if asked to take ownership of a different FormFetcher than which |
3078 // it had consumed before, the PasswordFormManager adds itself as a consumer | 3082 // it had consumed before, the PasswordFormManager adds itself as a consumer |
3079 // and replaces the references to the old results. | 3083 // and replaces the references to the old results. |
3080 TEST_F(PasswordFormManagerTest, GrabFetcher_Different) { | 3084 TEST_F(PasswordFormManagerTest, GrabFetcher_Different) { |
3081 PasswordForm old_match = *observed_form(); | 3085 PasswordForm old_match = *observed_form(); |
3082 old_match.username_value = ASCIIToUTF16("user1"); | 3086 old_match.username_value = ASCIIToUTF16("user1"); |
3083 old_match.password_value = ASCIIToUTF16("pass"); | 3087 old_match.password_value = ASCIIToUTF16("pass"); |
3084 fake_form_fetcher()->SetNonFederated({&old_match}, 0u); | 3088 fake_form_fetcher()->SetNonFederated({&old_match}, 0u); |
(...skipping 11 matching lines...) Expand all Loading... | |
3096 EXPECT_EQ(0u, form_manager()->best_matches().size()); | 3100 EXPECT_EQ(0u, form_manager()->best_matches().size()); |
3097 } | 3101 } |
3098 | 3102 |
3099 // Check that on changing FormFetcher, the PasswordFormManager removes itself | 3103 // Check that on changing FormFetcher, the PasswordFormManager removes itself |
3100 // from consuming the old one. | 3104 // from consuming the old one. |
3101 TEST_F(PasswordFormManagerTest, GrabFetcher_Remove) { | 3105 TEST_F(PasswordFormManagerTest, GrabFetcher_Remove) { |
3102 MockFormFetcher old_fetcher; | 3106 MockFormFetcher old_fetcher; |
3103 FormFetcher::Consumer* added_consumer = nullptr; | 3107 FormFetcher::Consumer* added_consumer = nullptr; |
3104 EXPECT_CALL(old_fetcher, AddConsumer(_)) | 3108 EXPECT_CALL(old_fetcher, AddConsumer(_)) |
3105 .WillOnce(SaveArg<0>(&added_consumer)); | 3109 .WillOnce(SaveArg<0>(&added_consumer)); |
3106 PasswordFormManager form_manager( | 3110 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
3107 password_manager(), client(), client()->driver(), *observed_form(), | 3111 password_manager(), client(), client()->driver(), *observed_form(), |
3108 base::MakeUnique<MockFormSaver>(), &old_fetcher); | 3112 base::MakeUnique<MockFormSaver>(), &old_fetcher)); |
3109 EXPECT_EQ(&form_manager, added_consumer); | 3113 EXPECT_EQ(form_manager.get(), added_consumer); |
3110 | 3114 |
3111 auto new_fetcher = base::MakeUnique<MockFormFetcher>(); | 3115 auto new_fetcher = base::MakeUnique<MockFormFetcher>(); |
3112 EXPECT_CALL(*new_fetcher, AddConsumer(&form_manager)); | 3116 EXPECT_CALL(*new_fetcher, AddConsumer(form_manager.get())); |
3113 EXPECT_CALL(old_fetcher, RemoveConsumer(&form_manager)); | 3117 EXPECT_CALL(old_fetcher, RemoveConsumer(form_manager.get())); |
3114 form_manager.GrabFetcher(std::move(new_fetcher)); | 3118 form_manager->GrabFetcher(std::move(new_fetcher)); |
3115 } | 3119 } |
3116 | 3120 |
3117 TEST_F(PasswordFormManagerTest, UploadSignInForm_WithAutofillTypes) { | 3121 TEST_F(PasswordFormManagerTest, UploadSignInForm_WithAutofillTypes) { |
3118 // For newly saved passwords on a sign-in form, upload an autofill vote for a | 3122 // For newly saved passwords on a sign-in form, upload an autofill vote for a |
3119 // username field and a autofill::PASSWORD vote for a password field. | 3123 // username field and a autofill::PASSWORD vote for a password field. |
3120 autofill::FormFieldData field; | 3124 autofill::FormFieldData field; |
3121 field.name = ASCIIToUTF16("Email"); | 3125 field.name = ASCIIToUTF16("Email"); |
3122 field.form_control_type = "text"; | 3126 field.form_control_type = "text"; |
3123 observed_form()->form_data.fields.push_back(field); | 3127 observed_form()->form_data.fields.push_back(field); |
3124 | 3128 |
3125 field.name = ASCIIToUTF16("Passwd"); | 3129 field.name = ASCIIToUTF16("Passwd"); |
3126 field.form_control_type = "password"; | 3130 field.form_control_type = "password"; |
3127 observed_form()->form_data.fields.push_back(field); | 3131 observed_form()->form_data.fields.push_back(field); |
3128 | 3132 |
3129 FakeFormFetcher fetcher; | 3133 FakeFormFetcher fetcher; |
3130 fetcher.Fetch(); | 3134 fetcher.Fetch(); |
3131 PasswordFormManager form_manager( | 3135 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
3132 password_manager(), client(), client()->driver(), *observed_form(), | 3136 password_manager(), client(), client()->driver(), *observed_form(), |
3133 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 3137 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
3134 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 3138 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
3135 | 3139 |
3136 PasswordForm form_to_save(*observed_form()); | 3140 PasswordForm form_to_save(*observed_form()); |
3137 form_to_save.preferred = true; | 3141 form_to_save.preferred = true; |
3138 form_to_save.username_value = ASCIIToUTF16("test@gmail.com"); | 3142 form_to_save.username_value = ASCIIToUTF16("test@gmail.com"); |
3139 form_to_save.password_value = ASCIIToUTF16("password"); | 3143 form_to_save.password_value = ASCIIToUTF16("password"); |
3140 | 3144 |
3141 std::unique_ptr<FormStructure> uploaded_form_structure; | 3145 std::unique_ptr<FormStructure> uploaded_form_structure; |
3142 auto* mock_autofill_manager = | 3146 auto* mock_autofill_manager = |
3143 client()->mock_driver()->mock_autofill_manager(); | 3147 client()->mock_driver()->mock_autofill_manager(); |
3144 EXPECT_CALL(*mock_autofill_manager, StartUploadProcessPtr(_, _, true)) | 3148 EXPECT_CALL(*mock_autofill_manager, StartUploadProcessPtr(_, _, true)) |
3145 .WillOnce(WithArg<0>(SaveToUniquePtr(&uploaded_form_structure))); | 3149 .WillOnce(WithArg<0>(SaveToUniquePtr(&uploaded_form_structure))); |
3146 form_manager.ProvisionallySave( | 3150 form_manager->ProvisionallySave( |
3147 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 3151 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
3148 form_manager.Save(); | 3152 form_manager->Save(); |
3149 | 3153 |
3150 ASSERT_EQ(2u, uploaded_form_structure->field_count()); | 3154 ASSERT_EQ(2u, uploaded_form_structure->field_count()); |
3151 autofill::ServerFieldTypeSet expected_types = {autofill::PASSWORD}; | 3155 autofill::ServerFieldTypeSet expected_types = {autofill::PASSWORD}; |
3152 EXPECT_EQ(form_to_save.username_value, | 3156 EXPECT_EQ(form_to_save.username_value, |
3153 uploaded_form_structure->field(0)->value); | 3157 uploaded_form_structure->field(0)->value); |
3154 EXPECT_EQ(expected_types, | 3158 EXPECT_EQ(expected_types, |
3155 uploaded_form_structure->field(1)->possible_types()); | 3159 uploaded_form_structure->field(1)->possible_types()); |
3156 } | 3160 } |
3157 | 3161 |
3158 // Checks that there is no upload on saving a password on a password form only | 3162 // Checks that there is no upload on saving a password on a password form only |
3159 // with 1 field. | 3163 // with 1 field. |
3160 TEST_F(PasswordFormManagerTest, NoUploadsForSubmittedFormWithOnlyOneField) { | 3164 TEST_F(PasswordFormManagerTest, NoUploadsForSubmittedFormWithOnlyOneField) { |
3161 autofill::FormFieldData field; | 3165 autofill::FormFieldData field; |
3162 field.name = ASCIIToUTF16("Passwd"); | 3166 field.name = ASCIIToUTF16("Passwd"); |
3163 field.form_control_type = "password"; | 3167 field.form_control_type = "password"; |
3164 observed_form()->form_data.fields.push_back(field); | 3168 observed_form()->form_data.fields.push_back(field); |
3165 | 3169 |
3166 FakeFormFetcher fetcher; | 3170 FakeFormFetcher fetcher; |
3167 fetcher.Fetch(); | 3171 fetcher.Fetch(); |
3168 PasswordFormManager form_manager( | 3172 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
3169 password_manager(), client(), client()->driver(), *observed_form(), | 3173 password_manager(), client(), client()->driver(), *observed_form(), |
3170 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 3174 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
3171 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 3175 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
3172 | 3176 |
3173 PasswordForm form_to_save(*observed_form()); | 3177 PasswordForm form_to_save(*observed_form()); |
3174 form_to_save.preferred = true; | 3178 form_to_save.preferred = true; |
3175 form_to_save.password_value = ASCIIToUTF16("password"); | 3179 form_to_save.password_value = ASCIIToUTF16("password"); |
3176 | 3180 |
3177 auto* mock_autofill_manager = | 3181 auto* mock_autofill_manager = |
3178 client()->mock_driver()->mock_autofill_manager(); | 3182 client()->mock_driver()->mock_autofill_manager(); |
3179 EXPECT_CALL(*mock_autofill_manager, StartUploadProcessPtr(_, _, _)).Times(0); | 3183 EXPECT_CALL(*mock_autofill_manager, StartUploadProcessPtr(_, _, _)).Times(0); |
3180 form_manager.ProvisionallySave( | 3184 form_manager->ProvisionallySave( |
3181 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 3185 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
3182 form_manager.Save(); | 3186 form_manager->Save(); |
3183 } | 3187 } |
3184 | 3188 |
3185 // If the frame containing the login form is served over HTTPS, no histograms | 3189 // If the frame containing the login form is served over HTTPS, no histograms |
3186 // should be recorded. | 3190 // should be recorded. |
3187 TEST_F(PasswordFormManagerTest, | 3191 TEST_F(PasswordFormManagerTest, |
3188 SuppressedHTTPSFormsHistogram_NotRecordedOnHTTPSLoginForms) { | 3192 SuppressedHTTPSFormsHistogram_NotRecordedOnHTTPSLoginForms) { |
3189 base::HistogramTester histogram_tester; | 3193 base::HistogramTester histogram_tester; |
3190 | 3194 |
3191 PasswordForm https_observed_form = *observed_form(); | 3195 PasswordForm https_observed_form = *observed_form(); |
3192 https_observed_form.origin = GURL("https://accounts.google.com/a/LoginAuth"); | 3196 https_observed_form.origin = GURL("https://accounts.google.com/a/LoginAuth"); |
3193 https_observed_form.signon_realm = "https://accounts.google.com/"; | 3197 https_observed_form.signon_realm = "https://accounts.google.com/"; |
3194 | 3198 |
3195 // Only the scheme of the frame containing the login form maters, not the | 3199 // Only the scheme of the frame containing the login form maters, not the |
3196 // scheme of the main frame. | 3200 // scheme of the main frame. |
3197 ASSERT_FALSE(client()->IsMainFrameSecure()); | 3201 ASSERT_FALSE(client()->IsMainFrameSecure()); |
3198 | 3202 |
3199 // Even if there are suppressed results, they are ignored (but there should be | 3203 // Even if there are suppressed results, they are ignored (but there should be |
3200 // none in production in this case, though). | 3204 // none in production in this case, though). |
3201 FakeFormFetcher fetcher; | 3205 FakeFormFetcher fetcher; |
3202 fetcher.set_suppressed_https_forms({saved_match()}); | 3206 fetcher.set_suppressed_https_forms({saved_match()}); |
3203 fetcher.set_did_complete_querying_suppressed_https_forms(true); | 3207 fetcher.set_did_complete_querying_suppressed_https_forms(true); |
3204 fetcher.Fetch(); | 3208 fetcher.Fetch(); |
3205 | 3209 |
3206 std::unique_ptr<PasswordFormManager> form_manager = | 3210 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
3207 base::MakeUnique<PasswordFormManager>( | 3211 password_manager(), client(), client()->driver(), https_observed_form, |
3208 password_manager(), client(), client()->driver(), https_observed_form, | 3212 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
3209 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | |
3210 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 3213 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
3211 form_manager.reset(); | 3214 form_manager = nullptr; |
3212 | 3215 |
3213 histogram_tester.ExpectTotalCount( | 3216 histogram_tester.ExpectTotalCount( |
3214 "PasswordManager.QueryingSuppressedAccountsFinished", 0); | 3217 "PasswordManager.QueryingSuppressedAccountsFinished", 0); |
3215 const auto sample_counts = histogram_tester.GetTotalCountsForPrefix( | 3218 const auto sample_counts = histogram_tester.GetTotalCountsForPrefix( |
3216 "PasswordManager.SuppressedAccount."); | 3219 "PasswordManager.SuppressedAccount."); |
3217 EXPECT_THAT(sample_counts, IsEmpty()); | 3220 EXPECT_THAT(sample_counts, IsEmpty()); |
3218 } | 3221 } |
3219 | 3222 |
3220 TEST_F(PasswordFormManagerTest, | 3223 TEST_F(PasswordFormManagerTest, |
3221 SuppressedHTTPSFormsHistogram_NotRecordedIfStoreWasTooSlow) { | 3224 SuppressedHTTPSFormsHistogram_NotRecordedIfStoreWasTooSlow) { |
3222 base::HistogramTester histogram_tester; | 3225 base::HistogramTester histogram_tester; |
3223 | 3226 |
3224 fake_form_fetcher()->set_did_complete_querying_suppressed_https_forms(false); | 3227 fake_form_fetcher()->set_did_complete_querying_suppressed_https_forms(false); |
3225 fake_form_fetcher()->Fetch(); | 3228 fake_form_fetcher()->Fetch(); |
3226 std::unique_ptr<PasswordFormManager> form_manager = | 3229 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
3227 base::MakeUnique<PasswordFormManager>( | 3230 password_manager(), client(), client()->driver(), *observed_form(), |
3228 password_manager(), client(), client()->driver(), *observed_form(), | 3231 base::MakeUnique<NiceMock<MockFormSaver>>(), fake_form_fetcher())); |
3229 base::MakeUnique<NiceMock<MockFormSaver>>(), fake_form_fetcher()); | |
3230 fake_form_fetcher()->SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 3232 fake_form_fetcher()->SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
3231 form_manager.reset(); | 3233 form_manager = nullptr; |
3232 | 3234 |
3233 histogram_tester.ExpectUniqueSample( | 3235 histogram_tester.ExpectUniqueSample( |
3234 "PasswordManager.QueryingSuppressedAccountsFinished", false, 1); | 3236 "PasswordManager.QueryingSuppressedAccountsFinished", false, 1); |
3235 const auto sample_counts = histogram_tester.GetTotalCountsForPrefix( | 3237 const auto sample_counts = histogram_tester.GetTotalCountsForPrefix( |
3236 "PasswordManager.SuppressedAccount."); | 3238 "PasswordManager.SuppressedAccount."); |
3237 EXPECT_THAT(sample_counts, IsEmpty()); | 3239 EXPECT_THAT(sample_counts, IsEmpty()); |
3238 } | 3240 } |
3239 | 3241 |
3240 TEST_F(PasswordFormManagerTest, | 3242 TEST_F(PasswordFormManagerTest, |
3241 SuppressedHTTPSFormsHistogram_RecordedForHTTPPages) { | 3243 SuppressedHTTPSFormsHistogram_RecordedForHTTPPages) { |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3357 SCOPED_TRACE(test_case.expected_histogram_sample_generated); | 3359 SCOPED_TRACE(test_case.expected_histogram_sample_generated); |
3358 | 3360 |
3359 base::HistogramTester histogram_tester; | 3361 base::HistogramTester histogram_tester; |
3360 | 3362 |
3361 const base::string16 filled_username = | 3363 const base::string16 filled_username = |
3362 ASCIIToUTF16(test_case.filled_username); | 3364 ASCIIToUTF16(test_case.filled_username); |
3363 const base::string16 filled_password = | 3365 const base::string16 filled_password = |
3364 ASCIIToUTF16(test_case.filled_password); | 3366 ASCIIToUTF16(test_case.filled_password); |
3365 | 3367 |
3366 FakeFormFetcher fetcher; | 3368 FakeFormFetcher fetcher; |
3367 std::unique_ptr<PasswordFormManager> form_manager = | 3369 scoped_refptr<PasswordFormManager> form_manager(new PasswordFormManager( |
3368 base::MakeUnique<PasswordFormManager>( | 3370 password_manager(), client(), client()->driver(), *observed_form(), |
3369 password_manager(), client(), client()->driver(), *observed_form(), | 3371 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
3370 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | |
3371 | 3372 |
3372 PasswordForm http_stored_form = *saved_match(); | 3373 PasswordForm http_stored_form = *saved_match(); |
3373 http_stored_form.username_value = filled_username; | 3374 http_stored_form.username_value = filled_username; |
3374 http_stored_form.password_value = filled_password; | 3375 http_stored_form.password_value = filled_password; |
3375 if (test_case.simulate_manager_action == ManagerAction::OFFERED_PSL) | 3376 if (test_case.simulate_manager_action == ManagerAction::OFFERED_PSL) |
3376 http_stored_form.is_public_suffix_match = true; | 3377 http_stored_form.is_public_suffix_match = true; |
3377 | 3378 |
3378 std::vector<const PasswordForm*> matches; | 3379 std::vector<const PasswordForm*> matches; |
3379 if (test_case.simulate_manager_action != ManagerAction::NONE) | 3380 if (test_case.simulate_manager_action != ManagerAction::NONE) |
3380 matches.push_back(&http_stored_form); | 3381 matches.push_back(&http_stored_form); |
(...skipping 24 matching lines...) Expand all Loading... | |
3405 form_manager->ProvisionallySave( | 3406 form_manager->ProvisionallySave( |
3406 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 3407 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
3407 if (test_case.simulate_submit_result == SubmitResult::PASSED) { | 3408 if (test_case.simulate_submit_result == SubmitResult::PASSED) { |
3408 form_manager->LogSubmitPassed(); | 3409 form_manager->LogSubmitPassed(); |
3409 form_manager->Save(); | 3410 form_manager->Save(); |
3410 } else { | 3411 } else { |
3411 form_manager->LogSubmitFailed(); | 3412 form_manager->LogSubmitFailed(); |
3412 } | 3413 } |
3413 } | 3414 } |
3414 | 3415 |
3415 form_manager.reset(); | 3416 form_manager = nullptr; |
3416 | 3417 |
3417 histogram_tester.ExpectUniqueSample( | 3418 histogram_tester.ExpectUniqueSample( |
3418 "PasswordManager.QueryingSuppressedAccountsFinished", true, 1); | 3419 "PasswordManager.QueryingSuppressedAccountsFinished", true, 1); |
3419 | 3420 |
3420 EXPECT_THAT(histogram_tester.GetAllSamples( | 3421 EXPECT_THAT(histogram_tester.GetAllSamples( |
3421 "PasswordManager.SuppressedAccount.Generated.HTTPSNotHTTP"), | 3422 "PasswordManager.SuppressedAccount.Generated.HTTPSNotHTTP"), |
3422 ::testing::ElementsAre(base::Bucket( | 3423 ::testing::ElementsAre(base::Bucket( |
3423 test_case.expected_histogram_sample_generated, 1))); | 3424 test_case.expected_histogram_sample_generated, 1))); |
3424 EXPECT_THAT(histogram_tester.GetAllSamples( | 3425 EXPECT_THAT(histogram_tester.GetAllSamples( |
3425 "PasswordManager.SuppressedAccount.Manual.HTTPSNotHTTP"), | 3426 "PasswordManager.SuppressedAccount.Manual.HTTPSNotHTTP"), |
3426 ::testing::ElementsAre(base::Bucket( | 3427 ::testing::ElementsAre(base::Bucket( |
3427 test_case.expected_histogram_sample_manual, 1))); | 3428 test_case.expected_histogram_sample_manual, 1))); |
3428 } | 3429 } |
3429 } | 3430 } |
3430 | 3431 |
3431 } // namespace password_manager | 3432 } // namespace password_manager |
OLD | NEW |