Rename requireUserMediation to preventSilentAccess in the CM API.

components/password_manager/content/browser/credential_manager_impl_unittest.cc

 // Copyright 2014 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/content/browser/credential_manager_impl.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <tuple>
@@ skipping 338 matching lines @@
   }
 
   CredentialManagerImpl* cm_service_impl() { return cm_service_impl_.get(); }
 
   // Helpers for testing CredentialManagerImpl methods.
   void CallStore(const CredentialInfo& info,
                  CredentialManagerImpl::StoreCallback callback) {
     cm_service_impl_->Store(info, std::move(callback));
   }
 
-  void CallRequireUserMediation(
-      CredentialManagerImpl::RequireUserMediationCallback callback) {
-    cm_service_impl_->RequireUserMediation(std::move(callback));
+  void CallPreventSilentAccess(
+      CredentialManagerImpl::PreventSilentAccessCallback callback) {
+    cm_service_impl_->PreventSilentAccess(std::move(callback));
   }
 
   void CallGet(CredentialMediationRequirement mediation,
                bool include_passwords,
                const std::vector<GURL>& federations,
                CredentialManagerImpl::GetCallback callback) {
     cm_service_impl_->Get(mediation, include_passwords, federations,
                           std::move(callback));
   }
 
@@ skipping 332 matching lines @@
 
   bool called = false;
   CallStore(info, base::Bind(&RespondCallback, &called));
 
   RunAllPendingTasks();
 
   EXPECT_TRUE(called);
   EXPECT_FALSE(client_->pending_manager());
 }
 
-TEST_F(CredentialManagerImplTest, CredentialManagerOnRequireUserMediation) {
+TEST_F(CredentialManagerImplTest, CredentialManagerOnPreventSilentAccess) {
   store_->AddLogin(form_);
   store_->AddLogin(subdomain_form_);
   store_->AddLogin(cross_origin_form_);
   RunAllPendingTasks();
 
   TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
   EXPECT_EQ(3U, passwords.size());
   EXPECT_EQ(1U, passwords[form_.signon_realm].size());
   EXPECT_EQ(1U, passwords[subdomain_form_.signon_realm].size());
   EXPECT_EQ(1U, passwords[cross_origin_form_.signon_realm].size());
   EXPECT_FALSE(passwords[form_.signon_realm][0].skip_zero_click);
   EXPECT_FALSE(passwords[subdomain_form_.signon_realm][0].skip_zero_click);
   EXPECT_FALSE(passwords[cross_origin_form_.signon_realm][0].skip_zero_click);
 
   bool called = false;
-  CallRequireUserMediation(base::Bind(&RespondCallback, &called));
+  CallPreventSilentAccess(base::Bind(&RespondCallback, &called));
 
   RunAllPendingTasks();
 
   EXPECT_TRUE(called);
 
   passwords = store_->stored_passwords();
   EXPECT_EQ(3U, passwords.size());
   EXPECT_EQ(1U, passwords[form_.signon_realm].size());
   EXPECT_EQ(1U, passwords[subdomain_form_.signon_realm].size());
   EXPECT_EQ(1U, passwords[cross_origin_form_.signon_realm].size());
   EXPECT_TRUE(passwords[form_.signon_realm][0].skip_zero_click);
   EXPECT_TRUE(passwords[subdomain_form_.signon_realm][0].skip_zero_click);
   EXPECT_FALSE(passwords[cross_origin_form_.signon_realm][0].skip_zero_click);
 }
 
 TEST_F(CredentialManagerImplTest,
-       CredentialManagerOnRequireUserMediationIncognito) {
+       CredentialManagerOnPreventSilentAccessIncognito) {
   EXPECT_CALL(*client_, IsSavingAndFillingEnabledForCurrentPage())
       .WillRepeatedly(testing::Return(false));
   store_->AddLogin(form_);
   RunAllPendingTasks();
 
   TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
   ASSERT_EQ(1U, passwords.size());
   ASSERT_EQ(1U, passwords[form_.signon_realm].size());
   EXPECT_FALSE(passwords[form_.signon_realm][0].skip_zero_click);
 
   bool called = false;
-  CallRequireUserMediation(base::Bind(&RespondCallback, &called));
+  CallPreventSilentAccess(base::Bind(&RespondCallback, &called));
   RunAllPendingTasks();
 
   EXPECT_TRUE(called);
 
   passwords = store_->stored_passwords();
   ASSERT_EQ(1U, passwords.size());
   ASSERT_EQ(1U, passwords[form_.signon_realm].size());
   EXPECT_FALSE(passwords[form_.signon_realm][0].skip_zero_click);
 }
 
 TEST_F(CredentialManagerImplTest,
-       CredentialManagerOnRequireUserMediationWithAffiliation) {
+       CredentialManagerOnPreventSilentAccessWithAffiliation) {
   store_->AddLogin(form_);
   store_->AddLogin(cross_origin_form_);
   store_->AddLogin(affiliated_form1_);
   store_->AddLogin(affiliated_form2_);
 
   auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   std::vector<std::string> affiliated_realms;
   affiliated_realms.push_back(kTestAndroidRealm1);
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(
           cm_service_impl_->GetSynthesizedFormForOrigin(), affiliated_realms);
   RunAllPendingTasks();
 
   TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
   EXPECT_EQ(4U, passwords.size());
   EXPECT_FALSE(passwords[form_.signon_realm][0].skip_zero_click);
   EXPECT_FALSE(passwords[cross_origin_form_.signon_realm][0].skip_zero_click);
   EXPECT_FALSE(passwords[affiliated_form1_.signon_realm][0].skip_zero_click);
   EXPECT_FALSE(passwords[affiliated_form2_.signon_realm][0].skip_zero_click);
 
   bool called = false;
-  CallRequireUserMediation(base::Bind(&RespondCallback, &called));
+  CallPreventSilentAccess(base::Bind(&RespondCallback, &called));
   RunAllPendingTasks();
 
   passwords = store_->stored_passwords();
   EXPECT_EQ(4U, passwords.size());
   EXPECT_TRUE(passwords[form_.signon_realm][0].skip_zero_click);
   EXPECT_FALSE(passwords[cross_origin_form_.signon_realm][0].skip_zero_click);
   EXPECT_TRUE(passwords[affiliated_form1_.signon_realm][0].skip_zero_click);
   EXPECT_FALSE(passwords[affiliated_form2_.signon_realm][0].skip_zero_click);
 }
 
@@ skipping 814 matching lines @@
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(_));
   CallStore(info, base::Bind(&RespondCallback, &called));
   // Allow the PasswordFormManager to talk to the password store
   RunAllPendingTasks();
 
   ASSERT_TRUE(client_->pending_manager());
   EXPECT_TRUE(client_->pending_manager()->IsBlacklisted());
 }
 
 }  // namespace password_manager