Remove PasswordStore::AuthorizationPromptPolicy

components/password_manager/core/browser/password_form_manager_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/password_manager/core/browser/password_form_manager.h"
 
 #include <map>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 323 matching lines @@
 
   void TearDown() override {
     if (mock_store_.get())
       mock_store_->ShutdownOnUIThread();
   }
 
   MockPasswordStore* mock_store() const { return mock_store_.get(); }
 
   void SimulateMatchingPhase(PasswordFormManager* p,
                              ResultOfSimulatedMatchingMask result) {
-    const PasswordStore::AuthorizationPromptPolicy auth_policy =
-        PasswordStore::DISALLOW_PROMPT;
-    EXPECT_CALL(*mock_store(), GetLogins(p->observed_form(), auth_policy, p));
-    p->FetchDataFromPasswordStore(auth_policy);
+    EXPECT_CALL(*mock_store(), GetLogins(p->observed_form(), p));
+    p->FetchDataFromPasswordStore();
     if (result == RESULT_NO_MATCH) {
       p->OnGetPasswordStoreResults(ScopedVector<PasswordForm>());
       return;
     }
 
     ScopedVector<PasswordForm> result_form;
     if (result & RESULT_SAVED_MATCH) {
       result_form.push_back(new PasswordForm(saved_match_));
     }
     if (result & RESULT_PSL_MATCH) {
@@ skipping 1024 matching lines @@
   encountered_form.action = GURL("http://accounts.google.com/Login");
   encountered_form.username_element = ASCIIToUTF16("Email");
   encountered_form.password_element = ASCIIToUTF16("Passwd");
   encountered_form.submit_element = ASCIIToUTF16("signIn");
 
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_));
 
   PasswordFormManager form_manager(password_manager(), client(),
                                    client()->driver(), encountered_form, false);
 
-  const PasswordStore::AuthorizationPromptPolicy auth_policy =
-      PasswordStore::DISALLOW_PROMPT;
-  EXPECT_CALL(*mock_store(),
-              GetLogins(encountered_form, auth_policy, &form_manager));
-  form_manager.FetchDataFromPasswordStore(auth_policy);
+  EXPECT_CALL(*mock_store(), GetLogins(encountered_form, &form_manager));
+  form_manager.FetchDataFromPasswordStore();
 
   // Password store only has these incomplete credentials.
   scoped_ptr<PasswordForm> incomplete_form(new PasswordForm());
   incomplete_form->origin = GURL("http://accounts.google.com/LoginAuth");
   incomplete_form->signon_realm = "http://accounts.google.com/";
   incomplete_form->password_value = ASCIIToUTF16("my_password");
   incomplete_form->username_value = ASCIIToUTF16("my_username");
   incomplete_form->preferred = true;
   incomplete_form->ssl_valid = false;
   incomplete_form->scheme = PasswordForm::SCHEME_HTML;
@@ skipping 435 matching lines @@
   form->origin = GURL(example_url);
   form->signon_realm = example_url;
   form->action = GURL(example_url);
   form->username_element = ASCIIToUTF16("u");
   form->password_element = ASCIIToUTF16("p");
   form->submit_element = ASCIIToUTF16("s");
 
   PasswordFormManager form_manager(password_manager(), client(),
                                    client()->driver(), *form, false);
 
-  const PasswordStore::AuthorizationPromptPolicy auth_policy =
-      PasswordStore::DISALLOW_PROMPT;
-  EXPECT_CALL(*mock_store(), GetLogins(*form, auth_policy, &form_manager));
-  form_manager.FetchDataFromPasswordStore(auth_policy);
+  EXPECT_CALL(*mock_store(), GetLogins(*form, &form_manager));
+  form_manager.FetchDataFromPasswordStore();
 
   // Suddenly, the frame and its driver disappear.
   client()->KillDriver();
 
   ScopedVector<PasswordForm> simulated_results;
   simulated_results.push_back(std::move(form));
   form_manager.OnGetPasswordStoreResults(std::move(simulated_results));
 }
 
 TEST_F(PasswordFormManagerTest, PreferredMatchIsUpToDate) {
   // Check that preferred_match() is always a member of best_matches().
-  const PasswordStore::AuthorizationPromptPolicy auth_policy =
-      PasswordStore::DISALLOW_PROMPT;
-  EXPECT_CALL(*mock_store(),
-              GetLogins(*observed_form(), auth_policy, form_manager()));
-  form_manager()->FetchDataFromPasswordStore(auth_policy);
+  EXPECT_CALL(*mock_store(), GetLogins(*observed_form(), form_manager()));
+  form_manager()->FetchDataFromPasswordStore();
 
   ScopedVector<PasswordForm> simulated_results;
   scoped_ptr<PasswordForm> form(new PasswordForm(*observed_form()));
   form->username_value = ASCIIToUTF16("username");
   form->password_value = ASCIIToUTF16("password1");
   form->preferred = false;
 
   scoped_ptr<PasswordForm> generated_form(new PasswordForm(*form));
   generated_form->type = PasswordForm::TYPE_GENERATED;
   generated_form->password_value = ASCIIToUTF16("password2");
@@ skipping 258 matching lines @@
 }
 
 TEST_F(PasswordFormManagerTest, WipeStoreCopyIfOutdated_BeforeStoreCallback) {
   PasswordForm form(*saved_match());
   ASSERT_FALSE(form.password_value.empty());
 
   PasswordFormManager form_manager(password_manager(), client(),
                                    client()->driver(), form, false);
 
   // Do not notify the store observer after this GetLogins call.
-  EXPECT_CALL(*mock_store(), GetLogins(_, _, _));
-  form_manager.FetchDataFromPasswordStore(PasswordStore::DISALLOW_PROMPT);
+  EXPECT_CALL(*mock_store(), GetLogins(_, _));
+  form_manager.FetchDataFromPasswordStore();
 
   PasswordForm submitted_form(form);
   submitted_form.password_value += ASCIIToUTF16("add stuff, make it different");
   form_manager.ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   base::HistogramTester histogram_tester;
   EXPECT_CALL(*mock_store(), RemoveLogin(_)).Times(0);
   form_manager.WipeStoreCopyIfOutdated();
   histogram_tester.ExpectUniqueSample("PasswordManager.StoreReadyWhenWiping", 0,
                                       1);
 }
 
 TEST_F(PasswordFormManagerTest, WipeStoreCopyIfOutdated_NotOutdated) {
   PasswordForm form(*saved_match());
   form.username_value = ASCIIToUTF16("test@gmail.com");
   ASSERT_FALSE(form.password_value.empty());
 
   PasswordFormManager form_manager(password_manager(), client(),
                                    client()->driver(), form, false);
 
   // For GAIA authentication, the first two usernames are equivalent to
   // test@gmail.com, but the third is not.
   PasswordForm form_related(form);
   form_related.username_value = ASCIIToUTF16("test@googlemail.com");
   PasswordForm form_related2(form);
   form_related2.username_value = ASCIIToUTF16("test");
   PasswordForm form_unrelated(form);
   form_unrelated.username_value = ASCIIToUTF16("test.else");
-  EXPECT_CALL(*mock_store(), GetLogins(_, _, _))
-      .WillOnce(testing::WithArg<2>(
+  EXPECT_CALL(*mock_store(), GetLogins(_, _))
+      .WillOnce(testing::WithArg<1>(
           InvokeConsumer(form, form_related, form_related2, form_unrelated)));
-  form_manager.FetchDataFromPasswordStore(PasswordStore::DISALLOW_PROMPT);
+  form_manager.FetchDataFromPasswordStore();
 
   form_manager.ProvisionallySave(
       form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   base::HistogramTester histogram_tester;
   EXPECT_CALL(*mock_store(), RemoveLogin(_)).Times(0);
   form_manager.WipeStoreCopyIfOutdated();
   histogram_tester.ExpectUniqueSample("PasswordManager.StoreReadyWhenWiping", 1,
                                       1);
 }
 
 TEST_F(PasswordFormManagerTest, WipeStoreCopyIfOutdated_Outdated) {
   PasswordForm form(*saved_match());
   ASSERT_FALSE(form.password_value.empty());
 
   PasswordFormManager form_manager(password_manager(), client(),
                                    client()->driver(), form, false);
 
   // For GAIA authentication, the first two usernames are equivalent to
   // test@gmail.com, but the third is not.
   PasswordForm form_related(form);
   form_related.username_value = ASCIIToUTF16("test@googlemail.com");
   PasswordForm form_related2(form);
   form_related2.username_value = ASCIIToUTF16("test");
   PasswordForm form_unrelated(form);
   form_unrelated.username_value = ASCIIToUTF16("test.else");
-  EXPECT_CALL(*mock_store(), GetLogins(_, _, _))
-      .WillOnce(testing::WithArg<2>(
+  EXPECT_CALL(*mock_store(), GetLogins(_, _))
+      .WillOnce(testing::WithArg<1>(
           InvokeConsumer(form, form_related, form_related2, form_unrelated)));
-  form_manager.FetchDataFromPasswordStore(PasswordStore::DISALLOW_PROMPT);
+  form_manager.FetchDataFromPasswordStore();
 
   PasswordForm submitted_form(form);
   submitted_form.password_value += ASCIIToUTF16("add stuff, make it different");
   form_manager.ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   base::HistogramTester histogram_tester;
   EXPECT_CALL(*mock_store(), RemoveLogin(form));
   EXPECT_CALL(*mock_store(), RemoveLogin(form_related));
   EXPECT_CALL(*mock_store(), RemoveLogin(form_related2));
@@ skipping 134 matching lines @@
   EXPECT_CALL(*mock_store(), RemoveLogin(_)).Times(0);
   EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
               StartUploadRequest(_, false, _, _, true));
 
   form_manager()->ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   form_manager()->Save();
 }
 
 TEST_F(PasswordFormManagerTest, GenerationStatusChangedWithPassword) {
-  const PasswordStore::AuthorizationPromptPolicy auth_policy =
-      PasswordStore::DISALLOW_PROMPT;
-  EXPECT_CALL(*mock_store(),
-              GetLogins(*observed_form(), auth_policy, form_manager()));
-  form_manager()->FetchDataFromPasswordStore(auth_policy);
+  EXPECT_CALL(*mock_store(), GetLogins(*observed_form(), form_manager()));
+  form_manager()->FetchDataFromPasswordStore();
 
   scoped_ptr<PasswordForm> generated_form(new PasswordForm(*observed_form()));
   generated_form->type = PasswordForm::TYPE_GENERATED;
   generated_form->username_value = ASCIIToUTF16("username");
   generated_form->password_value = ASCIIToUTF16("password2");
   generated_form->preferred = true;
 
   PasswordForm submitted_form(*generated_form);
   submitted_form.password_value = ASCIIToUTF16("password3");
 
   ScopedVector<PasswordForm> simulated_results;
   simulated_results.push_back(std::move(generated_form));
   form_manager()->OnGetPasswordStoreResults(std::move(simulated_results));
 
   form_manager()->ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   PasswordForm new_credentials;
   EXPECT_CALL(*mock_store(), UpdateLogin(_))
       .WillOnce(testing::SaveArg<0>(&new_credentials));
   form_manager()->Save();
 
   EXPECT_EQ(PasswordForm::TYPE_MANUAL, new_credentials.type);
 }
 
 TEST_F(PasswordFormManagerTest, GenerationStatusNotUpdatedIfPasswordUnchanged) {
   base::HistogramTester histogram_tester;
 
-  const PasswordStore::AuthorizationPromptPolicy auth_policy =
-      PasswordStore::DISALLOW_PROMPT;
-  EXPECT_CALL(*mock_store(),
-              GetLogins(*observed_form(), auth_policy, form_manager()));
-  form_manager()->FetchDataFromPasswordStore(auth_policy);
+  EXPECT_CALL(*mock_store(), GetLogins(*observed_form(), form_manager()));
+  form_manager()->FetchDataFromPasswordStore();
 
   scoped_ptr<PasswordForm> generated_form(new PasswordForm(*observed_form()));
   generated_form->type = PasswordForm::TYPE_GENERATED;
   generated_form->username_value = ASCIIToUTF16("username");
   generated_form->password_value = ASCIIToUTF16("password2");
   generated_form->preferred = true;
 
   PasswordForm submitted_form(*generated_form);
 
   ScopedVector<PasswordForm> simulated_results;
   simulated_results.push_back(std::move(generated_form));
   form_manager()->OnGetPasswordStoreResults(std::move(simulated_results));
 
   form_manager()->ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   PasswordForm new_credentials;
   EXPECT_CALL(*mock_store(), UpdateLogin(_))
       .WillOnce(testing::SaveArg<0>(&new_credentials));
   form_manager()->Save();
 
   EXPECT_EQ(PasswordForm::TYPE_GENERATED, new_credentials.type);
   histogram_tester.ExpectBucketCount("PasswordGeneration.SubmissionEvent",
                                      metrics_util::PASSWORD_USED, 1);
 }
 
 TEST_F(PasswordFormManagerTest,
        FetchMatchingLoginsFromPasswordStore_Reentrance) {
-  const PasswordStore::AuthorizationPromptPolicy auth_policy =
-      PasswordStore::DISALLOW_PROMPT;
-  EXPECT_CALL(*mock_store(), GetLogins(form_manager()->observed_form(),
-                                       auth_policy, form_manager()))
+  EXPECT_CALL(*mock_store(),
+              GetLogins(form_manager()->observed_form(), form_manager()))
       .Times(2);
-  form_manager()->FetchDataFromPasswordStore(auth_policy);
-  form_manager()->FetchDataFromPasswordStore(auth_policy);
+  form_manager()->FetchDataFromPasswordStore();
+  form_manager()->FetchDataFromPasswordStore();
 
   // First response from the store, should be ignored.
   scoped_ptr<PasswordForm> saved_form(new PasswordForm(*saved_match()));
   saved_form->username_value = ASCIIToUTF16("a@gmail.com");
   ScopedVector<PasswordForm> results;
   results.push_back(std::move(saved_form));
   form_manager()->OnGetPasswordStoreResults(std::move(results));
   EXPECT_TRUE(form_manager()->best_matches().empty());
 
   // Second response from the store should not be ignored.
@@ skipping 27 matching lines @@
   form_manager()->ProcessFrame(second_driver.AsWeakPtr());
 }
 
 TEST_F(PasswordFormManagerTest, ProcessFrame_DriverBeforeMatching) {
   NiceMock<MockPasswordManagerDriver> extra_driver;
 
   EXPECT_CALL(extra_driver, FillPasswordForm(_));
 
   // Ask store for logins, but store should not respond yet.
   EXPECT_CALL(*mock_store(),
-              GetLogins(form_manager()->observed_form(), _, form_manager()));
-  form_manager()->FetchDataFromPasswordStore(PasswordStore::DISALLOW_PROMPT);
+              GetLogins(form_manager()->observed_form(), form_manager()));
+  form_manager()->FetchDataFromPasswordStore();
 
   // Now add the extra driver.
   form_manager()->ProcessFrame(extra_driver.AsWeakPtr());
 
   // Password store responds.
   scoped_ptr<PasswordForm> match(new PasswordForm(*saved_match()));
   ScopedVector<PasswordForm> result_form;
   result_form.push_back(std::move(match));
   form_manager()->OnGetPasswordStoreResults(std::move(result_form));
 }
 
 TEST_F(PasswordFormManagerTest, ProcessFrame_StoreUpdatesCausesAutofill) {
   EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_)).Times(2);
   SimulateMatchingPhase(form_manager(), RESULT_SAVED_MATCH);
   SimulateMatchingPhase(form_manager(), RESULT_SAVED_MATCH);
 }
 
 TEST_F(PasswordFormManagerTest, UpdateFormManagers_IsCalled) {
   // Let |password_manager()| create one additional PasswordFormManager.
   PasswordStoreConsumer* consumer = nullptr;  // Will point to the new PFM.
-  EXPECT_CALL(*mock_store(), GetLogins(_, _, _))
-      .WillOnce(SaveArg<2>(&consumer));
+  EXPECT_CALL(*mock_store(), GetLogins(_, _)).WillOnce(SaveArg<1>(&consumer));
   PasswordForm form;
   std::vector<PasswordForm> observed;
   observed.push_back(form);
   password_manager()->OnPasswordFormsParsed(client()->mock_driver(), observed);
   // Make sure that the additional PFM is in POST_MATCHING phase.
   ASSERT_TRUE(consumer);
   consumer->OnGetPasswordStoreResults(ScopedVector<PasswordForm>());
 
   // Now prepare |form_manager()| for saving.
   SimulateMatchingPhase(form_manager(), RESULT_NO_MATCH);
   PasswordForm saved_form(*observed_form());
   saved_form.preferred = true;
   form_manager()->ProvisionallySave(
       saved_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   // Firing Save() should cause PasswordManager::UpdateFormManagers to make the
   // additional PFM to call the password store again.
-  EXPECT_CALL(*mock_store(), GetLogins(_, _, _));
+  EXPECT_CALL(*mock_store(), GetLogins(_, _));
   form_manager()->Save();
 }
 
 TEST_F(PasswordFormManagerTest, UploadChangePasswordForm_NEW_PASSWORD) {
   ChangePasswordUploadTest(autofill::NEW_PASSWORD);
 }
 
 TEST_F(PasswordFormManagerTest,
        UploadChangePasswordForm_PROBABLY_NEW_PASSWORD) {
   ChangePasswordUploadTest(autofill::PROBABLY_NEW_PASSWORD);
@@ skipping 154 matching lines @@
 
   EXPECT_EQ(credentials.password_value, new_credentials.password_value);
   EXPECT_EQ(credentials.username_value, new_credentials.username_value);
   EXPECT_EQ(credentials.password_element, new_credentials.password_element);
   EXPECT_EQ(credentials.username_element, new_credentials.username_element);
   EXPECT_EQ(credentials.origin, new_credentials.origin);
 }
 
 #if !defined(OS_IOS) && !defined(OS_ANDROID)
 TEST_F(PasswordFormManagerTest, FetchStatistics) {
-  const PasswordStore::AuthorizationPromptPolicy auth_policy =
-      PasswordStore::DISALLOW_PROMPT;
   InteractionsStats stats;
   stats.origin_domain = observed_form()->origin.GetOrigin();
   stats.username_value = saved_match()->username_value;
   stats.dismissal_count = 5;
-  EXPECT_CALL(*mock_store(),
-              GetLogins(*observed_form(), auth_policy, form_manager()));
+  EXPECT_CALL(*mock_store(), GetLogins(*observed_form(), form_manager()));
   std::vector<InteractionsStats*> db_stats;
   db_stats.push_back(new InteractionsStats(stats));
   EXPECT_CALL(*mock_store(), GetSiteStatsMock(stats.origin_domain))
       .WillOnce(Return(db_stats));
-  form_manager()->FetchDataFromPasswordStore(auth_policy);
+  form_manager()->FetchDataFromPasswordStore();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(form_manager()->interactions_stats(),
               ElementsAre(Pointee(stats)));
 }
 #else
 TEST_F(PasswordFormManagerTest, DontFetchStatistics) {
-  const PasswordStore::AuthorizationPromptPolicy auth_policy =
-      PasswordStore::DISALLOW_PROMPT;
-  EXPECT_CALL(*mock_store(),
-              GetLogins(*observed_form(), auth_policy, form_manager()));
+  EXPECT_CALL(*mock_store(), GetLogins(*observed_form(), form_manager()));
   EXPECT_CALL(*mock_store(), GetSiteStatsMock(_)).Times(0);
-  form_manager()->FetchDataFromPasswordStore(auth_policy);
+  form_manager()->FetchDataFromPasswordStore();
   base::RunLoop().RunUntilIdle();
 }
 #endif
 
 TEST_F(PasswordFormManagerTest,
        TestSavingOnChangePasswordFormGenerationNoStoredForms) {
   client()->set_is_update_password_ui_enabled(true);
   SimulateMatchingPhase(form_manager(), RESULT_NO_MATCH);
   form_manager()->set_has_generated_password(true);
 
@@ skipping 216 matching lines @@
   Mock::VerifyAndClearExpectations(mock_store());
 
   EXPECT_EQ(saved_match()->username_value + ASCIIToUTF16("1"),
             new_credentials.username_value);
   EXPECT_EQ(saved_match()->password_value, new_credentials.password_value);
   EXPECT_EQ(base::string16(), new_credentials.username_element);
   EXPECT_EQ(autofill::PasswordForm::TYPE_API, new_credentials.type);
 }
 
 }  // namespace password_manager