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( |
410 password_manager(), client(), client()->driver(), form, | 410 base::MakeRefCounted<PasswordFormManager>( |
411 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 411 password_manager(), client(), client()->driver(), form, |
| 412 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
412 PasswordForm match = CreateSavedMatch(false); | 413 PasswordForm match = CreateSavedMatch(false); |
413 match.generation_upload_status = status; | 414 match.generation_upload_status = status; |
414 match.times_used = times_used; | 415 match.times_used = times_used; |
415 | 416 |
416 PasswordForm form_to_save(form); | 417 PasswordForm form_to_save(form); |
417 form_to_save.preferred = true; | 418 form_to_save.preferred = true; |
418 form_to_save.username_element = ASCIIToUTF16("observed-username-field"); | 419 form_to_save.username_element = ASCIIToUTF16("observed-username-field"); |
419 form_to_save.username_value = match.username_value; | 420 form_to_save.username_value = match.username_value; |
420 form_to_save.password_value = match.password_value; | 421 form_to_save.password_value = match.password_value; |
421 | 422 |
422 fetcher.SetNonFederated({&match}, 0u); | 423 fetcher.SetNonFederated({&match}, 0u); |
423 std::string expected_login_signature; | 424 std::string expected_login_signature; |
424 autofill::FormStructure observed_structure(observed_form_data); | 425 autofill::FormStructure observed_structure(observed_form_data); |
425 autofill::FormStructure pending_structure(saved_match()->form_data); | 426 autofill::FormStructure pending_structure(saved_match()->form_data); |
426 if (observed_structure.FormSignatureAsStr() != | 427 if (observed_structure.FormSignatureAsStr() != |
427 pending_structure.FormSignatureAsStr() && | 428 pending_structure.FormSignatureAsStr() && |
428 times_used == 0) { | 429 times_used == 0) { |
429 expected_login_signature = observed_structure.FormSignatureAsStr(); | 430 expected_login_signature = observed_structure.FormSignatureAsStr(); |
430 } | 431 } |
431 autofill::ServerFieldTypeSet expected_available_field_types; | 432 autofill::ServerFieldTypeSet expected_available_field_types; |
432 FieldTypeMap expected_types; | 433 FieldTypeMap expected_types; |
433 expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE; | 434 expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE; |
434 expected_types[match.username_element] = autofill::UNKNOWN_TYPE; | 435 expected_types[match.username_element] = autofill::UNKNOWN_TYPE; |
435 | 436 |
436 bool expect_generation_vote = false; | 437 bool expect_generation_vote = false; |
437 if (field_type) { | 438 if (field_type) { |
438 // Show the password generation popup to check that the generation vote | 439 // Show the password generation popup to check that the generation vote |
439 // would be ignored. | 440 // would be ignored. |
440 form_manager.set_generation_element(saved_match()->password_element); | 441 form_manager->set_generation_element(saved_match()->password_element); |
441 form_manager.set_generation_popup_was_shown(true); | 442 form_manager->set_generation_popup_was_shown(true); |
442 expect_generation_vote = | 443 expect_generation_vote = |
443 *field_type != autofill::ACCOUNT_CREATION_PASSWORD; | 444 *field_type != autofill::ACCOUNT_CREATION_PASSWORD; |
444 | 445 |
445 expected_available_field_types.insert(*field_type); | 446 expected_available_field_types.insert(*field_type); |
446 expected_types[saved_match()->password_element] = *field_type; | 447 expected_types[saved_match()->password_element] = *field_type; |
447 } | 448 } |
448 | 449 |
449 if (field_type) { | 450 if (field_type) { |
450 EXPECT_CALL( | 451 EXPECT_CALL( |
451 *client()->mock_driver()->mock_autofill_download_manager(), | 452 *client()->mock_driver()->mock_autofill_download_manager(), |
452 StartUploadRequest(CheckUploadedAutofillTypesAndSignature( | 453 StartUploadRequest(CheckUploadedAutofillTypesAndSignature( |
453 pending_structure.FormSignatureAsStr(), | 454 pending_structure.FormSignatureAsStr(), |
454 expected_types, expect_generation_vote), | 455 expected_types, expect_generation_vote), |
455 false, expected_available_field_types, | 456 false, expected_available_field_types, |
456 expected_login_signature, true)); | 457 expected_login_signature, true)); |
457 } else { | 458 } else { |
458 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 459 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
459 StartUploadRequest(_, _, _, _, _)) | 460 StartUploadRequest(_, _, _, _, _)) |
460 .Times(0); | 461 .Times(0); |
461 } | 462 } |
462 form_manager.ProvisionallySave( | 463 form_manager->ProvisionallySave( |
463 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 464 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
464 form_manager.Save(); | 465 form_manager->Save(); |
465 Mock::VerifyAndClearExpectations( | 466 Mock::VerifyAndClearExpectations( |
466 client()->mock_driver()->mock_autofill_download_manager()); | 467 client()->mock_driver()->mock_autofill_download_manager()); |
467 } | 468 } |
468 | 469 |
469 // Test upload votes on change password forms. |field_type| is a vote that we | 470 // Test upload votes on change password forms. |field_type| is a vote that we |
470 // expect to be uploaded. | 471 // expect to be uploaded. |
471 void ChangePasswordUploadTest(autofill::ServerFieldType field_type, | 472 void ChangePasswordUploadTest(autofill::ServerFieldType field_type, |
472 bool has_confirmation_field) { | 473 bool has_confirmation_field) { |
473 SCOPED_TRACE(testing::Message() | 474 SCOPED_TRACE(testing::Message() |
474 << "field_type=" << field_type | 475 << "field_type=" << field_type |
(...skipping 13 matching lines...) Expand all Loading... |
488 observed_form()->form_data.fields.push_back(empty_field); | 489 observed_form()->form_data.fields.push_back(empty_field); |
489 if (has_confirmation_field) { | 490 if (has_confirmation_field) { |
490 field.label = ASCIIToUTF16("ConfPwd"); | 491 field.label = ASCIIToUTF16("ConfPwd"); |
491 field.name = ASCIIToUTF16("ConfPwd"); | 492 field.name = ASCIIToUTF16("ConfPwd"); |
492 field.form_control_type = "password"; | 493 field.form_control_type = "password"; |
493 observed_form()->form_data.fields.push_back(field); | 494 observed_form()->form_data.fields.push_back(field); |
494 } | 495 } |
495 | 496 |
496 FakeFormFetcher fetcher; | 497 FakeFormFetcher fetcher; |
497 fetcher.Fetch(); | 498 fetcher.Fetch(); |
498 PasswordFormManager form_manager( | 499 scoped_refptr<PasswordFormManager> form_manager( |
499 password_manager(), client(), client()->driver(), *observed_form(), | 500 base::MakeRefCounted<PasswordFormManager>( |
500 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 501 password_manager(), client(), client()->driver(), *observed_form(), |
| 502 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
501 fetcher.SetNonFederated({saved_match()}, 0u); | 503 fetcher.SetNonFederated({saved_match()}, 0u); |
502 | 504 |
503 // User submits current and new credentials to the observed form. | 505 // User submits current and new credentials to the observed form. |
504 PasswordForm submitted_form(*observed_form()); | 506 PasswordForm submitted_form(*observed_form()); |
505 // credentials.username_element.clear(); | 507 // credentials.username_element.clear(); |
506 submitted_form.username_value = saved_match()->username_value; | 508 submitted_form.username_value = saved_match()->username_value; |
507 submitted_form.password_value = saved_match()->password_value; | 509 submitted_form.password_value = saved_match()->password_value; |
508 submitted_form.new_password_value = ASCIIToUTF16("test2"); | 510 submitted_form.new_password_value = ASCIIToUTF16("test2"); |
509 submitted_form.preferred = true; | 511 submitted_form.preferred = true; |
510 form_manager.ProvisionallySave( | 512 form_manager->ProvisionallySave( |
511 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 513 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
512 | 514 |
513 // Successful login. The PasswordManager would instruct PasswordFormManager | 515 // Successful login. The PasswordManager would instruct PasswordFormManager |
514 // to update. | 516 // to update. |
515 EXPECT_FALSE(form_manager.IsNewLogin()); | 517 EXPECT_FALSE(form_manager->IsNewLogin()); |
516 EXPECT_FALSE( | 518 EXPECT_FALSE( |
517 form_manager.is_possible_change_password_form_without_username()); | 519 form_manager->is_possible_change_password_form_without_username()); |
518 | 520 |
519 // By now, the PasswordFormManager should have promoted the new password | 521 // By now, the PasswordFormManager should have promoted the new password |
520 // value already to be the current password, and should no longer maintain | 522 // value already to be the current password, and should no longer maintain |
521 // any info about the new password value. | 523 // any info about the new password value. |
522 EXPECT_EQ(submitted_form.new_password_value, | 524 EXPECT_EQ(submitted_form.new_password_value, |
523 form_manager.pending_credentials().password_value); | 525 form_manager->pending_credentials().password_value); |
524 EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty()); | 526 EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty()); |
525 | 527 |
526 std::map<base::string16, autofill::ServerFieldType> expected_types; | 528 std::map<base::string16, autofill::ServerFieldType> expected_types; |
527 expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE; | 529 expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE; |
528 expected_types[observed_form_.username_element] = autofill::UNKNOWN_TYPE; | 530 expected_types[observed_form_.username_element] = autofill::UNKNOWN_TYPE; |
529 expected_types[observed_form_.password_element] = autofill::PASSWORD; | 531 expected_types[observed_form_.password_element] = autofill::PASSWORD; |
530 expected_types[observed_form_.new_password_element] = field_type; | 532 expected_types[observed_form_.new_password_element] = field_type; |
531 expected_types[base::string16()] = autofill::UNKNOWN_TYPE; | 533 expected_types[base::string16()] = autofill::UNKNOWN_TYPE; |
532 | 534 |
533 autofill::ServerFieldTypeSet expected_available_field_types; | 535 autofill::ServerFieldTypeSet expected_available_field_types; |
534 expected_available_field_types.insert(autofill::PASSWORD); | 536 expected_available_field_types.insert(autofill::PASSWORD); |
(...skipping 15 matching lines...) Expand all Loading... |
550 } | 552 } |
551 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 553 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
552 StartUploadRequest(CheckUploadedAutofillTypesAndSignature( | 554 StartUploadRequest(CheckUploadedAutofillTypesAndSignature( |
553 observed_form_signature, expected_types, | 555 observed_form_signature, expected_types, |
554 false /* expect_generation_vote */), | 556 false /* expect_generation_vote */), |
555 false, expected_available_field_types, | 557 false, expected_available_field_types, |
556 expected_login_signature, true)); | 558 expected_login_signature, true)); |
557 | 559 |
558 switch (field_type) { | 560 switch (field_type) { |
559 case autofill::NEW_PASSWORD: | 561 case autofill::NEW_PASSWORD: |
560 form_manager.Update(*saved_match()); | 562 form_manager->Update(*saved_match()); |
561 break; | 563 break; |
562 case autofill::PROBABLY_NEW_PASSWORD: | 564 case autofill::PROBABLY_NEW_PASSWORD: |
563 form_manager.OnNoInteraction(true /* it is an update */); | 565 form_manager->OnNoInteraction(true /* it is an update */); |
564 break; | 566 break; |
565 case autofill::NOT_NEW_PASSWORD: | 567 case autofill::NOT_NEW_PASSWORD: |
566 form_manager.OnNopeUpdateClicked(); | 568 form_manager->OnNopeUpdateClicked(); |
567 break; | 569 break; |
568 default: | 570 default: |
569 NOTREACHED(); | 571 NOTREACHED(); |
570 } | 572 } |
571 Mock::VerifyAndClearExpectations( | 573 Mock::VerifyAndClearExpectations( |
572 client()->mock_driver()->mock_autofill_download_manager()); | 574 client()->mock_driver()->mock_autofill_download_manager()); |
573 } | 575 } |
574 | 576 |
575 autofill::AutofillUploadContents::Field::PasswordGenerationType | 577 autofill::AutofillUploadContents::Field::PasswordGenerationType |
576 GetExpectedPasswordGenerationType(bool is_manual_generation, | 578 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; | 633 submitted_form.username_value = saved_match()->username_value; |
632 submitted_form.password_value = saved_match()->password_value; | 634 submitted_form.password_value = saved_match()->password_value; |
633 | 635 |
634 if (is_change_password_form) { | 636 if (is_change_password_form) { |
635 submitted_form.new_password_value = | 637 submitted_form.new_password_value = |
636 saved_match()->password_value + ASCIIToUTF16("1"); | 638 saved_match()->password_value + ASCIIToUTF16("1"); |
637 } | 639 } |
638 | 640 |
639 FakeFormFetcher fetcher; | 641 FakeFormFetcher fetcher; |
640 fetcher.Fetch(); | 642 fetcher.Fetch(); |
641 PasswordFormManager form_manager( | 643 scoped_refptr<PasswordFormManager> form_manager( |
642 password_manager(), client(), client()->driver(), form, | 644 base::MakeRefCounted<PasswordFormManager>( |
643 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 645 password_manager(), client(), client()->driver(), form, |
| 646 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
644 | 647 |
645 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 648 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
646 | 649 |
647 autofill::ServerFieldTypeSet expected_available_field_types; | 650 autofill::ServerFieldTypeSet expected_available_field_types; |
648 // Don't send autofill votes if the user didn't press "Save" button. | 651 // Don't send autofill votes if the user didn't press "Save" button. |
649 if (interaction == SAVE) | 652 if (interaction == SAVE) |
650 expected_available_field_types.insert(autofill::PASSWORD); | 653 expected_available_field_types.insert(autofill::PASSWORD); |
651 | 654 |
652 form_manager.set_is_manual_generation(is_manual_generation); | 655 form_manager->set_is_manual_generation(is_manual_generation); |
653 base::string16 generation_element = is_change_password_form | 656 base::string16 generation_element = is_change_password_form |
654 ? form.new_password_element | 657 ? form.new_password_element |
655 : form.password_element; | 658 : form.password_element; |
656 form_manager.set_generation_element(generation_element); | 659 form_manager->set_generation_element(generation_element); |
657 form_manager.set_generation_popup_was_shown(true); | 660 form_manager->set_generation_popup_was_shown(true); |
658 form_manager.set_has_generated_password(has_generated_password); | 661 form_manager->set_has_generated_password(has_generated_password); |
659 | 662 |
660 // Figure out expected generation event type. | 663 // Figure out expected generation event type. |
661 autofill::AutofillUploadContents::Field::PasswordGenerationType | 664 autofill::AutofillUploadContents::Field::PasswordGenerationType |
662 expected_generation_type = GetExpectedPasswordGenerationType( | 665 expected_generation_type = GetExpectedPasswordGenerationType( |
663 is_manual_generation, is_change_password_form, | 666 is_manual_generation, is_change_password_form, |
664 has_generated_password); | 667 has_generated_password); |
665 std::map<base::string16, | 668 std::map<base::string16, |
666 autofill::AutofillUploadContents::Field::PasswordGenerationType> | 669 autofill::AutofillUploadContents::Field::PasswordGenerationType> |
667 expected_generation_types; | 670 expected_generation_types; |
668 expected_generation_types[generation_element] = expected_generation_type; | 671 expected_generation_types[generation_element] = expected_generation_type; |
669 | 672 |
670 autofill::FormStructure form_structure(submitted_form.form_data); | 673 autofill::FormStructure form_structure(submitted_form.form_data); |
671 | 674 |
672 EXPECT_CALL( | 675 EXPECT_CALL( |
673 *client()->mock_driver()->mock_autofill_download_manager(), | 676 *client()->mock_driver()->mock_autofill_download_manager(), |
674 StartUploadRequest( | 677 StartUploadRequest( |
675 CheckUploadedGenerationTypesAndSignature( | 678 CheckUploadedGenerationTypesAndSignature( |
676 form_structure.FormSignatureAsStr(), expected_generation_types), | 679 form_structure.FormSignatureAsStr(), expected_generation_types), |
677 false, expected_available_field_types, std::string(), true)); | 680 false, expected_available_field_types, std::string(), true)); |
678 | 681 |
679 form_manager.ProvisionallySave( | 682 form_manager->ProvisionallySave( |
680 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 683 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
681 switch (interaction) { | 684 switch (interaction) { |
682 case SAVE: | 685 case SAVE: |
683 form_manager.Save(); | 686 form_manager->Save(); |
684 break; | 687 break; |
685 case NEVER: | 688 case NEVER: |
686 form_manager.OnNeverClicked(); | 689 form_manager->OnNeverClicked(); |
687 break; | 690 break; |
688 case NO_INTERACTION: | 691 case NO_INTERACTION: |
689 form_manager.OnNoInteraction(false /* not an update prompt*/); | 692 form_manager->OnNoInteraction(false /* not an update prompt*/); |
690 break; | 693 break; |
691 } | 694 } |
692 Mock::VerifyAndClearExpectations( | 695 Mock::VerifyAndClearExpectations( |
693 client()->mock_driver()->mock_autofill_download_manager()); | 696 client()->mock_driver()->mock_autofill_download_manager()); |
694 } | 697 } |
695 | 698 |
696 PasswordForm* observed_form() { return &observed_form_; } | 699 PasswordForm* observed_form() { return &observed_form_; } |
697 PasswordForm* saved_match() { return &saved_match_; } | 700 PasswordForm* saved_match() { return &saved_match_; } |
698 PasswordForm* psl_saved_match() { return &psl_saved_match_; } | 701 PasswordForm* psl_saved_match() { return &psl_saved_match_; } |
699 PasswordForm CreateSavedMatch(bool blacklisted) { | 702 PasswordForm CreateSavedMatch(bool blacklisted) { |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
743 return form; | 746 return form; |
744 } | 747 } |
745 | 748 |
746 void SimulateActionsOnHTTPObservedForm( | 749 void SimulateActionsOnHTTPObservedForm( |
747 FakeFormFetcher* fetcher, | 750 FakeFormFetcher* fetcher, |
748 SimulatedManagerAction manager_action, | 751 SimulatedManagerAction manager_action, |
749 SimulatedSubmitResult submit_result, | 752 SimulatedSubmitResult submit_result, |
750 const char* filled_username, | 753 const char* filled_username, |
751 const char* filled_password, | 754 const char* filled_password, |
752 const char* submitted_password = nullptr) { | 755 const char* submitted_password = nullptr) { |
753 PasswordFormManager form_manager( | 756 scoped_refptr<PasswordFormManager> form_manager( |
754 password_manager(), client(), client()->driver(), *observed_form(), | 757 base::MakeRefCounted<PasswordFormManager>( |
755 base::MakeUnique<NiceMock<MockFormSaver>>(), fetcher); | 758 password_manager(), client(), client()->driver(), *observed_form(), |
| 759 base::MakeUnique<NiceMock<MockFormSaver>>(), fetcher)); |
756 | 760 |
757 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 761 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
758 StartUploadRequest(_, _, _, _, _)) | 762 StartUploadRequest(_, _, _, _, _)) |
759 .Times(::testing::AnyNumber()); | 763 .Times(::testing::AnyNumber()); |
760 | 764 |
761 PasswordForm http_stored_form = *saved_match(); | 765 PasswordForm http_stored_form = *saved_match(); |
762 http_stored_form.username_value = base::ASCIIToUTF16(filled_username); | 766 http_stored_form.username_value = base::ASCIIToUTF16(filled_username); |
763 http_stored_form.password_value = base::ASCIIToUTF16(filled_password); | 767 http_stored_form.password_value = base::ASCIIToUTF16(filled_password); |
764 if (manager_action == SimulatedManagerAction::OFFERED_PSL) | 768 if (manager_action == SimulatedManagerAction::OFFERED_PSL) |
765 http_stored_form.is_public_suffix_match = true; | 769 http_stored_form.is_public_suffix_match = true; |
(...skipping 15 matching lines...) Expand all Loading... |
781 fetcher->SetNonFederated(matches, 0u); | 785 fetcher->SetNonFederated(matches, 0u); |
782 | 786 |
783 if (submit_result != SimulatedSubmitResult::NONE) { | 787 if (submit_result != SimulatedSubmitResult::NONE) { |
784 PasswordForm submitted_form(*observed_form()); | 788 PasswordForm submitted_form(*observed_form()); |
785 submitted_form.preferred = true; | 789 submitted_form.preferred = true; |
786 submitted_form.username_value = base::ASCIIToUTF16(filled_username); | 790 submitted_form.username_value = base::ASCIIToUTF16(filled_username); |
787 submitted_form.password_value = | 791 submitted_form.password_value = |
788 submitted_password ? base::ASCIIToUTF16(submitted_password) | 792 submitted_password ? base::ASCIIToUTF16(submitted_password) |
789 : base::ASCIIToUTF16(filled_password); | 793 : base::ASCIIToUTF16(filled_password); |
790 | 794 |
791 form_manager.ProvisionallySave( | 795 form_manager->ProvisionallySave( |
792 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 796 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
793 if (submit_result == SimulatedSubmitResult::PASSED) { | 797 if (submit_result == SimulatedSubmitResult::PASSED) { |
794 form_manager.LogSubmitPassed(); | 798 form_manager->LogSubmitPassed(); |
795 form_manager.Save(); | 799 form_manager->Save(); |
796 } else { | 800 } else { |
797 form_manager.LogSubmitFailed(); | 801 form_manager->LogSubmitFailed(); |
798 } | 802 } |
799 } | 803 } |
800 } | 804 } |
801 | 805 |
802 private: | 806 private: |
803 // Necessary for callbacks, and for TestAutofillDriver. | 807 // Necessary for callbacks, and for TestAutofillDriver. |
804 base::MessageLoop message_loop_; | 808 base::MessageLoop message_loop_; |
805 | 809 |
806 PasswordForm observed_form_; | 810 PasswordForm observed_form_; |
807 PasswordForm saved_match_; | 811 PasswordForm saved_match_; |
808 PasswordForm psl_saved_match_; | 812 PasswordForm psl_saved_match_; |
809 TestPasswordManagerClient client_; | 813 TestPasswordManagerClient client_; |
810 std::unique_ptr<PasswordManager> password_manager_; | 814 std::unique_ptr<PasswordManager> password_manager_; |
811 // Define |fake_form_fetcher_| before |form_manager_|, because the former | 815 // Define |fake_form_fetcher_| before |form_manager_|, because the former |
812 // needs to outlive the latter. | 816 // needs to outlive the latter. |
813 FakeFormFetcher fake_form_fetcher_; | 817 FakeFormFetcher fake_form_fetcher_; |
814 std::unique_ptr<PasswordFormManager> form_manager_; | 818 scoped_refptr<PasswordFormManager> form_manager_; |
815 }; | 819 }; |
816 | 820 |
817 class PasswordFormManagerFillOnAccountSelectTest | 821 class PasswordFormManagerFillOnAccountSelectTest |
818 : public PasswordFormManagerTest { | 822 : public PasswordFormManagerTest { |
819 public: | 823 public: |
820 PasswordFormManagerFillOnAccountSelectTest() { | 824 PasswordFormManagerFillOnAccountSelectTest() { |
821 scoped_feature_list_.InitAndEnableFeature(features::kFillOnAccountSelect); | 825 scoped_feature_list_.InitAndEnableFeature(features::kFillOnAccountSelect); |
822 } | 826 } |
823 | 827 |
824 base::test::ScopedFeatureList scoped_feature_list_; | 828 base::test::ScopedFeatureList scoped_feature_list_; |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
923 } | 927 } |
924 | 928 |
925 // Test that stored blacklisted forms are correctly evaluated for whether they | 929 // Test that stored blacklisted forms are correctly evaluated for whether they |
926 // apply to the observed form. | 930 // apply to the observed form. |
927 TEST_F(PasswordFormManagerTest, TestBlacklistMatching) { | 931 TEST_F(PasswordFormManagerTest, TestBlacklistMatching) { |
928 observed_form()->origin = GURL("http://accounts.google.com/a/LoginAuth"); | 932 observed_form()->origin = GURL("http://accounts.google.com/a/LoginAuth"); |
929 observed_form()->action = GURL("http://accounts.google.com/a/Login"); | 933 observed_form()->action = GURL("http://accounts.google.com/a/Login"); |
930 observed_form()->signon_realm = "http://accounts.google.com"; | 934 observed_form()->signon_realm = "http://accounts.google.com"; |
931 FakeFormFetcher fetcher; | 935 FakeFormFetcher fetcher; |
932 fetcher.Fetch(); | 936 fetcher.Fetch(); |
933 PasswordFormManager form_manager(password_manager(), client(), | 937 scoped_refptr<PasswordFormManager> form_manager( |
934 client()->driver(), *observed_form(), | 938 base::MakeRefCounted<PasswordFormManager>( |
935 base::MakeUnique<MockFormSaver>(), &fetcher); | 939 password_manager(), client(), client()->driver(), *observed_form(), |
| 940 base::MakeUnique<MockFormSaver>(), &fetcher)); |
936 | 941 |
937 // Doesn't apply because it is just a PSL match of the observed form. | 942 // Doesn't apply because it is just a PSL match of the observed form. |
938 PasswordForm blacklisted_psl = *observed_form(); | 943 PasswordForm blacklisted_psl = *observed_form(); |
939 blacklisted_psl.signon_realm = "http://m.accounts.google.com"; | 944 blacklisted_psl.signon_realm = "http://m.accounts.google.com"; |
940 blacklisted_psl.is_public_suffix_match = true; | 945 blacklisted_psl.is_public_suffix_match = true; |
941 blacklisted_psl.blacklisted_by_user = true; | 946 blacklisted_psl.blacklisted_by_user = true; |
942 | 947 |
943 // Doesn't apply because of different origin. | 948 // Doesn't apply because of different origin. |
944 PasswordForm blacklisted_not_match = *observed_form(); | 949 PasswordForm blacklisted_not_match = *observed_form(); |
945 blacklisted_not_match.origin = GURL("http://google.com/a/LoginAuth"); | 950 blacklisted_not_match.origin = GURL("http://google.com/a/LoginAuth"); |
(...skipping 22 matching lines...) Expand all Loading... |
968 | 973 |
969 std::vector<const PasswordForm*> matches = {&blacklisted_psl, | 974 std::vector<const PasswordForm*> matches = {&blacklisted_psl, |
970 &blacklisted_not_match, | 975 &blacklisted_not_match, |
971 &blacklisted_not_match2, | 976 &blacklisted_not_match2, |
972 &blacklisted_not_match3, | 977 &blacklisted_not_match3, |
973 &blacklisted_match, | 978 &blacklisted_match, |
974 &blacklisted_match2, | 979 &blacklisted_match2, |
975 saved_match()}; | 980 saved_match()}; |
976 fetcher.SetNonFederated(matches, 0u); | 981 fetcher.SetNonFederated(matches, 0u); |
977 | 982 |
978 EXPECT_TRUE(form_manager.IsBlacklisted()); | 983 EXPECT_TRUE(form_manager->IsBlacklisted()); |
979 EXPECT_THAT(form_manager.blacklisted_matches(), | 984 EXPECT_THAT(form_manager->blacklisted_matches(), |
980 UnorderedElementsAre(Pointee(blacklisted_match), | 985 UnorderedElementsAre(Pointee(blacklisted_match), |
981 Pointee(blacklisted_match2))); | 986 Pointee(blacklisted_match2))); |
982 EXPECT_EQ(1u, form_manager.best_matches().size()); | 987 EXPECT_EQ(1u, form_manager->best_matches().size()); |
983 EXPECT_EQ(*saved_match(), *form_manager.preferred_match()); | 988 EXPECT_EQ(*saved_match(), *form_manager->preferred_match()); |
984 } | 989 } |
985 | 990 |
986 // Test that even in the presence of blacklisted matches, the non-blacklisted | 991 // Test that even in the presence of blacklisted matches, the non-blacklisted |
987 // ones are still autofilled. | 992 // ones are still autofilled. |
988 TEST_F(PasswordFormManagerTest, AutofillBlacklisted) { | 993 TEST_F(PasswordFormManagerTest, AutofillBlacklisted) { |
989 PasswordForm saved_form = *observed_form(); | 994 PasswordForm saved_form = *observed_form(); |
990 saved_form.username_value = ASCIIToUTF16("user"); | 995 saved_form.username_value = ASCIIToUTF16("user"); |
991 saved_form.password_value = ASCIIToUTF16("pass"); | 996 saved_form.password_value = ASCIIToUTF16("pass"); |
992 | 997 |
993 PasswordForm blacklisted = *observed_form(); | 998 PasswordForm blacklisted = *observed_form(); |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1063 } | 1068 } |
1064 | 1069 |
1065 // Test that when the submitted form contains a "new-password" field, then the | 1070 // Test that when the submitted form contains a "new-password" field, then the |
1066 // password value is taken from there. | 1071 // password value is taken from there. |
1067 TEST_F(PasswordFormManagerTest, TestNewLoginFromNewPasswordElement) { | 1072 TEST_F(PasswordFormManagerTest, TestNewLoginFromNewPasswordElement) { |
1068 observed_form()->new_password_element = ASCIIToUTF16("NewPasswd"); | 1073 observed_form()->new_password_element = ASCIIToUTF16("NewPasswd"); |
1069 observed_form()->username_marked_by_site = true; | 1074 observed_form()->username_marked_by_site = true; |
1070 | 1075 |
1071 FakeFormFetcher fetcher; | 1076 FakeFormFetcher fetcher; |
1072 fetcher.Fetch(); | 1077 fetcher.Fetch(); |
1073 PasswordFormManager form_manager(password_manager(), client(), | 1078 scoped_refptr<PasswordFormManager> form_manager( |
1074 client()->driver(), *observed_form(), | 1079 base::MakeRefCounted<PasswordFormManager>( |
1075 base::MakeUnique<MockFormSaver>(), &fetcher); | 1080 password_manager(), client(), client()->driver(), *observed_form(), |
| 1081 base::MakeUnique<MockFormSaver>(), &fetcher)); |
1076 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 1082 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
1077 | 1083 |
1078 // User enters current and new credentials to the observed form. | 1084 // User enters current and new credentials to the observed form. |
1079 PasswordForm credentials(*observed_form()); | 1085 PasswordForm credentials(*observed_form()); |
1080 credentials.username_value = saved_match()->username_value; | 1086 credentials.username_value = saved_match()->username_value; |
1081 credentials.password_value = ASCIIToUTF16("oldpassword"); | 1087 credentials.password_value = ASCIIToUTF16("oldpassword"); |
1082 credentials.new_password_value = ASCIIToUTF16("newpassword"); | 1088 credentials.new_password_value = ASCIIToUTF16("newpassword"); |
1083 credentials.preferred = true; | 1089 credentials.preferred = true; |
1084 form_manager.ProvisionallySave( | 1090 form_manager->ProvisionallySave( |
1085 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 1091 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
1086 | 1092 |
1087 // Successful login. The PasswordManager would instruct PasswordFormManager | 1093 // Successful login. The PasswordManager would instruct PasswordFormManager |
1088 // to save, which should know this is a new login. | 1094 // to save, which should know this is a new login. |
1089 EXPECT_TRUE(form_manager.IsNewLogin()); | 1095 EXPECT_TRUE(form_manager->IsNewLogin()); |
1090 EXPECT_EQ(credentials.origin, form_manager.pending_credentials().origin); | 1096 EXPECT_EQ(credentials.origin, form_manager->pending_credentials().origin); |
1091 EXPECT_EQ(credentials.signon_realm, | 1097 EXPECT_EQ(credentials.signon_realm, |
1092 form_manager.pending_credentials().signon_realm); | 1098 form_manager->pending_credentials().signon_realm); |
1093 EXPECT_EQ(credentials.action, form_manager.pending_credentials().action); | 1099 EXPECT_EQ(credentials.action, form_manager->pending_credentials().action); |
1094 EXPECT_TRUE(form_manager.pending_credentials().preferred); | 1100 EXPECT_TRUE(form_manager->pending_credentials().preferred); |
1095 EXPECT_EQ(credentials.username_value, | 1101 EXPECT_EQ(credentials.username_value, |
1096 form_manager.pending_credentials().username_value); | 1102 form_manager->pending_credentials().username_value); |
1097 | 1103 |
1098 // By this point, the PasswordFormManager should have promoted the new | 1104 // By this point, the PasswordFormManager should have promoted the new |
1099 // password value to be the current password, and should have wiped the | 1105 // password value to be the current password, and should have wiped the |
1100 // password element name: it is likely going to be different on a login | 1106 // password element name: it is likely going to be different on a login |
1101 // form, so it is not worth remembering them. | 1107 // form, so it is not worth remembering them. |
1102 EXPECT_EQ(credentials.new_password_value, | 1108 EXPECT_EQ(credentials.new_password_value, |
1103 form_manager.pending_credentials().password_value); | 1109 form_manager->pending_credentials().password_value); |
1104 EXPECT_TRUE(form_manager.pending_credentials().password_element.empty()); | 1110 EXPECT_TRUE(form_manager->pending_credentials().password_element.empty()); |
1105 EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty()); | 1111 EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty()); |
1106 } | 1112 } |
1107 | 1113 |
1108 TEST_F(PasswordFormManagerTest, TestUpdatePassword) { | 1114 TEST_F(PasswordFormManagerTest, TestUpdatePassword) { |
1109 fake_form_fetcher()->SetNonFederated({saved_match()}, 0u); | 1115 fake_form_fetcher()->SetNonFederated({saved_match()}, 0u); |
1110 | 1116 |
1111 // User submits credentials for the observed form using a username previously | 1117 // User submits credentials for the observed form using a username previously |
1112 // stored, but a new password. Note that the observed form may have different | 1118 // stored, but a new password. Note that the observed form may have different |
1113 // origin URL (as it does in this case) than the saved_match, but we want to | 1119 // origin URL (as it does in this case) than the saved_match, but we want to |
1114 // make sure the updated password is reflected in saved_match, because that is | 1120 // make sure the updated password is reflected in saved_match, because that is |
1115 // what we autofilled. | 1121 // what we autofilled. |
(...skipping 30 matching lines...) Expand all Loading... |
1146 // should not serve as a source for updating meta-information stored with the | 1152 // should not serve as a source for updating meta-information stored with the |
1147 // old credentials, such as element names, as they are likely going to be | 1153 // old credentials, such as element names, as they are likely going to be |
1148 // different between change password and login forms. To test this in depth, | 1154 // different between change password and login forms. To test this in depth, |
1149 // forcibly wipe |submit_element|, which should normally trigger updating | 1155 // forcibly wipe |submit_element|, which should normally trigger updating |
1150 // this field from |observed_form| during updating as a special case. We will | 1156 // this field from |observed_form| during updating as a special case. We will |
1151 // verify in the end that this did not happen. | 1157 // verify in the end that this did not happen. |
1152 saved_match()->submit_element.clear(); | 1158 saved_match()->submit_element.clear(); |
1153 | 1159 |
1154 FakeFormFetcher fetcher; | 1160 FakeFormFetcher fetcher; |
1155 fetcher.Fetch(); | 1161 fetcher.Fetch(); |
1156 PasswordFormManager form_manager(password_manager(), client(), | 1162 scoped_refptr<PasswordFormManager> form_manager( |
1157 client()->driver(), *observed_form(), | 1163 base::MakeRefCounted<PasswordFormManager>( |
1158 base::MakeUnique<MockFormSaver>(), &fetcher); | 1164 password_manager(), client(), client()->driver(), *observed_form(), |
| 1165 base::MakeUnique<MockFormSaver>(), &fetcher)); |
1159 fetcher.SetNonFederated({saved_match()}, 0u); | 1166 fetcher.SetNonFederated({saved_match()}, 0u); |
1160 | 1167 |
1161 // User submits current and new credentials to the observed form. | 1168 // User submits current and new credentials to the observed form. |
1162 PasswordForm credentials(*observed_form()); | 1169 PasswordForm credentials(*observed_form()); |
1163 credentials.username_value = saved_match()->username_value; | 1170 credentials.username_value = saved_match()->username_value; |
1164 credentials.password_value = saved_match()->password_value; | 1171 credentials.password_value = saved_match()->password_value; |
1165 credentials.new_password_value = ASCIIToUTF16("test2"); | 1172 credentials.new_password_value = ASCIIToUTF16("test2"); |
1166 credentials.preferred = true; | 1173 credentials.preferred = true; |
1167 form_manager.ProvisionallySave( | 1174 form_manager->ProvisionallySave( |
1168 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 1175 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
1169 | 1176 |
1170 // Successful login. The PasswordManager would instruct PasswordFormManager | 1177 // Successful login. The PasswordManager would instruct PasswordFormManager |
1171 // to save, and since this is an update, it should know not to save as a new | 1178 // to save, and since this is an update, it should know not to save as a new |
1172 // login. | 1179 // login. |
1173 EXPECT_FALSE(form_manager.IsNewLogin()); | 1180 EXPECT_FALSE(form_manager->IsNewLogin()); |
1174 | 1181 |
1175 // By now, the PasswordFormManager should have promoted the new password value | 1182 // By now, the PasswordFormManager should have promoted the new password value |
1176 // already to be the current password, and should no longer maintain any info | 1183 // already to be the current password, and should no longer maintain any info |
1177 // about the new password. | 1184 // about the new password. |
1178 EXPECT_EQ(credentials.new_password_value, | 1185 EXPECT_EQ(credentials.new_password_value, |
1179 form_manager.pending_credentials().password_value); | 1186 form_manager->pending_credentials().password_value); |
1180 EXPECT_TRUE(form_manager.pending_credentials().new_password_element.empty()); | 1187 EXPECT_TRUE(form_manager->pending_credentials().new_password_element.empty()); |
1181 EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty()); | 1188 EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty()); |
1182 | 1189 |
1183 // Trigger saving to exercise some special case handling for updating. | 1190 // Trigger saving to exercise some special case handling for updating. |
1184 PasswordForm new_credentials; | 1191 PasswordForm new_credentials; |
1185 EXPECT_CALL(MockFormSaver::Get(&form_manager), Update(_, _, _, nullptr)) | 1192 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Update(_, _, _, nullptr)) |
1186 .WillOnce(testing::SaveArg<0>(&new_credentials)); | 1193 .WillOnce(testing::SaveArg<0>(&new_credentials)); |
1187 | 1194 |
1188 form_manager.Save(); | 1195 form_manager->Save(); |
1189 | 1196 |
1190 // No meta-information should be updated, only the password. | 1197 // No meta-information should be updated, only the password. |
1191 EXPECT_EQ(credentials.new_password_value, new_credentials.password_value); | 1198 EXPECT_EQ(credentials.new_password_value, new_credentials.password_value); |
1192 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); | 1199 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); |
1193 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); | 1200 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); |
1194 EXPECT_EQ(saved_match()->submit_element, new_credentials.submit_element); | 1201 EXPECT_EQ(saved_match()->submit_element, new_credentials.submit_element); |
1195 } | 1202 } |
1196 | 1203 |
1197 // Test that saved results are not ignored if they differ in paths for action or | 1204 // Test that saved results are not ignored if they differ in paths for action or |
1198 // origin. | 1205 // origin. |
1199 TEST_F(PasswordFormManagerTest, TestIgnoreResult_Paths) { | 1206 TEST_F(PasswordFormManagerTest, TestIgnoreResult_Paths) { |
1200 PasswordForm observed(*observed_form()); | 1207 PasswordForm observed(*observed_form()); |
1201 observed.origin = GURL("https://accounts.google.com/a/LoginAuth"); | 1208 observed.origin = GURL("https://accounts.google.com/a/LoginAuth"); |
1202 observed.action = GURL("https://accounts.google.com/a/Login"); | 1209 observed.action = GURL("https://accounts.google.com/a/Login"); |
1203 observed.signon_realm = "https://accounts.google.com"; | 1210 observed.signon_realm = "https://accounts.google.com"; |
1204 | 1211 |
1205 FakeFormFetcher fetcher; | 1212 FakeFormFetcher fetcher; |
1206 fetcher.Fetch(); | 1213 fetcher.Fetch(); |
1207 PasswordFormManager form_manager(password_manager(), client(), | 1214 scoped_refptr<PasswordFormManager> form_manager( |
1208 client()->driver(), observed, | 1215 base::MakeRefCounted<PasswordFormManager>( |
1209 base::MakeUnique<MockFormSaver>(), &fetcher); | 1216 password_manager(), client(), client()->driver(), observed, |
| 1217 base::MakeUnique<MockFormSaver>(), &fetcher)); |
1210 | 1218 |
1211 PasswordForm saved_form = observed; | 1219 PasswordForm saved_form = observed; |
1212 saved_form.origin = GURL("https://accounts.google.com/a/OtherLoginAuth"); | 1220 saved_form.origin = GURL("https://accounts.google.com/a/OtherLoginAuth"); |
1213 saved_form.action = GURL("https://accounts.google.com/a/OtherLogin"); | 1221 saved_form.action = GURL("https://accounts.google.com/a/OtherLogin"); |
1214 fetcher.SetNonFederated({&saved_form}, 0u); | 1222 fetcher.SetNonFederated({&saved_form}, 0u); |
1215 | 1223 |
1216 // Different paths for action / origin are okay. | 1224 // Different paths for action / origin are okay. |
1217 EXPECT_EQ(1u, form_manager.best_matches().size()); | 1225 EXPECT_EQ(1u, form_manager->best_matches().size()); |
1218 EXPECT_EQ(*form_manager.best_matches().begin()->second, saved_form); | 1226 EXPECT_EQ(*form_manager->best_matches().begin()->second, saved_form); |
1219 } | 1227 } |
1220 | 1228 |
1221 // Test that saved empty action URL is updated with the submitted action URL. | 1229 // Test that saved empty action URL is updated with the submitted action URL. |
1222 TEST_F(PasswordFormManagerTest, TestEmptyAction) { | 1230 TEST_F(PasswordFormManagerTest, TestEmptyAction) { |
1223 saved_match()->action = GURL(); | 1231 saved_match()->action = GURL(); |
1224 fake_form_fetcher()->SetNonFederated({saved_match()}, 0u); | 1232 fake_form_fetcher()->SetNonFederated({saved_match()}, 0u); |
1225 | 1233 |
1226 // User logs in with the autofilled username / password from saved_match. | 1234 // User logs in with the autofilled username / password from saved_match. |
1227 PasswordForm login = *observed_form(); | 1235 PasswordForm login = *observed_form(); |
1228 login.username_value = saved_match()->username_value; | 1236 login.username_value = saved_match()->username_value; |
(...skipping 139 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1368 TEST_F(PasswordFormManagerTest, | 1376 TEST_F(PasswordFormManagerTest, |
1369 TestSendNotBlacklistedMessage_DroppedCredentials) { | 1377 TestSendNotBlacklistedMessage_DroppedCredentials) { |
1370 // There are cases, such as when a form is made explicitly for creating a new | 1378 // There are cases, such as when a form is made explicitly for creating a new |
1371 // password, where we may ignore saved credentials. Make sure that we still | 1379 // password, where we may ignore saved credentials. Make sure that we still |
1372 // allow generation in that case. | 1380 // allow generation in that case. |
1373 PasswordForm signup_form(*observed_form()); | 1381 PasswordForm signup_form(*observed_form()); |
1374 signup_form.new_password_element = base::ASCIIToUTF16("new_password_field"); | 1382 signup_form.new_password_element = base::ASCIIToUTF16("new_password_field"); |
1375 | 1383 |
1376 FakeFormFetcher fetcher; | 1384 FakeFormFetcher fetcher; |
1377 fetcher.Fetch(); | 1385 fetcher.Fetch(); |
1378 PasswordFormManager form_manager(password_manager(), client(), | 1386 scoped_refptr<PasswordFormManager> form_manager( |
1379 client()->driver(), signup_form, | 1387 base::MakeRefCounted<PasswordFormManager>( |
1380 base::MakeUnique<MockFormSaver>(), &fetcher); | 1388 password_manager(), client(), client()->driver(), signup_form, |
| 1389 base::MakeUnique<MockFormSaver>(), &fetcher)); |
1381 EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_)); | 1390 EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_)); |
1382 PasswordForm simulated_result = CreateSavedMatch(false); | 1391 PasswordForm simulated_result = CreateSavedMatch(false); |
1383 fetcher.SetNonFederated({&simulated_result}, 0u); | 1392 fetcher.SetNonFederated({&simulated_result}, 0u); |
1384 } | 1393 } |
1385 | 1394 |
1386 TEST_F(PasswordFormManagerTest, | 1395 TEST_F(PasswordFormManagerTest, |
1387 TestSendNotBlacklistedMessage_BlacklistedCredentials) { | 1396 TestSendNotBlacklistedMessage_BlacklistedCredentials) { |
1388 // Signing up on a previously visited site. Credentials are found in the | 1397 // Signing up on a previously visited site. Credentials are found in the |
1389 // password store, but they are blacklisted. AllowPasswordGenerationForForm | 1398 // password store, but they are blacklisted. AllowPasswordGenerationForForm |
1390 // is still called. | 1399 // is still called. |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1520 encountered_form.signon_realm = "http://accounts.google.com/"; | 1529 encountered_form.signon_realm = "http://accounts.google.com/"; |
1521 encountered_form.action = GURL("http://accounts.google.com/Login"); | 1530 encountered_form.action = GURL("http://accounts.google.com/Login"); |
1522 encountered_form.username_element = ASCIIToUTF16("Email"); | 1531 encountered_form.username_element = ASCIIToUTF16("Email"); |
1523 encountered_form.password_element = ASCIIToUTF16("Passwd"); | 1532 encountered_form.password_element = ASCIIToUTF16("Passwd"); |
1524 encountered_form.submit_element = ASCIIToUTF16("signIn"); | 1533 encountered_form.submit_element = ASCIIToUTF16("signIn"); |
1525 | 1534 |
1526 EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_)); | 1535 EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_)); |
1527 | 1536 |
1528 FakeFormFetcher fetcher; | 1537 FakeFormFetcher fetcher; |
1529 fetcher.Fetch(); | 1538 fetcher.Fetch(); |
1530 PasswordFormManager form_manager(password_manager(), client(), | 1539 scoped_refptr<PasswordFormManager> form_manager( |
1531 client()->driver(), encountered_form, | 1540 base::MakeRefCounted<PasswordFormManager>( |
1532 base::MakeUnique<MockFormSaver>(), &fetcher); | 1541 password_manager(), client(), client()->driver(), encountered_form, |
| 1542 base::MakeUnique<MockFormSaver>(), &fetcher)); |
1533 | 1543 |
1534 PasswordForm incomplete_form; | 1544 PasswordForm incomplete_form; |
1535 incomplete_form.origin = GURL("http://accounts.google.com/LoginAuth"); | 1545 incomplete_form.origin = GURL("http://accounts.google.com/LoginAuth"); |
1536 incomplete_form.signon_realm = "http://accounts.google.com/"; | 1546 incomplete_form.signon_realm = "http://accounts.google.com/"; |
1537 incomplete_form.password_value = ASCIIToUTF16("my_password"); | 1547 incomplete_form.password_value = ASCIIToUTF16("my_password"); |
1538 incomplete_form.username_value = ASCIIToUTF16("my_username"); | 1548 incomplete_form.username_value = ASCIIToUTF16("my_username"); |
1539 incomplete_form.preferred = true; | 1549 incomplete_form.preferred = true; |
1540 incomplete_form.scheme = PasswordForm::SCHEME_HTML; | 1550 incomplete_form.scheme = PasswordForm::SCHEME_HTML; |
1541 | 1551 |
1542 // We expect to see this form eventually sent to the Password store. It | 1552 // We expect to see this form eventually sent to the Password store. It |
1543 // has password/username values from the store and 'username_element', | 1553 // has password/username values from the store and 'username_element', |
1544 // 'password_element', 'submit_element' and 'action' fields copied from | 1554 // 'password_element', 'submit_element' and 'action' fields copied from |
1545 // the encountered form. | 1555 // the encountered form. |
1546 PasswordForm complete_form(incomplete_form); | 1556 PasswordForm complete_form(incomplete_form); |
1547 complete_form.action = encountered_form.action; | 1557 complete_form.action = encountered_form.action; |
1548 complete_form.password_element = encountered_form.password_element; | 1558 complete_form.password_element = encountered_form.password_element; |
1549 complete_form.username_element = encountered_form.username_element; | 1559 complete_form.username_element = encountered_form.username_element; |
1550 complete_form.submit_element = encountered_form.submit_element; | 1560 complete_form.submit_element = encountered_form.submit_element; |
1551 | 1561 |
1552 PasswordForm obsolete_form(incomplete_form); | 1562 PasswordForm obsolete_form(incomplete_form); |
1553 obsolete_form.action = encountered_form.action; | 1563 obsolete_form.action = encountered_form.action; |
1554 | 1564 |
1555 // Feed the incomplete credentials to the manager. | 1565 // Feed the incomplete credentials to the manager. |
1556 fetcher.SetNonFederated({&incomplete_form}, 0u); | 1566 fetcher.SetNonFederated({&incomplete_form}, 0u); |
1557 | 1567 |
1558 form_manager.ProvisionallySave( | 1568 form_manager->ProvisionallySave( |
1559 complete_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 1569 complete_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
1560 // By now that form has been used once. | 1570 // By now that form has been used once. |
1561 complete_form.times_used = 1; | 1571 complete_form.times_used = 1; |
1562 obsolete_form.times_used = 1; | 1572 obsolete_form.times_used = 1; |
1563 | 1573 |
1564 // Check that PasswordStore receives an update request with the complete form. | 1574 // Check that PasswordStore receives an update request with the complete form. |
1565 EXPECT_CALL(MockFormSaver::Get(&form_manager), | 1575 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), |
1566 Update(complete_form, _, _, Pointee(obsolete_form))); | 1576 Update(complete_form, _, _, Pointee(obsolete_form))); |
1567 form_manager.Save(); | 1577 form_manager->Save(); |
1568 } | 1578 } |
1569 | 1579 |
1570 // Test that public-suffix-matched credentials score lower than same-origin | 1580 // Test that public-suffix-matched credentials score lower than same-origin |
1571 // ones. | 1581 // ones. |
1572 TEST_F(PasswordFormManagerTest, TestScoringPublicSuffixMatch) { | 1582 TEST_F(PasswordFormManagerTest, TestScoringPublicSuffixMatch) { |
1573 EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_)); | 1583 EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_)); |
1574 | 1584 |
1575 PasswordForm base_match = CreateSavedMatch(false); | 1585 PasswordForm base_match = CreateSavedMatch(false); |
1576 base_match.origin = GURL("http://accounts.google.com/a/ServiceLoginAuth"); | 1586 base_match.origin = GURL("http://accounts.google.com/a/ServiceLoginAuth"); |
1577 base_match.action = GURL("http://accounts.google.com/a/ServiceLogin"); | 1587 base_match.action = GURL("http://accounts.google.com/a/ServiceLogin"); |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1699 PasswordForm invalid_action_form(*observed_form()); | 1709 PasswordForm invalid_action_form(*observed_form()); |
1700 invalid_action_form.action = GURL("http://"); | 1710 invalid_action_form.action = GURL("http://"); |
1701 ASSERT_FALSE(invalid_action_form.action.is_valid()); | 1711 ASSERT_FALSE(invalid_action_form.action.is_valid()); |
1702 ASSERT_FALSE(invalid_action_form.action.is_empty()); | 1712 ASSERT_FALSE(invalid_action_form.action.is_empty()); |
1703 // Non-empty invalid action URLs should not match other actions. | 1713 // Non-empty invalid action URLs should not match other actions. |
1704 // First when the compared form has an invalid URL: | 1714 // First when the compared form has an invalid URL: |
1705 EXPECT_EQ(0, form_manager()->DoesManage(invalid_action_form, nullptr) & | 1715 EXPECT_EQ(0, form_manager()->DoesManage(invalid_action_form, nullptr) & |
1706 PasswordFormManager::RESULT_ACTION_MATCH); | 1716 PasswordFormManager::RESULT_ACTION_MATCH); |
1707 // Then when the observed form has an invalid URL: | 1717 // Then when the observed form has an invalid URL: |
1708 PasswordForm valid_action_form(*observed_form()); | 1718 PasswordForm valid_action_form(*observed_form()); |
1709 PasswordFormManager invalid_manager( | 1719 scoped_refptr<PasswordFormManager> invalid_manager( |
1710 password_manager(), client(), client()->driver(), invalid_action_form, | 1720 base::MakeRefCounted<PasswordFormManager>( |
1711 base::MakeUnique<MockFormSaver>(), fake_form_fetcher()); | 1721 password_manager(), client(), client()->driver(), invalid_action_form, |
1712 EXPECT_EQ(0, invalid_manager.DoesManage(valid_action_form, nullptr) & | 1722 base::MakeUnique<MockFormSaver>(), fake_form_fetcher())); |
| 1723 EXPECT_EQ(0, invalid_manager->DoesManage(valid_action_form, nullptr) & |
1713 PasswordFormManager::RESULT_ACTION_MATCH); | 1724 PasswordFormManager::RESULT_ACTION_MATCH); |
1714 } | 1725 } |
1715 | 1726 |
1716 TEST_F(PasswordFormManagerTest, EmptyActionURLsDoNotMatchNonEmpty) { | 1727 TEST_F(PasswordFormManagerTest, EmptyActionURLsDoNotMatchNonEmpty) { |
1717 PasswordForm empty_action_form(*observed_form()); | 1728 PasswordForm empty_action_form(*observed_form()); |
1718 empty_action_form.action = GURL(); | 1729 empty_action_form.action = GURL(); |
1719 ASSERT_FALSE(empty_action_form.action.is_valid()); | 1730 ASSERT_FALSE(empty_action_form.action.is_valid()); |
1720 ASSERT_TRUE(empty_action_form.action.is_empty()); | 1731 ASSERT_TRUE(empty_action_form.action.is_empty()); |
1721 // First when the compared form has an empty URL: | 1732 // First when the compared form has an empty URL: |
1722 EXPECT_EQ(0, form_manager()->DoesManage(empty_action_form, nullptr) & | 1733 EXPECT_EQ(0, form_manager()->DoesManage(empty_action_form, nullptr) & |
1723 PasswordFormManager::RESULT_ACTION_MATCH); | 1734 PasswordFormManager::RESULT_ACTION_MATCH); |
1724 // Then when the observed form has an empty URL: | 1735 // Then when the observed form has an empty URL: |
1725 PasswordForm valid_action_form(*observed_form()); | 1736 PasswordForm valid_action_form(*observed_form()); |
1726 PasswordFormManager empty_action_manager( | 1737 scoped_refptr<PasswordFormManager> empty_action_manager( |
1727 password_manager(), client(), client()->driver(), empty_action_form, | 1738 base::MakeRefCounted<PasswordFormManager>( |
1728 base::MakeUnique<MockFormSaver>(), fake_form_fetcher()); | 1739 password_manager(), client(), client()->driver(), empty_action_form, |
1729 EXPECT_EQ(0, empty_action_manager.DoesManage(valid_action_form, nullptr) & | 1740 base::MakeUnique<MockFormSaver>(), fake_form_fetcher())); |
| 1741 EXPECT_EQ(0, empty_action_manager->DoesManage(valid_action_form, nullptr) & |
1730 PasswordFormManager::RESULT_ACTION_MATCH); | 1742 PasswordFormManager::RESULT_ACTION_MATCH); |
1731 } | 1743 } |
1732 | 1744 |
1733 TEST_F(PasswordFormManagerTest, NonHTMLFormsDoNotMatchHTMLForms) { | 1745 TEST_F(PasswordFormManagerTest, NonHTMLFormsDoNotMatchHTMLForms) { |
1734 ASSERT_EQ(PasswordForm::SCHEME_HTML, observed_form()->scheme); | 1746 ASSERT_EQ(PasswordForm::SCHEME_HTML, observed_form()->scheme); |
1735 PasswordForm non_html_form(*observed_form()); | 1747 PasswordForm non_html_form(*observed_form()); |
1736 non_html_form.scheme = PasswordForm::SCHEME_DIGEST; | 1748 non_html_form.scheme = PasswordForm::SCHEME_DIGEST; |
1737 EXPECT_EQ(0, form_manager()->DoesManage(non_html_form, nullptr) & | 1749 EXPECT_EQ(0, form_manager()->DoesManage(non_html_form, nullptr) & |
1738 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); | 1750 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); |
1739 | 1751 |
1740 // The other way round: observing a non-HTML form, don't match a HTML form. | 1752 // The other way round: observing a non-HTML form, don't match a HTML form. |
1741 PasswordForm html_form(*observed_form()); | 1753 PasswordForm html_form(*observed_form()); |
1742 PasswordFormManager non_html_manager( | 1754 scoped_refptr<PasswordFormManager> non_html_manager( |
1743 password_manager(), client(), kNoDriver, non_html_form, | 1755 base::MakeRefCounted<PasswordFormManager>( |
1744 base::MakeUnique<MockFormSaver>(), fake_form_fetcher()); | 1756 password_manager(), client(), kNoDriver, non_html_form, |
1745 EXPECT_EQ(0, non_html_manager.DoesManage(html_form, nullptr) & | 1757 base::MakeUnique<MockFormSaver>(), fake_form_fetcher())); |
| 1758 EXPECT_EQ(0, non_html_manager->DoesManage(html_form, nullptr) & |
1746 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); | 1759 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); |
1747 } | 1760 } |
1748 | 1761 |
1749 TEST_F(PasswordFormManagerTest, OriginCheck_HostsMatchExactly) { | 1762 TEST_F(PasswordFormManagerTest, OriginCheck_HostsMatchExactly) { |
1750 // Host part of origins must match exactly, not just by prefix. | 1763 // Host part of origins must match exactly, not just by prefix. |
1751 PasswordForm form_longer_host(*observed_form()); | 1764 PasswordForm form_longer_host(*observed_form()); |
1752 form_longer_host.origin = GURL("http://accounts.google.com.au/a/LoginAuth"); | 1765 form_longer_host.origin = GURL("http://accounts.google.com.au/a/LoginAuth"); |
1753 // Check that accounts.google.com does not match accounts.google.com.au. | 1766 // Check that accounts.google.com does not match accounts.google.com.au. |
1754 EXPECT_EQ(0, form_manager()->DoesManage(form_longer_host, nullptr) & | 1767 EXPECT_EQ(0, form_manager()->DoesManage(form_longer_host, nullptr) & |
1755 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); | 1768 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); |
(...skipping 13 matching lines...) Expand all Loading... |
1769 // If the origin URL scheme of the compared form is not more secure than that | 1782 // If the origin URL scheme of the compared form is not more secure than that |
1770 // of the observed form, then the paths must match exactly. | 1783 // of the observed form, then the paths must match exactly. |
1771 PasswordForm form_longer_path(*observed_form()); | 1784 PasswordForm form_longer_path(*observed_form()); |
1772 form_longer_path.origin = GURL("http://accounts.google.com/a/LoginAuth/sec"); | 1785 form_longer_path.origin = GURL("http://accounts.google.com/a/LoginAuth/sec"); |
1773 // Check that /a/LoginAuth does not match /a/LoginAuth/more. | 1786 // Check that /a/LoginAuth does not match /a/LoginAuth/more. |
1774 EXPECT_EQ(0, form_manager()->DoesManage(form_longer_path, nullptr) & | 1787 EXPECT_EQ(0, form_manager()->DoesManage(form_longer_path, nullptr) & |
1775 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); | 1788 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); |
1776 | 1789 |
1777 PasswordForm secure_observed_form(*observed_form()); | 1790 PasswordForm secure_observed_form(*observed_form()); |
1778 secure_observed_form.origin = GURL("https://accounts.google.com/a/LoginAuth"); | 1791 secure_observed_form.origin = GURL("https://accounts.google.com/a/LoginAuth"); |
1779 PasswordFormManager secure_manager( | 1792 scoped_refptr<PasswordFormManager> secure_manager( |
1780 password_manager(), client(), client()->driver(), secure_observed_form, | 1793 base::MakeRefCounted<PasswordFormManager>( |
1781 base::MakeUnique<MockFormSaver>(), fake_form_fetcher()); | 1794 password_manager(), client(), client()->driver(), |
| 1795 secure_observed_form, base::MakeUnique<MockFormSaver>(), |
| 1796 fake_form_fetcher())); |
1782 // Also for HTTPS in the observed form, and HTTP in the compared form, an | 1797 // Also for HTTPS in the observed form, and HTTP in the compared form, an |
1783 // exact path match is expected. | 1798 // exact path match is expected. |
1784 EXPECT_EQ(0, secure_manager.DoesManage(form_longer_path, nullptr) & | 1799 EXPECT_EQ(0, secure_manager->DoesManage(form_longer_path, nullptr) & |
1785 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); | 1800 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); |
1786 // Not even upgrade to HTTPS in the compared form should help. | 1801 // Not even upgrade to HTTPS in the compared form should help. |
1787 form_longer_path.origin = GURL("https://accounts.google.com/a/LoginAuth/sec"); | 1802 form_longer_path.origin = GURL("https://accounts.google.com/a/LoginAuth/sec"); |
1788 EXPECT_EQ(0, secure_manager.DoesManage(form_longer_path, nullptr) & | 1803 EXPECT_EQ(0, secure_manager->DoesManage(form_longer_path, nullptr) & |
1789 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); | 1804 PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH); |
1790 } | 1805 } |
1791 | 1806 |
1792 TEST_F(PasswordFormManagerTest, OriginCheck_OnlyOriginsMatch) { | 1807 TEST_F(PasswordFormManagerTest, OriginCheck_OnlyOriginsMatch) { |
1793 // Make sure DoesManage() can distinguish when only origins match. | 1808 // Make sure DoesManage() can distinguish when only origins match. |
1794 | 1809 |
1795 PasswordForm different_html_attributes(*observed_form()); | 1810 PasswordForm different_html_attributes(*observed_form()); |
1796 different_html_attributes.password_element = ASCIIToUTF16("random_pass"); | 1811 different_html_attributes.password_element = ASCIIToUTF16("random_pass"); |
1797 different_html_attributes.username_element = ASCIIToUTF16("random_user"); | 1812 different_html_attributes.username_element = ASCIIToUTF16("random_user"); |
1798 | 1813 |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1866 EXPECT_EQ(ASCIIToUTF16("third"), credentials_to_update[0].password_value); | 1881 EXPECT_EQ(ASCIIToUTF16("third"), credentials_to_update[0].password_value); |
1867 EXPECT_FALSE(credentials_to_update[0].password_element.empty()); | 1882 EXPECT_FALSE(credentials_to_update[0].password_element.empty()); |
1868 EXPECT_TRUE(credentials_to_update[0].username_element.empty()); | 1883 EXPECT_TRUE(credentials_to_update[0].username_element.empty()); |
1869 } | 1884 } |
1870 | 1885 |
1871 TEST_F(PasswordFormManagerTest, UploadFormData_NewPassword) { | 1886 TEST_F(PasswordFormManagerTest, UploadFormData_NewPassword) { |
1872 // For newly saved passwords, upload a password vote for autofill::PASSWORD. | 1887 // For newly saved passwords, upload a password vote for autofill::PASSWORD. |
1873 // Don't vote for the username field yet. | 1888 // Don't vote for the username field yet. |
1874 FakeFormFetcher fetcher; | 1889 FakeFormFetcher fetcher; |
1875 fetcher.Fetch(); | 1890 fetcher.Fetch(); |
1876 PasswordFormManager form_manager( | 1891 scoped_refptr<PasswordFormManager> form_manager( |
1877 password_manager(), client(), client()->driver(), *saved_match(), | 1892 base::MakeRefCounted<PasswordFormManager>( |
1878 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 1893 password_manager(), client(), client()->driver(), *saved_match(), |
| 1894 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
1879 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 1895 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
1880 | 1896 |
1881 PasswordForm form_to_save(*saved_match()); | 1897 PasswordForm form_to_save(*saved_match()); |
1882 form_to_save.preferred = true; | 1898 form_to_save.preferred = true; |
1883 form_to_save.username_value = ASCIIToUTF16("username"); | 1899 form_to_save.username_value = ASCIIToUTF16("username"); |
1884 form_to_save.password_value = ASCIIToUTF16("1234"); | 1900 form_to_save.password_value = ASCIIToUTF16("1234"); |
1885 | 1901 |
1886 autofill::ServerFieldTypeSet expected_available_field_types; | 1902 autofill::ServerFieldTypeSet expected_available_field_types; |
1887 expected_available_field_types.insert(autofill::PASSWORD); | 1903 expected_available_field_types.insert(autofill::PASSWORD); |
1888 EXPECT_CALL( | 1904 EXPECT_CALL( |
1889 *client()->mock_driver()->mock_autofill_download_manager(), | 1905 *client()->mock_driver()->mock_autofill_download_manager(), |
1890 StartUploadRequest(_, false, expected_available_field_types, _, true)); | 1906 StartUploadRequest(_, false, expected_available_field_types, _, true)); |
1891 form_manager.ProvisionallySave( | 1907 form_manager->ProvisionallySave( |
1892 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 1908 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
1893 form_manager.Save(); | 1909 form_manager->Save(); |
1894 } | 1910 } |
1895 | 1911 |
1896 TEST_F(PasswordFormManagerTest, UploadFormData_NewPassword_Blacklist) { | 1912 TEST_F(PasswordFormManagerTest, UploadFormData_NewPassword_Blacklist) { |
1897 // Do not upload a vote if the user is blacklisting the form. | 1913 // Do not upload a vote if the user is blacklisting the form. |
1898 FakeFormFetcher fetcher; | 1914 FakeFormFetcher fetcher; |
1899 fetcher.Fetch(); | 1915 fetcher.Fetch(); |
1900 PasswordFormManager blacklist_form_manager( | 1916 scoped_refptr<PasswordFormManager> blacklist_form_manager( |
1901 password_manager(), client(), client()->driver(), *saved_match(), | 1917 base::MakeRefCounted<PasswordFormManager>( |
1902 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 1918 password_manager(), client(), client()->driver(), *saved_match(), |
| 1919 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
1903 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 1920 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
1904 | 1921 |
1905 autofill::ServerFieldTypeSet expected_available_field_types; | 1922 autofill::ServerFieldTypeSet expected_available_field_types; |
1906 expected_available_field_types.insert(autofill::USERNAME); | 1923 expected_available_field_types.insert(autofill::USERNAME); |
1907 expected_available_field_types.insert(autofill::PASSWORD); | 1924 expected_available_field_types.insert(autofill::PASSWORD); |
1908 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 1925 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
1909 StartUploadRequest(_, _, expected_available_field_types, _, true)) | 1926 StartUploadRequest(_, _, expected_available_field_types, _, true)) |
1910 .Times(0); | 1927 .Times(0); |
1911 blacklist_form_manager.PermanentlyBlacklist(); | 1928 blacklist_form_manager->PermanentlyBlacklist(); |
1912 } | 1929 } |
1913 | 1930 |
1914 TEST_F(PasswordFormManagerTest, UploadPasswordForm) { | 1931 TEST_F(PasswordFormManagerTest, UploadPasswordForm) { |
1915 autofill::FormData observed_form_data; | 1932 autofill::FormData observed_form_data; |
1916 autofill::FormFieldData field; | 1933 autofill::FormFieldData field; |
1917 field.label = ASCIIToUTF16("Email"); | 1934 field.label = ASCIIToUTF16("Email"); |
1918 field.name = ASCIIToUTF16("observed-username-field"); | 1935 field.name = ASCIIToUTF16("observed-username-field"); |
1919 field.form_control_type = "text"; | 1936 field.form_control_type = "text"; |
1920 observed_form_data.fields.push_back(field); | 1937 observed_form_data.fields.push_back(field); |
1921 | 1938 |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1986 PasswordForm form; | 2003 PasswordForm form; |
1987 form.origin = GURL(example_url); | 2004 form.origin = GURL(example_url); |
1988 form.signon_realm = example_url; | 2005 form.signon_realm = example_url; |
1989 form.action = GURL(example_url); | 2006 form.action = GURL(example_url); |
1990 form.username_element = ASCIIToUTF16("u"); | 2007 form.username_element = ASCIIToUTF16("u"); |
1991 form.password_element = ASCIIToUTF16("p"); | 2008 form.password_element = ASCIIToUTF16("p"); |
1992 form.submit_element = ASCIIToUTF16("s"); | 2009 form.submit_element = ASCIIToUTF16("s"); |
1993 | 2010 |
1994 FakeFormFetcher fetcher; | 2011 FakeFormFetcher fetcher; |
1995 fetcher.Fetch(); | 2012 fetcher.Fetch(); |
1996 PasswordFormManager form_manager(password_manager(), client(), | 2013 scoped_refptr<PasswordFormManager> form_manager( |
1997 client()->driver(), form, | 2014 base::MakeRefCounted<PasswordFormManager>( |
1998 base::MakeUnique<MockFormSaver>(), &fetcher); | 2015 password_manager(), client(), client()->driver(), form, |
| 2016 base::MakeUnique<MockFormSaver>(), &fetcher)); |
1999 | 2017 |
2000 // Suddenly, the frame and its driver disappear. | 2018 // Suddenly, the frame and its driver disappear. |
2001 client()->KillDriver(); | 2019 client()->KillDriver(); |
2002 | 2020 |
2003 fetcher.SetNonFederated({&form}, 0u); | 2021 fetcher.SetNonFederated({&form}, 0u); |
2004 } | 2022 } |
2005 | 2023 |
2006 TEST_F(PasswordFormManagerTest, PreferredMatchIsUpToDate) { | 2024 TEST_F(PasswordFormManagerTest, PreferredMatchIsUpToDate) { |
2007 // Check that preferred_match() is always a member of best_matches(). | 2025 // Check that preferred_match() is always a member of best_matches(). |
2008 PasswordForm form = *observed_form(); | 2026 PasswordForm form = *observed_form(); |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2066 } | 2084 } |
2067 | 2085 |
2068 TEST_F(PasswordFormManagerTest, TestSuggestingPasswordChangeForms) { | 2086 TEST_F(PasswordFormManagerTest, TestSuggestingPasswordChangeForms) { |
2069 // Suggesting password on the password change form on the previously visited | 2087 // Suggesting password on the password change form on the previously visited |
2070 // site. Credentials are found in the password store, and are not blacklisted. | 2088 // site. Credentials are found in the password store, and are not blacklisted. |
2071 PasswordForm observed_change_password_form = *observed_form(); | 2089 PasswordForm observed_change_password_form = *observed_form(); |
2072 observed_change_password_form.new_password_element = | 2090 observed_change_password_form.new_password_element = |
2073 base::ASCIIToUTF16("new_pwd"); | 2091 base::ASCIIToUTF16("new_pwd"); |
2074 FakeFormFetcher fetcher; | 2092 FakeFormFetcher fetcher; |
2075 fetcher.Fetch(); | 2093 fetcher.Fetch(); |
2076 PasswordFormManager manager_creds( | 2094 scoped_refptr<PasswordFormManager> manager_creds( |
2077 password_manager(), client(), client()->driver(), | 2095 base::MakeRefCounted<PasswordFormManager>( |
2078 observed_change_password_form, base::MakeUnique<MockFormSaver>(), | 2096 password_manager(), client(), client()->driver(), |
2079 &fetcher); | 2097 observed_change_password_form, base::MakeUnique<MockFormSaver>(), |
| 2098 &fetcher)); |
2080 | 2099 |
2081 autofill::PasswordFormFillData fill_data; | 2100 autofill::PasswordFormFillData fill_data; |
2082 EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_)) | 2101 EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_)) |
2083 .WillOnce(SaveArg<0>(&fill_data)); | 2102 .WillOnce(SaveArg<0>(&fill_data)); |
2084 | 2103 |
2085 PasswordForm result = CreateSavedMatch(false); | 2104 PasswordForm result = CreateSavedMatch(false); |
2086 fetcher.SetNonFederated({&result}, 0u); | 2105 fetcher.SetNonFederated({&result}, 0u); |
2087 EXPECT_EQ(1u, manager_creds.best_matches().size()); | 2106 EXPECT_EQ(1u, manager_creds->best_matches().size()); |
2088 EXPECT_EQ(0u, fill_data.additional_logins.size()); | 2107 EXPECT_EQ(0u, fill_data.additional_logins.size()); |
2089 EXPECT_TRUE(fill_data.wait_for_username); | 2108 EXPECT_TRUE(fill_data.wait_for_username); |
2090 } | 2109 } |
2091 | 2110 |
2092 TEST_F(PasswordFormManagerTest, TestUpdateMethod) { | 2111 TEST_F(PasswordFormManagerTest, TestUpdateMethod) { |
2093 // Add a new password field to the test form. The PasswordFormManager should | 2112 // Add a new password field to the test form. The PasswordFormManager should |
2094 // save the password from this field, instead of the current password field. | 2113 // save the password from this field, instead of the current password field. |
2095 observed_form()->new_password_element = ASCIIToUTF16("NewPasswd"); | 2114 observed_form()->new_password_element = ASCIIToUTF16("NewPasswd"); |
2096 autofill::FormFieldData field; | 2115 autofill::FormFieldData field; |
2097 field.label = ASCIIToUTF16("NewPasswd"); | 2116 field.label = ASCIIToUTF16("NewPasswd"); |
2098 field.name = ASCIIToUTF16("NewPasswd"); | 2117 field.name = ASCIIToUTF16("NewPasswd"); |
2099 field.form_control_type = "password"; | 2118 field.form_control_type = "password"; |
2100 observed_form()->form_data.fields.push_back(field); | 2119 observed_form()->form_data.fields.push_back(field); |
2101 | 2120 |
2102 // Given that |observed_form| was most likely a change password form, it | 2121 // Given that |observed_form| was most likely a change password form, it |
2103 // should not serve as a source for updating meta-information stored with the | 2122 // should not serve as a source for updating meta-information stored with the |
2104 // old credentials, such as element names, as they are likely going to be | 2123 // old credentials, such as element names, as they are likely going to be |
2105 // different between change password and login forms. To test this in depth, | 2124 // different between change password and login forms. To test this in depth, |
2106 // forcibly wipe |submit_element|, which should normally trigger updating | 2125 // forcibly wipe |submit_element|, which should normally trigger updating |
2107 // this field from |observed_form| during updating as a special case. We will | 2126 // this field from |observed_form| during updating as a special case. We will |
2108 // verify in the end that this did not happen. | 2127 // verify in the end that this did not happen. |
2109 saved_match()->submit_element.clear(); | 2128 saved_match()->submit_element.clear(); |
2110 | 2129 |
2111 FakeFormFetcher fetcher; | 2130 FakeFormFetcher fetcher; |
2112 fetcher.Fetch(); | 2131 fetcher.Fetch(); |
2113 PasswordFormManager form_manager(password_manager(), client(), | 2132 scoped_refptr<PasswordFormManager> form_manager( |
2114 client()->driver(), *observed_form(), | 2133 base::MakeRefCounted<PasswordFormManager>( |
2115 base::MakeUnique<MockFormSaver>(), &fetcher); | 2134 password_manager(), client(), client()->driver(), *observed_form(), |
| 2135 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2116 | 2136 |
2117 fetcher.SetNonFederated({saved_match()}, 0u); | 2137 fetcher.SetNonFederated({saved_match()}, 0u); |
2118 | 2138 |
2119 // User submits current and new credentials to the observed form. | 2139 // User submits current and new credentials to the observed form. |
2120 PasswordForm credentials(*observed_form()); | 2140 PasswordForm credentials(*observed_form()); |
2121 credentials.username_element.clear(); | 2141 credentials.username_element.clear(); |
2122 credentials.password_value = saved_match()->password_value; | 2142 credentials.password_value = saved_match()->password_value; |
2123 credentials.new_password_value = ASCIIToUTF16("test2"); | 2143 credentials.new_password_value = ASCIIToUTF16("test2"); |
2124 credentials.preferred = true; | 2144 credentials.preferred = true; |
2125 form_manager.ProvisionallySave( | 2145 form_manager->ProvisionallySave( |
2126 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2146 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2127 | 2147 |
2128 // Successful login. The PasswordManager would instruct PasswordFormManager | 2148 // Successful login. The PasswordManager would instruct PasswordFormManager |
2129 // to save, and since this is an update, it should know not to save as a new | 2149 // to save, and since this is an update, it should know not to save as a new |
2130 // login. | 2150 // login. |
2131 EXPECT_FALSE(form_manager.IsNewLogin()); | 2151 EXPECT_FALSE(form_manager->IsNewLogin()); |
2132 EXPECT_FALSE( | 2152 EXPECT_FALSE( |
2133 form_manager.is_possible_change_password_form_without_username()); | 2153 form_manager->is_possible_change_password_form_without_username()); |
2134 | 2154 |
2135 // By now, the PasswordFormManager should have promoted the new password value | 2155 // By now, the PasswordFormManager should have promoted the new password value |
2136 // already to be the current password, and should no longer maintain any info | 2156 // already to be the current password, and should no longer maintain any info |
2137 // about the new password value. | 2157 // about the new password value. |
2138 EXPECT_EQ(credentials.new_password_value, | 2158 EXPECT_EQ(credentials.new_password_value, |
2139 form_manager.pending_credentials().password_value); | 2159 form_manager->pending_credentials().password_value); |
2140 EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty()); | 2160 EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty()); |
2141 | 2161 |
2142 // Trigger saving to exercise some special case handling during updating. | 2162 // Trigger saving to exercise some special case handling during updating. |
2143 PasswordForm new_credentials; | 2163 PasswordForm new_credentials; |
2144 EXPECT_CALL(MockFormSaver::Get(&form_manager), Update(_, _, _, nullptr)) | 2164 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Update(_, _, _, nullptr)) |
2145 .WillOnce(SaveArg<0>(&new_credentials)); | 2165 .WillOnce(SaveArg<0>(&new_credentials)); |
2146 | 2166 |
2147 form_manager.Update(*saved_match()); | 2167 form_manager->Update(*saved_match()); |
2148 | 2168 |
2149 // No meta-information should be updated, only the password. | 2169 // No meta-information should be updated, only the password. |
2150 EXPECT_EQ(credentials.new_password_value, new_credentials.password_value); | 2170 EXPECT_EQ(credentials.new_password_value, new_credentials.password_value); |
2151 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); | 2171 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); |
2152 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); | 2172 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); |
2153 EXPECT_EQ(saved_match()->submit_element, new_credentials.submit_element); | 2173 EXPECT_EQ(saved_match()->submit_element, new_credentials.submit_element); |
2154 } | 2174 } |
2155 | 2175 |
2156 TEST_F(PasswordFormManagerTest, TestUpdateNoUsernameTextfieldPresent) { | 2176 TEST_F(PasswordFormManagerTest, TestUpdateNoUsernameTextfieldPresent) { |
2157 // Add a new password field to the test form and insert a |username_value| | 2177 // Add a new password field to the test form and insert a |username_value| |
(...skipping 10 matching lines...) Expand all Loading... |
2168 // should not serve as a source for updating meta-information stored with the | 2188 // should not serve as a source for updating meta-information stored with the |
2169 // old credentials, such as element names, as they are likely going to be | 2189 // old credentials, such as element names, as they are likely going to be |
2170 // different between change password and login forms. To test this in depth, | 2190 // different between change password and login forms. To test this in depth, |
2171 // forcibly wipe |submit_element|, which should normally trigger updating this | 2191 // forcibly wipe |submit_element|, which should normally trigger updating this |
2172 // field from |observed_form| during updating as a special case. We | 2192 // field from |observed_form| during updating as a special case. We |
2173 // will verify in the end that this did not happen. | 2193 // will verify in the end that this did not happen. |
2174 saved_match()->submit_element.clear(); | 2194 saved_match()->submit_element.clear(); |
2175 | 2195 |
2176 FakeFormFetcher fetcher; | 2196 FakeFormFetcher fetcher; |
2177 fetcher.Fetch(); | 2197 fetcher.Fetch(); |
2178 PasswordFormManager form_manager(password_manager(), client(), | 2198 scoped_refptr<PasswordFormManager> form_manager( |
2179 client()->driver(), *observed_form(), | 2199 base::MakeRefCounted<PasswordFormManager>( |
2180 base::MakeUnique<MockFormSaver>(), &fetcher); | 2200 password_manager(), client(), client()->driver(), *observed_form(), |
| 2201 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2181 | 2202 |
2182 fetcher.SetNonFederated({saved_match()}, 0u); | 2203 fetcher.SetNonFederated({saved_match()}, 0u); |
2183 | 2204 |
2184 // User submits current and new credentials to the observed form. | 2205 // User submits current and new credentials to the observed form. |
2185 PasswordForm credentials(*observed_form()); | 2206 PasswordForm credentials(*observed_form()); |
2186 // The |username_value| contains a text that's unlikely to be real username. | 2207 // The |username_value| contains a text that's unlikely to be real username. |
2187 credentials.username_value = ASCIIToUTF16("3"); | 2208 credentials.username_value = ASCIIToUTF16("3"); |
2188 credentials.password_value = saved_match()->password_value; | 2209 credentials.password_value = saved_match()->password_value; |
2189 credentials.new_password_value = ASCIIToUTF16("test2"); | 2210 credentials.new_password_value = ASCIIToUTF16("test2"); |
2190 credentials.preferred = true; | 2211 credentials.preferred = true; |
2191 form_manager.ProvisionallySave( | 2212 form_manager->ProvisionallySave( |
2192 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2213 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2193 | 2214 |
2194 // Successful login. The PasswordManager would instruct PasswordFormManager | 2215 // Successful login. The PasswordManager would instruct PasswordFormManager |
2195 // to save, and since this is an update, it should know not to save as a new | 2216 // to save, and since this is an update, it should know not to save as a new |
2196 // login. | 2217 // login. |
2197 EXPECT_FALSE(form_manager.IsNewLogin()); | 2218 EXPECT_FALSE(form_manager->IsNewLogin()); |
2198 EXPECT_TRUE(form_manager.is_possible_change_password_form_without_username()); | 2219 EXPECT_TRUE( |
| 2220 form_manager->is_possible_change_password_form_without_username()); |
2199 | 2221 |
2200 // By now, the PasswordFormManager should have promoted the new password value | 2222 // By now, the PasswordFormManager should have promoted the new password value |
2201 // already to be the current password, and should no longer maintain any info | 2223 // already to be the current password, and should no longer maintain any info |
2202 // about the new password value. | 2224 // about the new password value. |
2203 EXPECT_EQ(saved_match()->username_value, | 2225 EXPECT_EQ(saved_match()->username_value, |
2204 form_manager.pending_credentials().username_value); | 2226 form_manager->pending_credentials().username_value); |
2205 EXPECT_EQ(credentials.new_password_value, | 2227 EXPECT_EQ(credentials.new_password_value, |
2206 form_manager.pending_credentials().password_value); | 2228 form_manager->pending_credentials().password_value); |
2207 EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty()); | 2229 EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty()); |
2208 | 2230 |
2209 // Trigger saving to exercise some special case handling during updating. | 2231 // Trigger saving to exercise some special case handling during updating. |
2210 PasswordForm new_credentials; | 2232 PasswordForm new_credentials; |
2211 EXPECT_CALL(MockFormSaver::Get(&form_manager), Update(_, _, _, nullptr)) | 2233 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Update(_, _, _, nullptr)) |
2212 .WillOnce(SaveArg<0>(&new_credentials)); | 2234 .WillOnce(SaveArg<0>(&new_credentials)); |
2213 | 2235 |
2214 form_manager.Update(form_manager.pending_credentials()); | 2236 form_manager->Update(form_manager->pending_credentials()); |
2215 | 2237 |
2216 // No other information than password value should be updated. In particular | 2238 // No other information than password value should be updated. In particular |
2217 // not the username. | 2239 // not the username. |
2218 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); | 2240 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); |
2219 EXPECT_EQ(credentials.new_password_value, new_credentials.password_value); | 2241 EXPECT_EQ(credentials.new_password_value, new_credentials.password_value); |
2220 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); | 2242 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); |
2221 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); | 2243 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); |
2222 EXPECT_EQ(saved_match()->submit_element, new_credentials.submit_element); | 2244 EXPECT_EQ(saved_match()->submit_element, new_credentials.submit_element); |
2223 } | 2245 } |
2224 | 2246 |
2225 // Test that if WipeStoreCopyIfOutdated is called before password store | 2247 // Test that if WipeStoreCopyIfOutdated is called before password store |
2226 // callback, the UMA is signalled accordingly. | 2248 // callback, the UMA is signalled accordingly. |
2227 TEST_F(PasswordFormManagerTest, WipeStoreCopyIfOutdated_BeforeStoreCallback) { | 2249 TEST_F(PasswordFormManagerTest, WipeStoreCopyIfOutdated_BeforeStoreCallback) { |
2228 PasswordForm form(*saved_match()); | 2250 PasswordForm form(*saved_match()); |
2229 form.password_value = ASCIIToUTF16("nonempty-password"); | 2251 form.password_value = ASCIIToUTF16("nonempty-password"); |
2230 | 2252 |
2231 FakeFormFetcher fetcher; | 2253 FakeFormFetcher fetcher; |
2232 fetcher.Fetch(); | 2254 fetcher.Fetch(); |
2233 PasswordFormManager form_manager(password_manager(), client(), | 2255 scoped_refptr<PasswordFormManager> form_manager( |
2234 client()->driver(), form, | 2256 base::MakeRefCounted<PasswordFormManager>( |
2235 base::MakeUnique<MockFormSaver>(), &fetcher); | 2257 password_manager(), client(), client()->driver(), form, |
| 2258 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2236 // The creation of |fetcher| keeps it waiting for store results. This test | 2259 // The creation of |fetcher| keeps it waiting for store results. This test |
2237 // keeps the fetcher waiting on purpose. | 2260 // keeps the fetcher waiting on purpose. |
2238 | 2261 |
2239 PasswordForm submitted_form(form); | 2262 PasswordForm submitted_form(form); |
2240 submitted_form.password_value += ASCIIToUTF16("add stuff, make it different"); | 2263 submitted_form.password_value += ASCIIToUTF16("add stuff, make it different"); |
2241 form_manager.ProvisionallySave( | 2264 form_manager->ProvisionallySave( |
2242 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2265 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2243 | 2266 |
2244 base::HistogramTester histogram_tester; | 2267 base::HistogramTester histogram_tester; |
2245 EXPECT_CALL(MockFormSaver::Get(&form_manager), | 2268 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), |
2246 WipeOutdatedCopies(form_manager.pending_credentials(), _, _)); | 2269 WipeOutdatedCopies(form_manager->pending_credentials(), _, _)); |
2247 form_manager.WipeStoreCopyIfOutdated(); | 2270 form_manager->WipeStoreCopyIfOutdated(); |
2248 histogram_tester.ExpectUniqueSample("PasswordManager.StoreReadyWhenWiping", 0, | 2271 histogram_tester.ExpectUniqueSample("PasswordManager.StoreReadyWhenWiping", 0, |
2249 1); | 2272 1); |
2250 } | 2273 } |
2251 | 2274 |
2252 TEST_F(PasswordFormManagerTest, GenerationStatusChangedWithPassword) { | 2275 TEST_F(PasswordFormManagerTest, GenerationStatusChangedWithPassword) { |
2253 PasswordForm generated_form = *observed_form(); | 2276 PasswordForm generated_form = *observed_form(); |
2254 generated_form.type = PasswordForm::TYPE_GENERATED; | 2277 generated_form.type = PasswordForm::TYPE_GENERATED; |
2255 generated_form.username_value = ASCIIToUTF16("username"); | 2278 generated_form.username_value = ASCIIToUTF16("username"); |
2256 generated_form.password_value = ASCIIToUTF16("password2"); | 2279 generated_form.password_value = ASCIIToUTF16("password2"); |
2257 generated_form.preferred = true; | 2280 generated_form.preferred = true; |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2356 bool kFalseTrue[] = {false, true}; | 2379 bool kFalseTrue[] = {false, true}; |
2357 for (autofill::ServerFieldType vote : kChangePasswordVotes) { | 2380 for (autofill::ServerFieldType vote : kChangePasswordVotes) { |
2358 for (bool has_confirmation_field : kFalseTrue) | 2381 for (bool has_confirmation_field : kFalseTrue) |
2359 ChangePasswordUploadTest(vote, has_confirmation_field); | 2382 ChangePasswordUploadTest(vote, has_confirmation_field); |
2360 } | 2383 } |
2361 } | 2384 } |
2362 | 2385 |
2363 TEST_F(PasswordFormManagerTest, TestUpdatePSLMatchedCredentials) { | 2386 TEST_F(PasswordFormManagerTest, TestUpdatePSLMatchedCredentials) { |
2364 FakeFormFetcher fetcher; | 2387 FakeFormFetcher fetcher; |
2365 fetcher.Fetch(); | 2388 fetcher.Fetch(); |
2366 PasswordFormManager form_manager(password_manager(), client(), | 2389 scoped_refptr<PasswordFormManager> form_manager( |
2367 client()->driver(), *observed_form(), | 2390 base::MakeRefCounted<PasswordFormManager>( |
2368 base::MakeUnique<MockFormSaver>(), &fetcher); | 2391 password_manager(), client(), client()->driver(), *observed_form(), |
| 2392 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2369 fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u); | 2393 fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u); |
2370 | 2394 |
2371 // User submits a credentials with an old username and a new password. | 2395 // User submits a credentials with an old username and a new password. |
2372 PasswordForm credentials(*observed_form()); | 2396 PasswordForm credentials(*observed_form()); |
2373 credentials.username_value = saved_match()->username_value; | 2397 credentials.username_value = saved_match()->username_value; |
2374 credentials.password_value = ASCIIToUTF16("new_password"); | 2398 credentials.password_value = ASCIIToUTF16("new_password"); |
2375 credentials.preferred = true; | 2399 credentials.preferred = true; |
2376 form_manager.ProvisionallySave( | 2400 form_manager->ProvisionallySave( |
2377 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2401 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2378 | 2402 |
2379 // Successful login. The PasswordManager would instruct PasswordFormManager | 2403 // Successful login. The PasswordManager would instruct PasswordFormManager |
2380 // to save, and since this is an update, it should know not to save as a new | 2404 // to save, and since this is an update, it should know not to save as a new |
2381 // login. | 2405 // login. |
2382 EXPECT_FALSE(form_manager.IsNewLogin()); | 2406 EXPECT_FALSE(form_manager->IsNewLogin()); |
2383 | 2407 |
2384 // Trigger saving to exercise some special case handling during updating. | 2408 // Trigger saving to exercise some special case handling during updating. |
2385 PasswordForm new_credentials; | 2409 PasswordForm new_credentials; |
2386 std::vector<autofill::PasswordForm> credentials_to_update; | 2410 std::vector<autofill::PasswordForm> credentials_to_update; |
2387 EXPECT_CALL(MockFormSaver::Get(&form_manager), Update(_, _, _, nullptr)) | 2411 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Update(_, _, _, nullptr)) |
2388 .WillOnce(testing::DoAll(SaveArg<0>(&new_credentials), | 2412 .WillOnce(testing::DoAll(SaveArg<0>(&new_credentials), |
2389 SaveArgPointee<2>(&credentials_to_update))); | 2413 SaveArgPointee<2>(&credentials_to_update))); |
2390 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 2414 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
2391 StartUploadRequest(_, false, _, _, true)); | 2415 StartUploadRequest(_, false, _, _, true)); |
2392 | 2416 |
2393 form_manager.Save(); | 2417 form_manager->Save(); |
2394 | 2418 |
2395 // No meta-information should be updated, only the password. | 2419 // No meta-information should be updated, only the password. |
2396 EXPECT_EQ(credentials.password_value, new_credentials.password_value); | 2420 EXPECT_EQ(credentials.password_value, new_credentials.password_value); |
2397 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); | 2421 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); |
2398 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); | 2422 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); |
2399 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); | 2423 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); |
2400 EXPECT_EQ(saved_match()->origin, new_credentials.origin); | 2424 EXPECT_EQ(saved_match()->origin, new_credentials.origin); |
2401 | 2425 |
2402 ASSERT_EQ(1u, credentials_to_update.size()); | 2426 ASSERT_EQ(1u, credentials_to_update.size()); |
2403 EXPECT_EQ(credentials.password_value, | 2427 EXPECT_EQ(credentials.password_value, |
2404 credentials_to_update[0].password_value); | 2428 credentials_to_update[0].password_value); |
2405 EXPECT_EQ(psl_saved_match()->username_element, | 2429 EXPECT_EQ(psl_saved_match()->username_element, |
2406 credentials_to_update[0].username_element); | 2430 credentials_to_update[0].username_element); |
2407 EXPECT_EQ(psl_saved_match()->username_element, | 2431 EXPECT_EQ(psl_saved_match()->username_element, |
2408 credentials_to_update[0].username_element); | 2432 credentials_to_update[0].username_element); |
2409 EXPECT_EQ(psl_saved_match()->password_element, | 2433 EXPECT_EQ(psl_saved_match()->password_element, |
2410 credentials_to_update[0].password_element); | 2434 credentials_to_update[0].password_element); |
2411 EXPECT_EQ(psl_saved_match()->origin, credentials_to_update[0].origin); | 2435 EXPECT_EQ(psl_saved_match()->origin, credentials_to_update[0].origin); |
2412 } | 2436 } |
2413 | 2437 |
2414 TEST_F(PasswordFormManagerTest, | 2438 TEST_F(PasswordFormManagerTest, |
2415 TestNotUpdatePSLMatchedCredentialsWithAnotherUsername) { | 2439 TestNotUpdatePSLMatchedCredentialsWithAnotherUsername) { |
2416 FakeFormFetcher fetcher; | 2440 FakeFormFetcher fetcher; |
2417 fetcher.Fetch(); | 2441 fetcher.Fetch(); |
2418 PasswordFormManager form_manager(password_manager(), client(), | 2442 scoped_refptr<PasswordFormManager> form_manager( |
2419 client()->driver(), *observed_form(), | 2443 base::MakeRefCounted<PasswordFormManager>( |
2420 base::MakeUnique<MockFormSaver>(), &fetcher); | 2444 password_manager(), client(), client()->driver(), *observed_form(), |
| 2445 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2421 psl_saved_match()->username_value += ASCIIToUTF16("1"); | 2446 psl_saved_match()->username_value += ASCIIToUTF16("1"); |
2422 fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u); | 2447 fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u); |
2423 | 2448 |
2424 // User submits a credentials with an old username and a new password. | 2449 // User submits a credentials with an old username and a new password. |
2425 PasswordForm credentials(*observed_form()); | 2450 PasswordForm credentials(*observed_form()); |
2426 credentials.username_value = saved_match()->username_value; | 2451 credentials.username_value = saved_match()->username_value; |
2427 credentials.password_value = ASCIIToUTF16("new_password"); | 2452 credentials.password_value = ASCIIToUTF16("new_password"); |
2428 credentials.preferred = true; | 2453 credentials.preferred = true; |
2429 form_manager.ProvisionallySave( | 2454 form_manager->ProvisionallySave( |
2430 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2455 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2431 | 2456 |
2432 // Successful login. The PasswordManager would instruct PasswordFormManager | 2457 // Successful login. The PasswordManager would instruct PasswordFormManager |
2433 // to save, and since this is an update, it should know not to save as a new | 2458 // to save, and since this is an update, it should know not to save as a new |
2434 // login. | 2459 // login. |
2435 EXPECT_FALSE(form_manager.IsNewLogin()); | 2460 EXPECT_FALSE(form_manager->IsNewLogin()); |
2436 | 2461 |
2437 // Trigger saving to exercise some special case handling during updating. | 2462 // Trigger saving to exercise some special case handling during updating. |
2438 PasswordForm new_credentials; | 2463 PasswordForm new_credentials; |
2439 EXPECT_CALL(MockFormSaver::Get(&form_manager), | 2464 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), |
2440 Update(_, _, Pointee(IsEmpty()), nullptr)) | 2465 Update(_, _, Pointee(IsEmpty()), nullptr)) |
2441 .WillOnce(testing::SaveArg<0>(&new_credentials)); | 2466 .WillOnce(testing::SaveArg<0>(&new_credentials)); |
2442 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 2467 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
2443 StartUploadRequest(_, false, _, _, true)); | 2468 StartUploadRequest(_, false, _, _, true)); |
2444 | 2469 |
2445 form_manager.Save(); | 2470 form_manager->Save(); |
2446 | 2471 |
2447 // No meta-information should be updated, only the password. | 2472 // No meta-information should be updated, only the password. |
2448 EXPECT_EQ(credentials.password_value, new_credentials.password_value); | 2473 EXPECT_EQ(credentials.password_value, new_credentials.password_value); |
2449 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); | 2474 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); |
2450 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); | 2475 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); |
2451 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); | 2476 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); |
2452 EXPECT_EQ(saved_match()->origin, new_credentials.origin); | 2477 EXPECT_EQ(saved_match()->origin, new_credentials.origin); |
2453 } | 2478 } |
2454 | 2479 |
2455 TEST_F(PasswordFormManagerTest, | 2480 TEST_F(PasswordFormManagerTest, |
2456 TestNotUpdatePSLMatchedCredentialsWithAnotherPassword) { | 2481 TestNotUpdatePSLMatchedCredentialsWithAnotherPassword) { |
2457 FakeFormFetcher fetcher; | 2482 FakeFormFetcher fetcher; |
2458 fetcher.Fetch(); | 2483 fetcher.Fetch(); |
2459 PasswordFormManager form_manager(password_manager(), client(), | 2484 scoped_refptr<PasswordFormManager> form_manager( |
2460 client()->driver(), *observed_form(), | 2485 base::MakeRefCounted<PasswordFormManager>( |
2461 base::MakeUnique<MockFormSaver>(), &fetcher); | 2486 password_manager(), client(), client()->driver(), *observed_form(), |
| 2487 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2462 psl_saved_match()->password_value += ASCIIToUTF16("1"); | 2488 psl_saved_match()->password_value += ASCIIToUTF16("1"); |
2463 fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u); | 2489 fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u); |
2464 | 2490 |
2465 // User submits a credentials with an old username and a new password. | 2491 // User submits a credentials with an old username and a new password. |
2466 PasswordForm credentials(*observed_form()); | 2492 PasswordForm credentials(*observed_form()); |
2467 credentials.username_value = saved_match()->username_value; | 2493 credentials.username_value = saved_match()->username_value; |
2468 credentials.password_value = ASCIIToUTF16("new_password"); | 2494 credentials.password_value = ASCIIToUTF16("new_password"); |
2469 credentials.preferred = true; | 2495 credentials.preferred = true; |
2470 form_manager.ProvisionallySave( | 2496 form_manager->ProvisionallySave( |
2471 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2497 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2472 | 2498 |
2473 // Successful login. The PasswordManager would instruct PasswordFormManager | 2499 // Successful login. The PasswordManager would instruct PasswordFormManager |
2474 // to save, and since this is an update, it should know not to save as a new | 2500 // to save, and since this is an update, it should know not to save as a new |
2475 // login. | 2501 // login. |
2476 EXPECT_FALSE(form_manager.IsNewLogin()); | 2502 EXPECT_FALSE(form_manager->IsNewLogin()); |
2477 | 2503 |
2478 // Trigger saving to exercise some special case handling during updating. | 2504 // Trigger saving to exercise some special case handling during updating. |
2479 PasswordForm new_credentials; | 2505 PasswordForm new_credentials; |
2480 EXPECT_CALL(MockFormSaver::Get(&form_manager), | 2506 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), |
2481 Update(_, _, Pointee(IsEmpty()), nullptr)) | 2507 Update(_, _, Pointee(IsEmpty()), nullptr)) |
2482 .WillOnce(testing::SaveArg<0>(&new_credentials)); | 2508 .WillOnce(testing::SaveArg<0>(&new_credentials)); |
2483 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 2509 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
2484 StartUploadRequest(_, false, _, _, true)); | 2510 StartUploadRequest(_, false, _, _, true)); |
2485 | 2511 |
2486 form_manager.Save(); | 2512 form_manager->Save(); |
2487 | 2513 |
2488 // No meta-information should be updated, only the password. | 2514 // No meta-information should be updated, only the password. |
2489 EXPECT_EQ(credentials.password_value, new_credentials.password_value); | 2515 EXPECT_EQ(credentials.password_value, new_credentials.password_value); |
2490 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); | 2516 EXPECT_EQ(saved_match()->username_value, new_credentials.username_value); |
2491 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); | 2517 EXPECT_EQ(saved_match()->password_element, new_credentials.password_element); |
2492 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); | 2518 EXPECT_EQ(saved_match()->username_element, new_credentials.username_element); |
2493 EXPECT_EQ(saved_match()->origin, new_credentials.origin); | 2519 EXPECT_EQ(saved_match()->origin, new_credentials.origin); |
2494 } | 2520 } |
2495 | 2521 |
2496 TEST_F(PasswordFormManagerTest, TestNotUpdateWhenOnlyPSLMatched) { | 2522 TEST_F(PasswordFormManagerTest, TestNotUpdateWhenOnlyPSLMatched) { |
2497 FakeFormFetcher fetcher; | 2523 FakeFormFetcher fetcher; |
2498 fetcher.Fetch(); | 2524 fetcher.Fetch(); |
2499 PasswordFormManager form_manager(password_manager(), client(), | 2525 scoped_refptr<PasswordFormManager> form_manager( |
2500 client()->driver(), *observed_form(), | 2526 base::MakeRefCounted<PasswordFormManager>( |
2501 base::MakeUnique<MockFormSaver>(), &fetcher); | 2527 password_manager(), client(), client()->driver(), *observed_form(), |
| 2528 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2502 fetcher.SetNonFederated({psl_saved_match()}, 0u); | 2529 fetcher.SetNonFederated({psl_saved_match()}, 0u); |
2503 | 2530 |
2504 // User submits a credentials with an old username and a new password. | 2531 // User submits a credentials with an old username and a new password. |
2505 PasswordForm credentials(*observed_form()); | 2532 PasswordForm credentials(*observed_form()); |
2506 credentials.username_value = saved_match()->username_value; | 2533 credentials.username_value = saved_match()->username_value; |
2507 credentials.password_value = ASCIIToUTF16("new_password"); | 2534 credentials.password_value = ASCIIToUTF16("new_password"); |
2508 credentials.preferred = true; | 2535 credentials.preferred = true; |
2509 form_manager.ProvisionallySave( | 2536 form_manager->ProvisionallySave( |
2510 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2537 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2511 | 2538 |
2512 EXPECT_TRUE(form_manager.IsNewLogin()); | 2539 EXPECT_TRUE(form_manager->IsNewLogin()); |
2513 | 2540 |
2514 // PSL matched credential should not be updated, since we are not sure that | 2541 // PSL matched credential should not be updated, since we are not sure that |
2515 // this is the same credential as submitted one. | 2542 // this is the same credential as submitted one. |
2516 PasswordForm new_credentials; | 2543 PasswordForm new_credentials; |
2517 EXPECT_CALL(MockFormSaver::Get(&form_manager), Save(_, _, nullptr)) | 2544 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Save(_, _, nullptr)) |
2518 .WillOnce(testing::SaveArg<0>(&new_credentials)); | 2545 .WillOnce(testing::SaveArg<0>(&new_credentials)); |
2519 | 2546 |
2520 form_manager.Save(); | 2547 form_manager->Save(); |
2521 | 2548 |
2522 EXPECT_EQ(credentials.password_value, new_credentials.password_value); | 2549 EXPECT_EQ(credentials.password_value, new_credentials.password_value); |
2523 EXPECT_EQ(credentials.username_value, new_credentials.username_value); | 2550 EXPECT_EQ(credentials.username_value, new_credentials.username_value); |
2524 EXPECT_EQ(credentials.password_element, new_credentials.password_element); | 2551 EXPECT_EQ(credentials.password_element, new_credentials.password_element); |
2525 EXPECT_EQ(credentials.username_element, new_credentials.username_element); | 2552 EXPECT_EQ(credentials.username_element, new_credentials.username_element); |
2526 EXPECT_EQ(credentials.origin, new_credentials.origin); | 2553 EXPECT_EQ(credentials.origin, new_credentials.origin); |
2527 } | 2554 } |
2528 | 2555 |
2529 TEST_F(PasswordFormManagerTest, | 2556 TEST_F(PasswordFormManagerTest, |
2530 TestSavingOnChangePasswordFormGenerationNoStoredForms) { | 2557 TestSavingOnChangePasswordFormGenerationNoStoredForms) { |
(...skipping 114 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2645 field.name = ASCIIToUTF16("Passwd"); | 2672 field.name = ASCIIToUTF16("Passwd"); |
2646 field.form_control_type = "password"; | 2673 field.form_control_type = "password"; |
2647 observed_form()->form_data.fields.push_back(field); | 2674 observed_form()->form_data.fields.push_back(field); |
2648 | 2675 |
2649 field.label = ASCIIToUTF16("new password"); | 2676 field.label = ASCIIToUTF16("new password"); |
2650 field.name = ASCIIToUTF16("NewPasswd"); | 2677 field.name = ASCIIToUTF16("NewPasswd"); |
2651 observed_form()->form_data.fields.push_back(field); | 2678 observed_form()->form_data.fields.push_back(field); |
2652 | 2679 |
2653 FakeFormFetcher fetcher; | 2680 FakeFormFetcher fetcher; |
2654 fetcher.Fetch(); | 2681 fetcher.Fetch(); |
2655 PasswordFormManager form_manager(password_manager(), client(), | 2682 scoped_refptr<PasswordFormManager> form_manager( |
2656 client()->driver(), *observed_form(), | 2683 base::MakeRefCounted<PasswordFormManager>( |
2657 base::MakeUnique<MockFormSaver>(), &fetcher); | 2684 password_manager(), client(), client()->driver(), *observed_form(), |
| 2685 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2658 fetcher.SetNonFederated({saved_match()}, 0u); | 2686 fetcher.SetNonFederated({saved_match()}, 0u); |
2659 | 2687 |
2660 // User submits current and new credentials to the observed form. | 2688 // User submits current and new credentials to the observed form. |
2661 PasswordForm submitted_form(*observed_form()); | 2689 PasswordForm submitted_form(*observed_form()); |
2662 submitted_form.password_value = saved_match()->password_value; | 2690 submitted_form.password_value = saved_match()->password_value; |
2663 submitted_form.new_password_value = ASCIIToUTF16("test2"); | 2691 submitted_form.new_password_value = ASCIIToUTF16("test2"); |
2664 submitted_form.preferred = true; | 2692 submitted_form.preferred = true; |
2665 form_manager.ProvisionallySave( | 2693 form_manager->ProvisionallySave( |
2666 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2694 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2667 | 2695 |
2668 // Successful login. The PasswordManager would instruct PasswordFormManager | 2696 // Successful login. The PasswordManager would instruct PasswordFormManager |
2669 // to update. | 2697 // to update. |
2670 EXPECT_FALSE(form_manager.IsNewLogin()); | 2698 EXPECT_FALSE(form_manager->IsNewLogin()); |
2671 EXPECT_TRUE(form_manager.is_possible_change_password_form_without_username()); | 2699 EXPECT_TRUE( |
| 2700 form_manager->is_possible_change_password_form_without_username()); |
2672 | 2701 |
2673 // By now, the PasswordFormManager should have promoted the new password | 2702 // By now, the PasswordFormManager should have promoted the new password |
2674 // value already to be the current password, and should no longer maintain | 2703 // value already to be the current password, and should no longer maintain |
2675 // any info about the new password value. | 2704 // any info about the new password value. |
2676 EXPECT_EQ(submitted_form.new_password_value, | 2705 EXPECT_EQ(submitted_form.new_password_value, |
2677 form_manager.pending_credentials().password_value); | 2706 form_manager->pending_credentials().password_value); |
2678 EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty()); | 2707 EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty()); |
2679 | 2708 |
2680 std::map<base::string16, autofill::ServerFieldType> expected_types; | 2709 std::map<base::string16, autofill::ServerFieldType> expected_types; |
2681 expected_types[observed_form()->password_element] = autofill::PASSWORD; | 2710 expected_types[observed_form()->password_element] = autofill::PASSWORD; |
2682 expected_types[observed_form()->new_password_element] = | 2711 expected_types[observed_form()->new_password_element] = |
2683 autofill::NEW_PASSWORD; | 2712 autofill::NEW_PASSWORD; |
2684 | 2713 |
2685 autofill::ServerFieldTypeSet expected_available_field_types; | 2714 autofill::ServerFieldTypeSet expected_available_field_types; |
2686 expected_available_field_types.insert(autofill::PASSWORD); | 2715 expected_available_field_types.insert(autofill::PASSWORD); |
2687 expected_available_field_types.insert(autofill::NEW_PASSWORD); | 2716 expected_available_field_types.insert(autofill::NEW_PASSWORD); |
2688 | 2717 |
2689 std::string observed_form_signature = | 2718 std::string observed_form_signature = |
2690 autofill::FormStructure(observed_form()->form_data).FormSignatureAsStr(); | 2719 autofill::FormStructure(observed_form()->form_data).FormSignatureAsStr(); |
2691 | 2720 |
2692 std::string expected_login_signature = | 2721 std::string expected_login_signature = |
2693 autofill::FormStructure(saved_match()->form_data).FormSignatureAsStr(); | 2722 autofill::FormStructure(saved_match()->form_data).FormSignatureAsStr(); |
2694 | 2723 |
2695 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 2724 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
2696 StartUploadRequest(CheckUploadedAutofillTypesAndSignature( | 2725 StartUploadRequest(CheckUploadedAutofillTypesAndSignature( |
2697 observed_form_signature, expected_types, | 2726 observed_form_signature, expected_types, |
2698 false /* expect_generation_vote */), | 2727 false /* expect_generation_vote */), |
2699 false, expected_available_field_types, | 2728 false, expected_available_field_types, |
2700 expected_login_signature, true)); | 2729 expected_login_signature, true)); |
2701 | 2730 |
2702 form_manager.Update(*saved_match()); | 2731 form_manager->Update(*saved_match()); |
2703 } | 2732 } |
2704 | 2733 |
2705 // Checks uploading a vote about the usage of the password generation popup. | 2734 // Checks uploading a vote about the usage of the password generation popup. |
2706 TEST_F(PasswordFormManagerTest, GeneratedVoteUpload) { | 2735 TEST_F(PasswordFormManagerTest, GeneratedVoteUpload) { |
2707 bool kFalseTrue[] = {false, true}; | 2736 bool kFalseTrue[] = {false, true}; |
2708 SavePromptInteraction kSavePromptInterations[] = {SAVE, NEVER, | 2737 SavePromptInteraction kSavePromptInterations[] = {SAVE, NEVER, |
2709 NO_INTERACTION}; | 2738 NO_INTERACTION}; |
2710 for (bool is_manual_generation : kFalseTrue) { | 2739 for (bool is_manual_generation : kFalseTrue) { |
2711 for (bool is_change_password_form : kFalseTrue) { | 2740 for (bool is_change_password_form : kFalseTrue) { |
2712 for (bool has_generated_password : kFalseTrue) { | 2741 for (bool has_generated_password : kFalseTrue) { |
(...skipping 15 matching lines...) Expand all Loading... |
2728 form.form_data = saved_match()->form_data; | 2757 form.form_data = saved_match()->form_data; |
2729 | 2758 |
2730 // Create submitted form. | 2759 // Create submitted form. |
2731 PasswordForm submitted_form(form); | 2760 PasswordForm submitted_form(form); |
2732 submitted_form.preferred = true; | 2761 submitted_form.preferred = true; |
2733 submitted_form.username_value = saved_match()->username_value; | 2762 submitted_form.username_value = saved_match()->username_value; |
2734 submitted_form.password_value = saved_match()->password_value; | 2763 submitted_form.password_value = saved_match()->password_value; |
2735 | 2764 |
2736 FakeFormFetcher fetcher; | 2765 FakeFormFetcher fetcher; |
2737 fetcher.Fetch(); | 2766 fetcher.Fetch(); |
2738 PasswordFormManager form_manager( | 2767 scoped_refptr<PasswordFormManager> form_manager( |
2739 password_manager(), client(), client()->driver(), form, | 2768 base::MakeRefCounted<PasswordFormManager>( |
2740 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 2769 password_manager(), client(), client()->driver(), form, |
| 2770 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
2741 base::string16 generation_element = form.password_element; | 2771 base::string16 generation_element = form.password_element; |
2742 if (found_generation_element) | 2772 if (found_generation_element) |
2743 form_manager.SaveGenerationFieldDetectedByClassifier(generation_element); | 2773 form_manager->SaveGenerationFieldDetectedByClassifier(generation_element); |
2744 else | 2774 else |
2745 form_manager.SaveGenerationFieldDetectedByClassifier(base::string16()); | 2775 form_manager->SaveGenerationFieldDetectedByClassifier(base::string16()); |
2746 | 2776 |
2747 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 2777 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
2748 | 2778 |
2749 autofill::FormStructure form_structure(submitted_form.form_data); | 2779 autofill::FormStructure form_structure(submitted_form.form_data); |
2750 | 2780 |
2751 EXPECT_CALL( | 2781 EXPECT_CALL( |
2752 *client()->mock_driver()->mock_autofill_download_manager(), | 2782 *client()->mock_driver()->mock_autofill_download_manager(), |
2753 StartUploadRequest(CheckUploadedFormClassifierVote( | 2783 StartUploadRequest(CheckUploadedFormClassifierVote( |
2754 found_generation_element, generation_element), | 2784 found_generation_element, generation_element), |
2755 false, _, _, true)); | 2785 false, _, _, true)); |
2756 | 2786 |
2757 form_manager.ProvisionallySave( | 2787 form_manager->ProvisionallySave( |
2758 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2788 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2759 form_manager.Save(); | 2789 form_manager->Save(); |
2760 } | 2790 } |
2761 } | 2791 } |
2762 | 2792 |
2763 TEST_F(PasswordFormManagerTest, FieldPropertiesMasksUpload) { | 2793 TEST_F(PasswordFormManagerTest, FieldPropertiesMasksUpload) { |
2764 PasswordForm form(*observed_form()); | 2794 PasswordForm form(*observed_form()); |
2765 form.form_data = saved_match()->form_data; | 2795 form.form_data = saved_match()->form_data; |
2766 | 2796 |
2767 // Create submitted form. | 2797 // Create submitted form. |
2768 PasswordForm submitted_form(form); | 2798 PasswordForm submitted_form(form); |
2769 submitted_form.preferred = true; | 2799 submitted_form.preferred = true; |
2770 submitted_form.username_value = saved_match()->username_value; | 2800 submitted_form.username_value = saved_match()->username_value; |
2771 submitted_form.password_value = saved_match()->password_value; | 2801 submitted_form.password_value = saved_match()->password_value; |
2772 | 2802 |
2773 FakeFormFetcher fetcher; | 2803 FakeFormFetcher fetcher; |
2774 fetcher.Fetch(); | 2804 fetcher.Fetch(); |
2775 PasswordFormManager form_manager( | 2805 scoped_refptr<PasswordFormManager> form_manager( |
2776 password_manager(), client(), client()->driver(), form, | 2806 base::MakeRefCounted<PasswordFormManager>( |
2777 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 2807 password_manager(), client(), client()->driver(), form, |
| 2808 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
2778 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 2809 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
2779 | 2810 |
2780 DCHECK_EQ(3U, form.form_data.fields.size()); | 2811 DCHECK_EQ(3U, form.form_data.fields.size()); |
2781 submitted_form.form_data.fields[1].properties_mask = | 2812 submitted_form.form_data.fields[1].properties_mask = |
2782 FieldPropertiesFlags::USER_TYPED; | 2813 FieldPropertiesFlags::USER_TYPED; |
2783 submitted_form.form_data.fields[2].properties_mask = | 2814 submitted_form.form_data.fields[2].properties_mask = |
2784 FieldPropertiesFlags::USER_TYPED; | 2815 FieldPropertiesFlags::USER_TYPED; |
2785 | 2816 |
2786 std::map<base::string16, autofill::FieldPropertiesMask> | 2817 std::map<base::string16, autofill::FieldPropertiesMask> |
2787 expected_field_properties; | 2818 expected_field_properties; |
2788 for (const autofill::FormFieldData& field : submitted_form.form_data.fields) | 2819 for (const autofill::FormFieldData& field : submitted_form.form_data.fields) |
2789 if (field.properties_mask) | 2820 if (field.properties_mask) |
2790 expected_field_properties[field.name] = field.properties_mask; | 2821 expected_field_properties[field.name] = field.properties_mask; |
2791 | 2822 |
2792 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 2823 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
2793 StartUploadRequest( | 2824 StartUploadRequest( |
2794 CheckFieldPropertiesMasksUpload(expected_field_properties), | 2825 CheckFieldPropertiesMasksUpload(expected_field_properties), |
2795 false, _, _, true)); | 2826 false, _, _, true)); |
2796 form_manager.ProvisionallySave( | 2827 form_manager->ProvisionallySave( |
2797 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2828 submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2798 form_manager.Save(); | 2829 form_manager->Save(); |
2799 } | 2830 } |
2800 | 2831 |
2801 TEST_F(PasswordFormManagerTest, TestSavingAPIFormsWithSamePassword) { | 2832 TEST_F(PasswordFormManagerTest, TestSavingAPIFormsWithSamePassword) { |
2802 // Turn |observed_form| and |saved_match| to API created forms. | 2833 // Turn |observed_form| and |saved_match| to API created forms. |
2803 observed_form()->username_element.clear(); | 2834 observed_form()->username_element.clear(); |
2804 observed_form()->type = autofill::PasswordForm::TYPE_API; | 2835 observed_form()->type = autofill::PasswordForm::TYPE_API; |
2805 saved_match()->username_element.clear(); | 2836 saved_match()->username_element.clear(); |
2806 saved_match()->type = autofill::PasswordForm::TYPE_API; | 2837 saved_match()->type = autofill::PasswordForm::TYPE_API; |
2807 | 2838 |
2808 FakeFormFetcher fetcher; | 2839 FakeFormFetcher fetcher; |
2809 fetcher.Fetch(); | 2840 fetcher.Fetch(); |
2810 PasswordFormManager form_manager(password_manager(), client(), | 2841 scoped_refptr<PasswordFormManager> form_manager( |
2811 client()->driver(), *observed_form(), | 2842 base::MakeRefCounted<PasswordFormManager>( |
2812 base::MakeUnique<MockFormSaver>(), &fetcher); | 2843 password_manager(), client(), client()->driver(), *observed_form(), |
| 2844 base::MakeUnique<MockFormSaver>(), &fetcher)); |
2813 fetcher.SetNonFederated({saved_match()}, 0u); | 2845 fetcher.SetNonFederated({saved_match()}, 0u); |
2814 | 2846 |
2815 // User submits new credentials with the same password as in already saved | 2847 // User submits new credentials with the same password as in already saved |
2816 // one. | 2848 // one. |
2817 PasswordForm credentials(*observed_form()); | 2849 PasswordForm credentials(*observed_form()); |
2818 credentials.username_value = | 2850 credentials.username_value = |
2819 saved_match()->username_value + ASCIIToUTF16("1"); | 2851 saved_match()->username_value + ASCIIToUTF16("1"); |
2820 credentials.password_value = saved_match()->password_value; | 2852 credentials.password_value = saved_match()->password_value; |
2821 credentials.preferred = true; | 2853 credentials.preferred = true; |
2822 | 2854 |
2823 form_manager.ProvisionallySave( | 2855 form_manager->ProvisionallySave( |
2824 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2856 credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2825 | 2857 |
2826 EXPECT_TRUE(form_manager.IsNewLogin()); | 2858 EXPECT_TRUE(form_manager->IsNewLogin()); |
2827 | 2859 |
2828 PasswordForm new_credentials; | 2860 PasswordForm new_credentials; |
2829 EXPECT_CALL(MockFormSaver::Get(&form_manager), Save(_, _, nullptr)) | 2861 EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Save(_, _, nullptr)) |
2830 .WillOnce(SaveArg<0>(&new_credentials)); | 2862 .WillOnce(SaveArg<0>(&new_credentials)); |
2831 | 2863 |
2832 form_manager.Save(); | 2864 form_manager->Save(); |
2833 | 2865 |
2834 EXPECT_EQ(saved_match()->username_value + ASCIIToUTF16("1"), | 2866 EXPECT_EQ(saved_match()->username_value + ASCIIToUTF16("1"), |
2835 new_credentials.username_value); | 2867 new_credentials.username_value); |
2836 EXPECT_EQ(saved_match()->password_value, new_credentials.password_value); | 2868 EXPECT_EQ(saved_match()->password_value, new_credentials.password_value); |
2837 EXPECT_EQ(base::string16(), new_credentials.username_element); | 2869 EXPECT_EQ(base::string16(), new_credentials.username_element); |
2838 EXPECT_EQ(autofill::PasswordForm::TYPE_API, new_credentials.type); | 2870 EXPECT_EQ(autofill::PasswordForm::TYPE_API, new_credentials.type); |
2839 } | 2871 } |
2840 | 2872 |
2841 TEST_F(PasswordFormManagerTest, SkipZeroClickIntact) { | 2873 TEST_F(PasswordFormManagerTest, SkipZeroClickIntact) { |
2842 saved_match()->skip_zero_click = true; | 2874 saved_match()->skip_zero_click = true; |
(...skipping 23 matching lines...) Expand all Loading... |
2866 ASSERT_EQ(1u, credentials_to_update.size()); | 2898 ASSERT_EQ(1u, credentials_to_update.size()); |
2867 EXPECT_TRUE(credentials_to_update[0].skip_zero_click); | 2899 EXPECT_TRUE(credentials_to_update[0].skip_zero_click); |
2868 } | 2900 } |
2869 | 2901 |
2870 TEST_F(PasswordFormManagerTest, ProbablyAccountCreationUpload) { | 2902 TEST_F(PasswordFormManagerTest, ProbablyAccountCreationUpload) { |
2871 PasswordForm form(*observed_form()); | 2903 PasswordForm form(*observed_form()); |
2872 form.form_data = saved_match()->form_data; | 2904 form.form_data = saved_match()->form_data; |
2873 | 2905 |
2874 FakeFormFetcher fetcher; | 2906 FakeFormFetcher fetcher; |
2875 fetcher.Fetch(); | 2907 fetcher.Fetch(); |
2876 PasswordFormManager form_manager( | 2908 scoped_refptr<PasswordFormManager> form_manager( |
2877 password_manager(), client(), client()->driver(), form, | 2909 base::MakeRefCounted<PasswordFormManager>( |
2878 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 2910 password_manager(), client(), client()->driver(), form, |
| 2911 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
2879 | 2912 |
2880 PasswordForm form_to_save(form); | 2913 PasswordForm form_to_save(form); |
2881 form_to_save.preferred = true; | 2914 form_to_save.preferred = true; |
2882 form_to_save.username_element = ASCIIToUTF16("observed-username-field"); | 2915 form_to_save.username_element = ASCIIToUTF16("observed-username-field"); |
2883 form_to_save.username_value = saved_match()->username_value; | 2916 form_to_save.username_value = saved_match()->username_value; |
2884 form_to_save.password_value = saved_match()->password_value; | 2917 form_to_save.password_value = saved_match()->password_value; |
2885 form_to_save.does_look_like_signup_form = true; | 2918 form_to_save.does_look_like_signup_form = true; |
2886 | 2919 |
2887 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 2920 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
2888 | 2921 |
2889 autofill::FormStructure pending_structure(form_to_save.form_data); | 2922 autofill::FormStructure pending_structure(form_to_save.form_data); |
2890 autofill::ServerFieldTypeSet expected_available_field_types; | 2923 autofill::ServerFieldTypeSet expected_available_field_types; |
2891 std::map<base::string16, autofill::ServerFieldType> expected_types; | 2924 std::map<base::string16, autofill::ServerFieldType> expected_types; |
2892 expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE; | 2925 expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE; |
2893 expected_types[saved_match()->username_element] = autofill::UNKNOWN_TYPE; | 2926 expected_types[saved_match()->username_element] = autofill::UNKNOWN_TYPE; |
2894 expected_available_field_types.insert( | 2927 expected_available_field_types.insert( |
2895 autofill::PROBABLY_ACCOUNT_CREATION_PASSWORD); | 2928 autofill::PROBABLY_ACCOUNT_CREATION_PASSWORD); |
2896 expected_types[saved_match()->password_element] = | 2929 expected_types[saved_match()->password_element] = |
2897 autofill::PROBABLY_ACCOUNT_CREATION_PASSWORD; | 2930 autofill::PROBABLY_ACCOUNT_CREATION_PASSWORD; |
2898 | 2931 |
2899 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), | 2932 EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(), |
2900 StartUploadRequest( | 2933 StartUploadRequest( |
2901 CheckUploadedAutofillTypesAndSignature( | 2934 CheckUploadedAutofillTypesAndSignature( |
2902 pending_structure.FormSignatureAsStr(), expected_types, | 2935 pending_structure.FormSignatureAsStr(), expected_types, |
2903 false /* expect_generation_vote */), | 2936 false /* expect_generation_vote */), |
2904 false, expected_available_field_types, std::string(), true)); | 2937 false, expected_available_field_types, std::string(), true)); |
2905 | 2938 |
2906 form_manager.ProvisionallySave( | 2939 form_manager->ProvisionallySave( |
2907 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 2940 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
2908 form_manager.Save(); | 2941 form_manager->Save(); |
2909 } | 2942 } |
2910 | 2943 |
2911 TEST_F(PasswordFormManagerFillOnAccountSelectTest, ProcessFrame) { | 2944 TEST_F(PasswordFormManagerFillOnAccountSelectTest, ProcessFrame) { |
2912 EXPECT_CALL(*client()->mock_driver(), | 2945 EXPECT_CALL(*client()->mock_driver(), |
2913 ShowInitialPasswordAccountSuggestions(_)); | 2946 ShowInitialPasswordAccountSuggestions(_)); |
2914 fake_form_fetcher()->SetNonFederated({saved_match()}, 0u); | 2947 fake_form_fetcher()->SetNonFederated({saved_match()}, 0u); |
2915 } | 2948 } |
2916 | 2949 |
2917 // Check that PasswordFormManager records | 2950 // Check that PasswordFormManager records |
2918 // PasswordManager_LoginFollowingAutofill as part of processing a credential | 2951 // PasswordManager_LoginFollowingAutofill as part of processing a credential |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2954 static_cast<PasswordForm::Scheme>(correct); | 2987 static_cast<PasswordForm::Scheme>(correct); |
2955 const PasswordForm::Scheme kWrongScheme = | 2988 const PasswordForm::Scheme kWrongScheme = |
2956 static_cast<PasswordForm::Scheme>(wrong); | 2989 static_cast<PasswordForm::Scheme>(wrong); |
2957 SCOPED_TRACE(testing::Message() << "Correct scheme = " << kCorrectScheme | 2990 SCOPED_TRACE(testing::Message() << "Correct scheme = " << kCorrectScheme |
2958 << ", wrong scheme = " << kWrongScheme); | 2991 << ", wrong scheme = " << kWrongScheme); |
2959 | 2992 |
2960 PasswordForm observed = *observed_form(); | 2993 PasswordForm observed = *observed_form(); |
2961 observed.scheme = kCorrectScheme; | 2994 observed.scheme = kCorrectScheme; |
2962 FakeFormFetcher fetcher; | 2995 FakeFormFetcher fetcher; |
2963 fetcher.Fetch(); | 2996 fetcher.Fetch(); |
2964 PasswordFormManager form_manager( | 2997 scoped_refptr<PasswordFormManager> form_manager( |
2965 password_manager(), client(), | 2998 base::MakeRefCounted<PasswordFormManager>( |
2966 (kCorrectScheme == PasswordForm::SCHEME_HTML ? client()->driver() | 2999 password_manager(), client(), |
2967 : nullptr), | 3000 (kCorrectScheme == PasswordForm::SCHEME_HTML ? client()->driver() |
2968 observed, base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 3001 : nullptr), |
| 3002 observed, base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
2969 | 3003 |
2970 PasswordForm match = *saved_match(); | 3004 PasswordForm match = *saved_match(); |
2971 match.scheme = kCorrectScheme; | 3005 match.scheme = kCorrectScheme; |
2972 | 3006 |
2973 PasswordForm non_match = match; | 3007 PasswordForm non_match = match; |
2974 non_match.scheme = kWrongScheme; | 3008 non_match.scheme = kWrongScheme; |
2975 | 3009 |
2976 // First try putting the correct scheme first in returned matches. | 3010 // First try putting the correct scheme first in returned matches. |
2977 static_cast<FormFetcher::Consumer*>(&form_manager) | 3011 static_cast<FormFetcher::Consumer*>(form_manager.get()) |
2978 ->ProcessMatches({&match, &non_match}, 0u); | 3012 ->ProcessMatches({&match, &non_match}, 0u); |
2979 | 3013 |
2980 EXPECT_EQ(1u, form_manager.best_matches().size()); | 3014 EXPECT_EQ(1u, form_manager->best_matches().size()); |
2981 EXPECT_EQ(kCorrectScheme, | 3015 EXPECT_EQ(kCorrectScheme, |
2982 form_manager.best_matches().begin()->second->scheme); | 3016 form_manager->best_matches().begin()->second->scheme); |
2983 | 3017 |
2984 // Now try putting the correct scheme last in returned matches. | 3018 // Now try putting the correct scheme last in returned matches. |
2985 static_cast<FormFetcher::Consumer*>(&form_manager) | 3019 static_cast<FormFetcher::Consumer*>(form_manager.get()) |
2986 ->ProcessMatches({&non_match, &match}, 0u); | 3020 ->ProcessMatches({&non_match, &match}, 0u); |
2987 | 3021 |
2988 EXPECT_EQ(1u, form_manager.best_matches().size()); | 3022 EXPECT_EQ(1u, form_manager->best_matches().size()); |
2989 EXPECT_EQ(kCorrectScheme, | 3023 EXPECT_EQ(kCorrectScheme, |
2990 form_manager.best_matches().begin()->second->scheme); | 3024 form_manager->best_matches().begin()->second->scheme); |
2991 } | 3025 } |
2992 } | 3026 } |
2993 } | 3027 } |
2994 | 3028 |
2995 // Ensure that DoesManage takes into consideration drivers when origins are | 3029 // Ensure that DoesManage takes into consideration drivers when origins are |
2996 // different. | 3030 // different. |
2997 TEST_F(PasswordFormManagerTest, DoesManageDifferentOrigins) { | 3031 TEST_F(PasswordFormManagerTest, DoesManageDifferentOrigins) { |
2998 for (bool same_drivers : {false, true}) { | 3032 for (bool same_drivers : {false, true}) { |
2999 PasswordForm submitted_form(*observed_form()); | 3033 PasswordForm submitted_form(*observed_form()); |
3000 observed_form()->origin = GURL("http://accounts.google.com/a/Login"); | 3034 observed_form()->origin = GURL("http://accounts.google.com/a/Login"); |
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3125 | 3159 |
3126 EXPECT_THAT(credentials_to_update, IsEmpty()); | 3160 EXPECT_THAT(credentials_to_update, IsEmpty()); |
3127 } | 3161 } |
3128 | 3162 |
3129 // Check that on changing FormFetcher, the PasswordFormManager removes itself | 3163 // Check that on changing FormFetcher, the PasswordFormManager removes itself |
3130 // from consuming the old one. | 3164 // from consuming the old one. |
3131 TEST_F(PasswordFormManagerTest, DropFetcherOnDestruction) { | 3165 TEST_F(PasswordFormManagerTest, DropFetcherOnDestruction) { |
3132 MockFormFetcher fetcher; | 3166 MockFormFetcher fetcher; |
3133 FormFetcher::Consumer* added_consumer = nullptr; | 3167 FormFetcher::Consumer* added_consumer = nullptr; |
3134 EXPECT_CALL(fetcher, AddConsumer(_)).WillOnce(SaveArg<0>(&added_consumer)); | 3168 EXPECT_CALL(fetcher, AddConsumer(_)).WillOnce(SaveArg<0>(&added_consumer)); |
3135 auto form_manager = base::MakeUnique<PasswordFormManager>( | 3169 auto form_manager = base::MakeRefCounted<PasswordFormManager>( |
3136 password_manager(), client(), client()->driver(), *observed_form(), | 3170 password_manager(), client(), client()->driver(), *observed_form(), |
3137 base::MakeUnique<MockFormSaver>(), &fetcher); | 3171 base::MakeUnique<MockFormSaver>(), &fetcher); |
3138 EXPECT_EQ(form_manager.get(), added_consumer); | 3172 EXPECT_EQ(form_manager.get(), added_consumer); |
3139 | 3173 |
3140 EXPECT_CALL(fetcher, RemoveConsumer(form_manager.get())); | 3174 EXPECT_CALL(fetcher, RemoveConsumer(form_manager.get())); |
3141 form_manager.reset(); | 3175 form_manager = nullptr; |
3142 } | 3176 } |
3143 | 3177 |
3144 // Check that if asked to take ownership of the same FormFetcher which it had | 3178 // Check that if asked to take ownership of the same FormFetcher which it had |
3145 // consumed before, the PasswordFormManager does not add itself as a consumer | 3179 // consumed before, the PasswordFormManager does not add itself as a consumer |
3146 // again. | 3180 // again. |
3147 TEST_F(PasswordFormManagerTest, GrabFetcher_Same) { | 3181 TEST_F(PasswordFormManagerTest, GrabFetcher_Same) { |
3148 auto fetcher = base::MakeUnique<MockFormFetcher>(); | 3182 auto fetcher = base::MakeUnique<MockFormFetcher>(); |
3149 fetcher->Fetch(); | 3183 fetcher->Fetch(); |
3150 PasswordFormManager form_manager( | 3184 scoped_refptr<PasswordFormManager> form_manager( |
3151 password_manager(), client(), client()->driver(), *observed_form(), | 3185 base::MakeRefCounted<PasswordFormManager>( |
3152 base::MakeUnique<MockFormSaver>(), fetcher.get()); | 3186 password_manager(), client(), client()->driver(), *observed_form(), |
| 3187 base::MakeUnique<MockFormSaver>(), fetcher.get())); |
3153 | 3188 |
3154 EXPECT_CALL(*fetcher, AddConsumer(_)).Times(0); | 3189 EXPECT_CALL(*fetcher, AddConsumer(_)).Times(0); |
3155 EXPECT_CALL(*fetcher, RemoveConsumer(_)).Times(0); | 3190 EXPECT_CALL(*fetcher, RemoveConsumer(_)).Times(0); |
3156 form_manager.GrabFetcher(std::move(fetcher)); | 3191 form_manager->GrabFetcher(std::move(fetcher)); |
3157 // There will be a RemoveConsumer call as soon as form_manager goes out of | 3192 // There will be a RemoveConsumer call as soon as form_manager goes out of |
3158 // scope, but the test needs to ensure that there is none as a result of | 3193 // scope, but the test needs to ensure that there is none as a result of |
3159 // GrabFetcher. | 3194 // GrabFetcher. |
3160 Mock::VerifyAndClearExpectations(form_manager.form_fetcher()); | 3195 Mock::VerifyAndClearExpectations(form_manager->form_fetcher()); |
3161 } | 3196 } |
3162 | 3197 |
3163 // Check that if asked to take ownership of a different FormFetcher than which | 3198 // Check that if asked to take ownership of a different FormFetcher than which |
3164 // it had consumed before, the PasswordFormManager adds itself as a consumer | 3199 // it had consumed before, the PasswordFormManager adds itself as a consumer |
3165 // and replaces the references to the old results. | 3200 // and replaces the references to the old results. |
3166 TEST_F(PasswordFormManagerTest, GrabFetcher_Different) { | 3201 TEST_F(PasswordFormManagerTest, GrabFetcher_Different) { |
3167 PasswordForm old_match = *observed_form(); | 3202 PasswordForm old_match = *observed_form(); |
3168 old_match.username_value = ASCIIToUTF16("user1"); | 3203 old_match.username_value = ASCIIToUTF16("user1"); |
3169 old_match.password_value = ASCIIToUTF16("pass"); | 3204 old_match.password_value = ASCIIToUTF16("pass"); |
3170 fake_form_fetcher()->SetNonFederated({&old_match}, 0u); | 3205 fake_form_fetcher()->SetNonFederated({&old_match}, 0u); |
(...skipping 11 matching lines...) Expand all Loading... |
3182 EXPECT_EQ(0u, form_manager()->best_matches().size()); | 3217 EXPECT_EQ(0u, form_manager()->best_matches().size()); |
3183 } | 3218 } |
3184 | 3219 |
3185 // Check that on changing FormFetcher, the PasswordFormManager removes itself | 3220 // Check that on changing FormFetcher, the PasswordFormManager removes itself |
3186 // from consuming the old one. | 3221 // from consuming the old one. |
3187 TEST_F(PasswordFormManagerTest, GrabFetcher_Remove) { | 3222 TEST_F(PasswordFormManagerTest, GrabFetcher_Remove) { |
3188 MockFormFetcher old_fetcher; | 3223 MockFormFetcher old_fetcher; |
3189 FormFetcher::Consumer* added_consumer = nullptr; | 3224 FormFetcher::Consumer* added_consumer = nullptr; |
3190 EXPECT_CALL(old_fetcher, AddConsumer(_)) | 3225 EXPECT_CALL(old_fetcher, AddConsumer(_)) |
3191 .WillOnce(SaveArg<0>(&added_consumer)); | 3226 .WillOnce(SaveArg<0>(&added_consumer)); |
3192 PasswordFormManager form_manager( | 3227 scoped_refptr<PasswordFormManager> form_manager( |
3193 password_manager(), client(), client()->driver(), *observed_form(), | 3228 base::MakeRefCounted<PasswordFormManager>( |
3194 base::MakeUnique<MockFormSaver>(), &old_fetcher); | 3229 password_manager(), client(), client()->driver(), *observed_form(), |
3195 EXPECT_EQ(&form_manager, added_consumer); | 3230 base::MakeUnique<MockFormSaver>(), &old_fetcher)); |
| 3231 EXPECT_EQ(form_manager.get(), added_consumer); |
3196 | 3232 |
3197 auto new_fetcher = base::MakeUnique<MockFormFetcher>(); | 3233 auto new_fetcher = base::MakeUnique<MockFormFetcher>(); |
3198 EXPECT_CALL(*new_fetcher, AddConsumer(&form_manager)); | 3234 EXPECT_CALL(*new_fetcher, AddConsumer(form_manager.get())); |
3199 EXPECT_CALL(old_fetcher, RemoveConsumer(&form_manager)); | 3235 EXPECT_CALL(old_fetcher, RemoveConsumer(form_manager.get())); |
3200 form_manager.GrabFetcher(std::move(new_fetcher)); | 3236 form_manager->GrabFetcher(std::move(new_fetcher)); |
3201 } | 3237 } |
3202 | 3238 |
3203 TEST_F(PasswordFormManagerTest, UploadSignInForm_WithAutofillTypes) { | 3239 TEST_F(PasswordFormManagerTest, UploadSignInForm_WithAutofillTypes) { |
3204 // For newly saved passwords on a sign-in form, upload an autofill vote for a | 3240 // For newly saved passwords on a sign-in form, upload an autofill vote for a |
3205 // username field and a autofill::PASSWORD vote for a password field. | 3241 // username field and a autofill::PASSWORD vote for a password field. |
3206 autofill::FormFieldData field; | 3242 autofill::FormFieldData field; |
3207 field.name = ASCIIToUTF16("Email"); | 3243 field.name = ASCIIToUTF16("Email"); |
3208 field.form_control_type = "text"; | 3244 field.form_control_type = "text"; |
3209 observed_form()->form_data.fields.push_back(field); | 3245 observed_form()->form_data.fields.push_back(field); |
3210 | 3246 |
3211 field.name = ASCIIToUTF16("Passwd"); | 3247 field.name = ASCIIToUTF16("Passwd"); |
3212 field.form_control_type = "password"; | 3248 field.form_control_type = "password"; |
3213 observed_form()->form_data.fields.push_back(field); | 3249 observed_form()->form_data.fields.push_back(field); |
3214 | 3250 |
3215 FakeFormFetcher fetcher; | 3251 FakeFormFetcher fetcher; |
3216 fetcher.Fetch(); | 3252 fetcher.Fetch(); |
3217 PasswordFormManager form_manager( | 3253 scoped_refptr<PasswordFormManager> form_manager( |
3218 password_manager(), client(), client()->driver(), *observed_form(), | 3254 base::MakeRefCounted<PasswordFormManager>( |
3219 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 3255 password_manager(), client(), client()->driver(), *observed_form(), |
| 3256 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
3220 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 3257 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
3221 | 3258 |
3222 PasswordForm form_to_save(*observed_form()); | 3259 PasswordForm form_to_save(*observed_form()); |
3223 form_to_save.preferred = true; | 3260 form_to_save.preferred = true; |
3224 form_to_save.username_value = ASCIIToUTF16("test@gmail.com"); | 3261 form_to_save.username_value = ASCIIToUTF16("test@gmail.com"); |
3225 form_to_save.password_value = ASCIIToUTF16("password"); | 3262 form_to_save.password_value = ASCIIToUTF16("password"); |
3226 | 3263 |
3227 std::unique_ptr<FormStructure> uploaded_form_structure; | 3264 std::unique_ptr<FormStructure> uploaded_form_structure; |
3228 auto* mock_autofill_manager = | 3265 auto* mock_autofill_manager = |
3229 client()->mock_driver()->mock_autofill_manager(); | 3266 client()->mock_driver()->mock_autofill_manager(); |
3230 EXPECT_CALL(*mock_autofill_manager, StartUploadProcessPtr(_, _, true)) | 3267 EXPECT_CALL(*mock_autofill_manager, StartUploadProcessPtr(_, _, true)) |
3231 .WillOnce(WithArg<0>(SaveToUniquePtr(&uploaded_form_structure))); | 3268 .WillOnce(WithArg<0>(SaveToUniquePtr(&uploaded_form_structure))); |
3232 form_manager.ProvisionallySave( | 3269 form_manager->ProvisionallySave( |
3233 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 3270 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
3234 form_manager.Save(); | 3271 form_manager->Save(); |
3235 | 3272 |
3236 ASSERT_EQ(2u, uploaded_form_structure->field_count()); | 3273 ASSERT_EQ(2u, uploaded_form_structure->field_count()); |
3237 autofill::ServerFieldTypeSet expected_types = {autofill::PASSWORD}; | 3274 autofill::ServerFieldTypeSet expected_types = {autofill::PASSWORD}; |
3238 EXPECT_EQ(form_to_save.username_value, | 3275 EXPECT_EQ(form_to_save.username_value, |
3239 uploaded_form_structure->field(0)->value); | 3276 uploaded_form_structure->field(0)->value); |
3240 EXPECT_EQ(expected_types, | 3277 EXPECT_EQ(expected_types, |
3241 uploaded_form_structure->field(1)->possible_types()); | 3278 uploaded_form_structure->field(1)->possible_types()); |
3242 } | 3279 } |
3243 | 3280 |
3244 // Checks that there is no upload on saving a password on a password form only | 3281 // Checks that there is no upload on saving a password on a password form only |
3245 // with 1 field. | 3282 // with 1 field. |
3246 TEST_F(PasswordFormManagerTest, NoUploadsForSubmittedFormWithOnlyOneField) { | 3283 TEST_F(PasswordFormManagerTest, NoUploadsForSubmittedFormWithOnlyOneField) { |
3247 autofill::FormFieldData field; | 3284 autofill::FormFieldData field; |
3248 field.name = ASCIIToUTF16("Passwd"); | 3285 field.name = ASCIIToUTF16("Passwd"); |
3249 field.form_control_type = "password"; | 3286 field.form_control_type = "password"; |
3250 observed_form()->form_data.fields.push_back(field); | 3287 observed_form()->form_data.fields.push_back(field); |
3251 | 3288 |
3252 FakeFormFetcher fetcher; | 3289 FakeFormFetcher fetcher; |
3253 fetcher.Fetch(); | 3290 fetcher.Fetch(); |
3254 PasswordFormManager form_manager( | 3291 scoped_refptr<PasswordFormManager> form_manager( |
3255 password_manager(), client(), client()->driver(), *observed_form(), | 3292 base::MakeRefCounted<PasswordFormManager>( |
3256 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 3293 password_manager(), client(), client()->driver(), *observed_form(), |
| 3294 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher)); |
3257 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 3295 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
3258 | 3296 |
3259 PasswordForm form_to_save(*observed_form()); | 3297 PasswordForm form_to_save(*observed_form()); |
3260 form_to_save.preferred = true; | 3298 form_to_save.preferred = true; |
3261 form_to_save.password_value = ASCIIToUTF16("password"); | 3299 form_to_save.password_value = ASCIIToUTF16("password"); |
3262 | 3300 |
3263 auto* mock_autofill_manager = | 3301 auto* mock_autofill_manager = |
3264 client()->mock_driver()->mock_autofill_manager(); | 3302 client()->mock_driver()->mock_autofill_manager(); |
3265 EXPECT_CALL(*mock_autofill_manager, StartUploadProcessPtr(_, _, _)).Times(0); | 3303 EXPECT_CALL(*mock_autofill_manager, StartUploadProcessPtr(_, _, _)).Times(0); |
3266 form_manager.ProvisionallySave( | 3304 form_manager->ProvisionallySave( |
3267 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); | 3305 form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES); |
3268 form_manager.Save(); | 3306 form_manager->Save(); |
3269 } | 3307 } |
3270 | 3308 |
3271 TEST_F(PasswordFormManagerTest, | 3309 TEST_F(PasswordFormManagerTest, |
3272 SuppressedHTTPSFormsHistogram_NotRecordedIfStoreWasTooSlow) { | 3310 SuppressedHTTPSFormsHistogram_NotRecordedIfStoreWasTooSlow) { |
3273 base::HistogramTester histogram_tester; | 3311 base::HistogramTester histogram_tester; |
3274 | 3312 |
3275 fake_form_fetcher()->set_did_complete_querying_suppressed_forms(false); | 3313 fake_form_fetcher()->set_did_complete_querying_suppressed_forms(false); |
3276 fake_form_fetcher()->Fetch(); | 3314 fake_form_fetcher()->Fetch(); |
3277 std::unique_ptr<PasswordFormManager> form_manager = | 3315 scoped_refptr<PasswordFormManager> form_manager( |
3278 base::MakeUnique<PasswordFormManager>( | 3316 base::MakeRefCounted<PasswordFormManager>( |
3279 password_manager(), client(), client()->driver(), *observed_form(), | 3317 password_manager(), client(), client()->driver(), *observed_form(), |
3280 base::MakeUnique<NiceMock<MockFormSaver>>(), fake_form_fetcher()); | 3318 base::MakeUnique<NiceMock<MockFormSaver>>(), fake_form_fetcher())); |
3281 fake_form_fetcher()->SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 3319 fake_form_fetcher()->SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
3282 form_manager.reset(); | 3320 form_manager = nullptr; |
3283 | 3321 |
3284 histogram_tester.ExpectUniqueSample( | 3322 histogram_tester.ExpectUniqueSample( |
3285 "PasswordManager.QueryingSuppressedAccountsFinished", false, 1); | 3323 "PasswordManager.QueryingSuppressedAccountsFinished", false, 1); |
3286 const auto sample_counts = histogram_tester.GetTotalCountsForPrefix( | 3324 const auto sample_counts = histogram_tester.GetTotalCountsForPrefix( |
3287 "PasswordManager.SuppressedAccount."); | 3325 "PasswordManager.SuppressedAccount."); |
3288 EXPECT_THAT(sample_counts, IsEmpty()); | 3326 EXPECT_THAT(sample_counts, IsEmpty()); |
3289 } | 3327 } |
3290 | 3328 |
3291 TEST_F(PasswordFormManagerTest, SuppressedFormsHistograms) { | 3329 TEST_F(PasswordFormManagerTest, SuppressedFormsHistograms) { |
3292 static constexpr const struct { | 3330 static constexpr const struct { |
(...skipping 172 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3465 // scheme of the main frame. | 3503 // scheme of the main frame. |
3466 ASSERT_FALSE(client()->IsMainFrameSecure()); | 3504 ASSERT_FALSE(client()->IsMainFrameSecure()); |
3467 | 3505 |
3468 // Even if there were any suppressed HTTPS forms, they should be are ignored | 3506 // Even if there were any suppressed HTTPS forms, they should be are ignored |
3469 // (but there should be none in production in this case). | 3507 // (but there should be none in production in this case). |
3470 FakeFormFetcher fetcher; | 3508 FakeFormFetcher fetcher; |
3471 fetcher.set_suppressed_https_forms({saved_match()}); | 3509 fetcher.set_suppressed_https_forms({saved_match()}); |
3472 fetcher.set_did_complete_querying_suppressed_forms(true); | 3510 fetcher.set_did_complete_querying_suppressed_forms(true); |
3473 fetcher.Fetch(); | 3511 fetcher.Fetch(); |
3474 | 3512 |
3475 std::unique_ptr<PasswordFormManager> form_manager = | 3513 scoped_refptr<PasswordFormManager> form_manager = |
3476 base::MakeUnique<PasswordFormManager>( | 3514 base::MakeRefCounted<PasswordFormManager>( |
3477 password_manager(), client(), client()->driver(), https_observed_form, | 3515 password_manager(), client(), client()->driver(), https_observed_form, |
3478 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); | 3516 base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher); |
3479 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); | 3517 fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u); |
3480 form_manager.reset(); | 3518 form_manager = nullptr; |
3481 | 3519 |
3482 histogram_tester.ExpectUniqueSample( | 3520 histogram_tester.ExpectUniqueSample( |
3483 "PasswordManager.QueryingSuppressedAccountsFinished", true, 1); | 3521 "PasswordManager.QueryingSuppressedAccountsFinished", true, 1); |
3484 histogram_tester.ExpectTotalCount( | 3522 histogram_tester.ExpectTotalCount( |
3485 "PasswordManager.SuppressedAccount.Generated.HTTPSNotHTTP", 0); | 3523 "PasswordManager.SuppressedAccount.Generated.HTTPSNotHTTP", 0); |
3486 histogram_tester.ExpectTotalCount( | 3524 histogram_tester.ExpectTotalCount( |
3487 "PasswordManager.SuppressedAccount.Manual.HTTPSNotHTTP", 0); | 3525 "PasswordManager.SuppressedAccount.Manual.HTTPSNotHTTP", 0); |
3488 histogram_tester.ExpectTotalCount( | 3526 histogram_tester.ExpectTotalCount( |
3489 "PasswordManager.SuppressedAccount.Generated.PSLMatching", 1); | 3527 "PasswordManager.SuppressedAccount.Generated.PSLMatching", 1); |
3490 histogram_tester.ExpectTotalCount( | 3528 histogram_tester.ExpectTotalCount( |
3491 "PasswordManager.SuppressedAccount.Manual.PSLMatching", 1); | 3529 "PasswordManager.SuppressedAccount.Manual.PSLMatching", 1); |
3492 histogram_tester.ExpectTotalCount( | 3530 histogram_tester.ExpectTotalCount( |
3493 "PasswordManager.SuppressedAccount.Generated.SameOrganizationName", 1); | 3531 "PasswordManager.SuppressedAccount.Generated.SameOrganizationName", 1); |
3494 histogram_tester.ExpectTotalCount( | 3532 histogram_tester.ExpectTotalCount( |
3495 "PasswordManager.SuppressedAccount.Manual.SameOrganizationName", 1); | 3533 "PasswordManager.SuppressedAccount.Manual.SameOrganizationName", 1); |
3496 } | 3534 } |
3497 | 3535 |
3498 } // namespace password_manager | 3536 } // namespace password_manager |
OLD | NEW |