Deprecate CredentialRequestOptions.unmediated in favor mediation enum

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 274 matching lines @@
     EXPECT_TRUE(store_->IsEmpty());
   }
 
   void TearDown() override {
     cm_service_impl_.reset();
 
     store_->ShutdownOnUIThread();
     content::RenderViewHostTestHarness::TearDown();
   }
 
-  void ExpectZeroClickSignInFailure(bool zero_click_only,
+  void ExpectZeroClickSignInFailure(CredentialMediationRequirement mediation,
                                     bool include_passwords,
                                     const std::vector<GURL>& federations) {
     bool called = false;
     mojom::CredentialManagerError error;
     base::Optional<CredentialInfo> credential;
-    CallGet(zero_click_only, include_passwords, federations,
-            base::Bind(&GetCredentialCallback, &called, &error, &credential));
     EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
         .Times(testing::Exactly(0));
     EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
+    CallGet(mediation, include_passwords, federations,
+            base::Bind(&GetCredentialCallback, &called, &error, &credential));
 
     RunAllPendingTasks();
 
     EXPECT_TRUE(called);
     EXPECT_EQ(mojom::CredentialManagerError::SUCCESS, error);
     EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, credential->type);
   }
 
-  void ExpectZeroClickSignInSuccess(bool zero_click_only,
+  void ExpectZeroClickSignInSuccess(CredentialMediationRequirement mediation,
                                     bool include_passwords,
                                     const std::vector<GURL>& federations,
                                     CredentialType type) {
     bool called = false;
     mojom::CredentialManagerError error;
     base::Optional<CredentialInfo> credential;
-    CallGet(zero_click_only, include_passwords, federations,
-            base::Bind(&GetCredentialCallback, &called, &error, &credential));
     EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
         .Times(testing::Exactly(0));
     EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(1));
+    CallGet(mediation, include_passwords, federations,
+            base::Bind(&GetCredentialCallback, &called, &error, &credential));
 
     RunAllPendingTasks();
 
     EXPECT_TRUE(called);
     EXPECT_EQ(mojom::CredentialManagerError::SUCCESS, error);
     EXPECT_EQ(type, credential->type);
   }
 
-  void ExpectCredentialType(bool zero_click_only,
+  void ExpectCredentialType(CredentialMediationRequirement mediation,
                             bool include_passwords,
                             const std::vector<GURL>& federations,
                             CredentialType type) {
     bool called = false;
     mojom::CredentialManagerError error;
     base::Optional<CredentialInfo> credential;
-    CallGet(zero_click_only, include_passwords, federations,
+    CallGet(mediation, include_passwords, federations,
             base::Bind(&GetCredentialCallback, &called, &error, &credential));
 
     RunAllPendingTasks();
 
     EXPECT_TRUE(called);
     EXPECT_EQ(mojom::CredentialManagerError::SUCCESS, error);
     EXPECT_EQ(type, credential->type);
   }
 
   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 CallGet(bool zero_click_only,
+  void CallGet(CredentialMediationRequirement mediation,
                bool include_passwords,
                const std::vector<GURL>& federations,
                CredentialManagerImpl::GetCallback callback) {
-    cm_service_impl_->Get(zero_click_only, include_passwords, federations,
+    cm_service_impl_->Get(mediation, include_passwords, federations,
                           std::move(callback));
   }
 
  protected:
   autofill::PasswordForm form_;
   autofill::PasswordForm affiliated_form1_;
   autofill::PasswordForm affiliated_form2_;
   autofill::PasswordForm origin_path_form_;
   autofill::PasswordForm subdomain_form_;
   autofill::PasswordForm cross_origin_form_;
@@ skipping 294 matching lines @@
   RunAllPendingTasks();
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
       .Times(testing::Exactly(1));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
 
   bool called = false;
   mojom::CredentialManagerError error;
   base::Optional<CredentialInfo> credential;
-  CallGet(false, true, federations,
+  CallGet(CredentialMediationRequirement::kOptional, true, federations,
           base::Bind(&GetCredentialCallback, &called, &error, &credential));
 
   RunAllPendingTasks();
 
   EXPECT_TRUE(called);
   EXPECT_EQ(mojom::CredentialManagerError::SUCCESS, error);
 
   // Verify that the update toggled the skip_zero_click flag.
   TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
   EXPECT_FALSE(passwords[form_.signon_realm][0].skip_zero_click);
@@ skipping 112 matching lines @@
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialWithEmptyPasswordStore) {
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(_))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
 
-  ExpectCredentialType(false, true, federations,
-                       CredentialType::CREDENTIAL_TYPE_EMPTY);
+  ExpectCredentialType(CredentialMediationRequirement::kOptional, true,
+                       federations, CredentialType::CREDENTIAL_TYPE_EMPTY);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialWithEmptyUsernames) {
   form_.username_value.clear();
   store_->AddLogin(form_);
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
 
   std::vector<GURL> federations;
-  ExpectCredentialType(false, true, federations,
-                       CredentialType::CREDENTIAL_TYPE_EMPTY);
+  ExpectCredentialType(CredentialMediationRequirement::kOptional, true,
+                       federations, CredentialType::CREDENTIAL_TYPE_EMPTY);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialWithPSLCredential) {
   store_->AddLogin(subdomain_form_);
   subdomain_form_.is_public_suffix_match = true;
   EXPECT_CALL(*client_,
               PromptUserToChooseCredentialsPtr(
                   UnorderedElementsAre(Pointee(subdomain_form_)), _, _));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(0);
 
-  ExpectCredentialType(false, true, std::vector<GURL>(),
+  ExpectCredentialType(CredentialMediationRequirement::kOptional, true,
+                       std::vector<GURL>(),
                        CredentialType::CREDENTIAL_TYPE_PASSWORD);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialWithPSLAndNormalCredentials) {
   store_->AddLogin(form_);
   store_->AddLogin(origin_path_form_);
   store_->AddLogin(subdomain_form_);
 
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(
                             UnorderedElementsAre(Pointee(origin_path_form_),
                                                  Pointee(form_)),
                             _, _));
 
-  ExpectCredentialType(false, true, std::vector<GURL>(),
+  ExpectCredentialType(CredentialMediationRequirement::kOptional, true,
+                       std::vector<GURL>(),
                        CredentialType::CREDENTIAL_TYPE_PASSWORD);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialWithEmptyAndNonemptyUsernames) {
   store_->AddLogin(form_);
   autofill::PasswordForm empty = form_;
   empty.username_value.clear();
   store_->AddLogin(empty);
   autofill::PasswordForm duplicate = form_;
   duplicate.username_element = base::ASCIIToUTF16("different_username_element");
   store_->AddLogin(duplicate);
 
   std::vector<GURL> federations;
-  ExpectZeroClickSignInSuccess(false, true, federations,
+  ExpectZeroClickSignInSuccess(CredentialMediationRequirement::kOptional, true,
+                               federations,
                                CredentialType::CREDENTIAL_TYPE_PASSWORD);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialWithDuplicates) {
   // Add 6 credentials. Two buckets of duplicates, one empty username and one
   // federated one. There should be just 3 in the account chooser.
   form_.preferred = true;
   form_.username_element = base::ASCIIToUTF16("username_element");
   store_->AddLogin(form_);
@@ skipping 22 matching lines @@
                             UnorderedElementsAre(Pointee(form_),
                                                  Pointee(origin_path_form_),
                                                  Pointee(federated)),
                             _, _));
 
   bool called = false;
   mojom::CredentialManagerError error;
   base::Optional<CredentialInfo> credential;
   std::vector<GURL> federations;
   federations.push_back(GURL("https://google.com/"));
-  CallGet(false, true, federations,
+  CallGet(CredentialMediationRequirement::kOptional, true, federations,
           base::Bind(&GetCredentialCallback, &called, &error, &credential));
 
   RunAllPendingTasks();
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialWithCrossOriginPasswordStore) {
   store_->AddLogin(cross_origin_form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(_))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
 
-  ExpectCredentialType(false, true, federations,
-                       CredentialType::CREDENTIAL_TYPE_EMPTY);
+  ExpectCredentialType(CredentialMediationRequirement::kOptional, true,
+                       federations, CredentialType::CREDENTIAL_TYPE_EMPTY);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialWithFullPasswordStore) {
   client_->set_zero_click_enabled(false);
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
       .Times(testing::Exactly(1));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
 
   bool called = false;
   mojom::CredentialManagerError error;
   base::Optional<CredentialInfo> credential;
-  CallGet(false, true, federations,
+  CallGet(CredentialMediationRequirement::kOptional, true, federations,
           base::Bind(&GetCredentialCallback, &called, &error, &credential));
 
   RunAllPendingTasks();
 
   EXPECT_TRUE(called);
   EXPECT_EQ(mojom::CredentialManagerError::SUCCESS, error);
 }
 
 TEST_F(
     CredentialManagerImplTest,
     CredentialManagerOnRequestCredentialWithZeroClickOnlyEmptyPasswordStore) {
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
 
-  ExpectZeroClickSignInFailure(true, true, federations);
+  ExpectZeroClickSignInFailure(CredentialMediationRequirement::kSilent, true,
+                               federations);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialWithZeroClickOnlyFullPasswordStore) {
   store_->AddLogin(form_);
   client_->set_first_run_seen(true);
 
   std::vector<GURL> federations;
 
   EXPECT_CALL(*client_, NotifyUserCouldBeAutoSignedInPtr(_)).Times(0);
 
-  ExpectZeroClickSignInSuccess(true, true, federations,
+  ExpectZeroClickSignInSuccess(CredentialMediationRequirement::kSilent, true,
+                               federations,
                                CredentialType::CREDENTIAL_TYPE_PASSWORD);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialWithoutPasswords) {
   store_->AddLogin(form_);
   client_->set_first_run_seen(true);
 
   std::vector<GURL> federations;
 
   EXPECT_CALL(*client_, NotifyUserCouldBeAutoSignedInPtr(_)).Times(0);
 
-  ExpectZeroClickSignInFailure(true, false, federations);
+  ExpectZeroClickSignInFailure(CredentialMediationRequirement::kSilent, false,
+                               federations);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialFederatedMatch) {
   form_.federation_origin = url::Origin(GURL("https://example.com/"));
   form_.password_value = base::string16();
   store_->AddLogin(form_);
   client_->set_first_run_seen(true);
 
   std::vector<GURL> federations;
   federations.push_back(GURL("https://example.com/"));
 
   EXPECT_CALL(*client_, NotifyUserCouldBeAutoSignedInPtr(_)).Times(0);
 
-  ExpectZeroClickSignInSuccess(true, true, federations,
+  ExpectZeroClickSignInSuccess(CredentialMediationRequirement::kSilent, true,
+                               federations,
                                CredentialType::CREDENTIAL_TYPE_FEDERATED);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialFederatedNoMatch) {
   form_.federation_origin = url::Origin(GURL("https://example.com/"));
   form_.password_value = base::string16();
   store_->AddLogin(form_);
   client_->set_first_run_seen(true);
 
   std::vector<GURL> federations;
   federations.push_back(GURL("https://not-example.com/"));
 
   EXPECT_CALL(*client_, NotifyUserCouldBeAutoSignedInPtr(_)).Times(0);
 
-  ExpectZeroClickSignInFailure(true, true, federations);
+  ExpectZeroClickSignInFailure(CredentialMediationRequirement::kSilent, true,
+                               federations);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialAffiliatedPasswordMatch) {
   store_->AddLogin(affiliated_form1_);
   client_->set_first_run_seen(true);
   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);
 
   // We pass in 'true' for the 'include_passwords' argument to ensure that
   // password-type credentials are included as potential matches.
-  ExpectZeroClickSignInSuccess(true, true, federations,
+  ExpectZeroClickSignInSuccess(CredentialMediationRequirement::kSilent, true,
+                               federations,
                                CredentialType::CREDENTIAL_TYPE_PASSWORD);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialAffiliatedPasswordNoMatch) {
   store_->AddLogin(affiliated_form1_);
   client_->set_first_run_seen(true);
   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);
 
   // We pass in 'false' for the 'include_passwords' argument to ensure that
   // password-type credentials are excluded as potential matches.
-  ExpectZeroClickSignInFailure(true, false, federations);
+  ExpectZeroClickSignInFailure(CredentialMediationRequirement::kSilent, false,
+                               federations);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialAffiliatedFederatedMatch) {
   affiliated_form1_.federation_origin =
       url::Origin(GURL("https://example.com/"));
   affiliated_form1_.password_value = base::string16();
   store_->AddLogin(affiliated_form1_);
   client_->set_first_run_seen(true);
   auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   federations.push_back(GURL("https://example.com/"));
 
   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);
 
-  ExpectZeroClickSignInSuccess(true, true, federations,
+  ExpectZeroClickSignInSuccess(CredentialMediationRequirement::kSilent, true,
+                               federations,
                                CredentialType::CREDENTIAL_TYPE_FEDERATED);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialAffiliatedFederatedNoMatch) {
   affiliated_form1_.federation_origin =
       url::Origin(GURL("https://example.com/"));
   affiliated_form1_.password_value = base::string16();
   store_->AddLogin(affiliated_form1_);
   client_->set_first_run_seen(true);
   auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   federations.push_back(GURL("https://not-example.com/"));
 
   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);
 
-  ExpectZeroClickSignInFailure(true, true, federations);
+  ExpectZeroClickSignInFailure(CredentialMediationRequirement::kSilent, true,
+                               federations);
 }
 
 TEST_F(CredentialManagerImplTest, RequestCredentialWithoutFirstRun) {
   client_->set_first_run_seen(false);
 
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_,
               NotifyUserCouldBeAutoSignedInPtr(testing::Pointee(form_)))
       .Times(1);
 
-  ExpectZeroClickSignInFailure(true, true, federations);
+  ExpectZeroClickSignInFailure(CredentialMediationRequirement::kSilent, true,
+                               federations);
 }
 
 TEST_F(CredentialManagerImplTest, RequestCredentialWithFirstRunAndSkip) {
   client_->set_first_run_seen(true);
 
   form_.skip_zero_click = true;
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_,
               NotifyUserCouldBeAutoSignedInPtr(testing::Pointee(form_)))
       .Times(1);
 
-  ExpectZeroClickSignInFailure(true, true, federations);
+  ExpectZeroClickSignInFailure(CredentialMediationRequirement::kSilent, true,
+                               federations);
 }
 
 TEST_F(CredentialManagerImplTest, RequestCredentialWithTLSErrors) {
   // If we encounter TLS errors, we won't return credentials.
   EXPECT_CALL(*client_, IsFillingEnabledForCurrentPage())
       .WillRepeatedly(testing::Return(false));
 
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
 
-  ExpectZeroClickSignInFailure(true, true, federations);
+  ExpectZeroClickSignInFailure(CredentialMediationRequirement::kSilent, true,
+                               federations);
 }
 
 TEST_F(CredentialManagerImplTest, RequestCredentialWhilePrerendering) {
   // The client disallows the credential manager for the current page.
   EXPECT_CALL(*client_, OnCredentialManagerUsed())
       .WillRepeatedly(testing::Return(false));
 
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
 
-  ExpectZeroClickSignInFailure(true, true, federations);
+  ExpectZeroClickSignInFailure(CredentialMediationRequirement::kSilent, true,
+                               federations);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialWithZeroClickOnlyTwoPasswordStore) {
   store_->AddLogin(form_);
   store_->AddLogin(origin_path_form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
 
   // With two items in the password store, we shouldn't get credentials back.
-  ExpectCredentialType(true, true, federations,
-                       CredentialType::CREDENTIAL_TYPE_EMPTY);
+  ExpectCredentialType(CredentialMediationRequirement::kSilent, true,
+                       federations, CredentialType::CREDENTIAL_TYPE_EMPTY);
 }
 
 TEST_F(CredentialManagerImplTest,
        OnRequestCredentialWithZeroClickOnlyAndSkipZeroClickPasswordStore) {
   form_.skip_zero_click = true;
   store_->AddLogin(form_);
   store_->AddLogin(origin_path_form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
 
   // With two items in the password store, we shouldn't get credentials back,
   // even though only one item has |skip_zero_click| set |false|.
-  ExpectCredentialType(true, true, federations,
-                       CredentialType::CREDENTIAL_TYPE_EMPTY);
+  ExpectCredentialType(CredentialMediationRequirement::kSilent, true,
+                       federations, CredentialType::CREDENTIAL_TYPE_EMPTY);
 }
 
 TEST_F(CredentialManagerImplTest,
        OnRequestCredentialWithZeroClickOnlyCrossOriginPasswordStore) {
   store_->AddLogin(cross_origin_form_);
 
   form_.skip_zero_click = true;
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
 
   // We only have cross-origin zero-click credentials; they should not be
   // returned.
-  ExpectCredentialType(true, true, federations,
-                       CredentialType::CREDENTIAL_TYPE_EMPTY);
+  ExpectCredentialType(CredentialMediationRequirement::kSilent, true,
+                       federations, CredentialType::CREDENTIAL_TYPE_EMPTY);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialWhileRequestPending) {
   client_->set_zero_click_enabled(false);
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
 
   // 1st request.
   bool called_1 = false;
   mojom::CredentialManagerError error_1;
   base::Optional<CredentialInfo> credential_1;
   CallGet(
-      false, true, federations,
+      CredentialMediationRequirement::kOptional, true, federations,
       base::Bind(&GetCredentialCallback, &called_1, &error_1, &credential_1));
   // 2nd request.
   bool called_2 = false;
   mojom::CredentialManagerError error_2;
   base::Optional<CredentialInfo> credential_2;
   CallGet(
-      false, true, federations,
+      CredentialMediationRequirement::kOptional, true, federations,
       base::Bind(&GetCredentialCallback, &called_2, &error_2, &credential_2));
 
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
       .Times(testing::Exactly(1));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
 
   // Execute the PasswordStore asynchronousness.
   RunAllPendingTasks();
 
   // Check that the second request triggered a rejection.
@@ skipping 36 matching lines @@
   // MockPasswordManagerClient mocks a user choice, and when users choose a
   // credential (and have the global zero-click flag enabled), we make sure that
   // they'll be logged in again next time.
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
       .Times(testing::Exactly(1));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
 
   bool called = false;
   mojom::CredentialManagerError error;
   base::Optional<CredentialInfo> credential;
-  CallGet(false, true, federations,
+  CallGet(CredentialMediationRequirement::kOptional, true, federations,
           base::Bind(&GetCredentialCallback, &called, &error, &credential));
 
   RunAllPendingTasks();
 
   passwords = store_->stored_passwords();
   EXPECT_EQ(2U, passwords.size());
   EXPECT_EQ(1U, passwords[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_TRUE(passwords[cross_origin_form_.signon_realm][0].skip_zero_click);
@@ skipping 15 matching lines @@
 
   // Trigger a request which should return the credential found in |form_|, and
   // wait for it to process.
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
       .Times(testing::Exactly(1));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
 
   bool called = false;
   mojom::CredentialManagerError error;
   base::Optional<CredentialInfo> credential;
-  CallGet(false, true, std::vector<GURL>(),
+  CallGet(CredentialMediationRequirement::kOptional, true, std::vector<GURL>(),
           base::Bind(&GetCredentialCallback, &called, &error, &credential));
 
   RunAllPendingTasks();
 
   // The form shouldn't become a zero-click one.
   passwords = store_->stored_passwords();
   ASSERT_EQ(1U, passwords.size());
   ASSERT_EQ(1U, passwords[form_.signon_realm].size());
   EXPECT_TRUE(passwords[form_.signon_realm][0].skip_zero_click);
 }
 
 TEST_F(CredentialManagerImplTest, IncognitoZeroClickRequestCredential) {
   EXPECT_CALL(*client_, IsIncognito()).WillRepeatedly(testing::Return(true));
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
 
-  ExpectCredentialType(true, true, federations,
-                       CredentialType::CREDENTIAL_TYPE_EMPTY);
+  ExpectCredentialType(CredentialMediationRequirement::kSilent, true,
+                       federations, CredentialType::CREDENTIAL_TYPE_EMPTY);
 }
 
 TEST_F(CredentialManagerImplTest, ZeroClickWithAffiliatedFormInPasswordStore) {
   // Insert the affiliated form into the store, and mock out the association
   // with the current origin. As it's the only form matching the origin, it
   // ought to be returned automagically.
   store_->AddLogin(affiliated_form1_);
 
   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);
 
-  ExpectZeroClickSignInSuccess(true, true, federations,
+  ExpectZeroClickSignInSuccess(CredentialMediationRequirement::kSilent, true,
+                               federations,
                                CredentialType::CREDENTIAL_TYPE_PASSWORD);
 }
 
 TEST_F(CredentialManagerImplTest,
        ZeroClickWithTwoAffiliatedFormsInPasswordStore) {
   // Insert two affiliated forms into the store, and mock out the association
   // with the current origin. Multiple forms === no zero-click sign in.
   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);
   affiliated_realms.push_back(kTestAndroidRealm2);
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(
           cm_service_impl_->GetSynthesizedFormForOrigin(), affiliated_realms);
 
-  ExpectZeroClickSignInFailure(true, true, federations);
+  ExpectZeroClickSignInFailure(CredentialMediationRequirement::kSilent, true,
+                               federations);
 }
 
 TEST_F(CredentialManagerImplTest,
        ZeroClickWithUnaffiliatedFormsInPasswordStore) {
   // Insert the affiliated form into the store, but don't mock out the
   // association with the current origin. No association === no zero-click sign
   // in.
   store_->AddLogin(affiliated_form1_);
 
   store_->SetAffiliatedMatchHelper(
       base::MakeUnique<MockAffiliatedMatchHelper>());
 
   std::vector<std::string> affiliated_realms;
   PasswordStore::FormDigest digest =
       cm_service_impl_->GetSynthesizedFormForOrigin();
   // First expect affiliations for the HTTPS domain.
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(digest, affiliated_realms);
 
   digest.origin = HttpURLFromHttps(digest.origin);
   digest.signon_realm = digest.origin.spec();
   // The second call happens for HTTP as the migration is triggered.
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(digest, affiliated_realms);
 
   std::vector<GURL> federations;
-  ExpectZeroClickSignInFailure(true, true, federations);
+  ExpectZeroClickSignInFailure(CredentialMediationRequirement::kSilent, true,
+                               federations);
 }
 
 TEST_F(CredentialManagerImplTest,
        ZeroClickWithFormAndUnaffiliatedFormsInPasswordStore) {
   // Insert the affiliated form into the store, along with a real form for the
   // origin, and don't mock out the association with the current origin. No
   // association + existing form === zero-click sign in.
   store_->AddLogin(form_);
   store_->AddLogin(affiliated_form1_);
 
   auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   std::vector<std::string> affiliated_realms;
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(
           cm_service_impl_->GetSynthesizedFormForOrigin(), affiliated_realms);
 
-  ExpectZeroClickSignInSuccess(true, true, federations,
+  ExpectZeroClickSignInSuccess(CredentialMediationRequirement::kSilent, true,
+                               federations,
                                CredentialType::CREDENTIAL_TYPE_PASSWORD);
 }
 
 TEST_F(CredentialManagerImplTest, ZeroClickWithPSLCredential) {
   subdomain_form_.skip_zero_click = false;
   store_->AddLogin(subdomain_form_);
 
-  ExpectZeroClickSignInFailure(true, true, std::vector<GURL>());
+  ExpectZeroClickSignInFailure(CredentialMediationRequirement::kSilent, true,
+                               std::vector<GURL>());
 }
 
 TEST_F(CredentialManagerImplTest, ZeroClickWithPSLAndNormalCredentials) {
   form_.password_value.clear();
   form_.federation_origin = url::Origin(GURL("https://google.com/"));
   form_.signon_realm = "federation://" + form_.origin.host() + "/google.com";
   form_.skip_zero_click = false;
   store_->AddLogin(form_);
   store_->AddLogin(subdomain_form_);
 
   std::vector<GURL> federations = {GURL("https://google.com/")};
-  ExpectZeroClickSignInSuccess(true, true, federations,
+  ExpectZeroClickSignInSuccess(CredentialMediationRequirement::kSilent, true,
+                               federations,
                                CredentialType::CREDENTIAL_TYPE_FEDERATED);
 }
 
 TEST_F(CredentialManagerImplTest, ZeroClickAfterMigratingHttpCredential) {
   // There is an http credential saved. It should be migrated and used for auto
   // sign-in.
   form_.origin = HttpURLFromHttps(form_.origin);
   form_.signon_realm = form_.origin.GetOrigin().spec();
   // That is the default value for old credentials.
   form_.skip_zero_click = true;
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
-  ExpectZeroClickSignInSuccess(true, true, federations,
+  ExpectZeroClickSignInSuccess(CredentialMediationRequirement::kSilent, true,
+                               federations,
                                CredentialType::CREDENTIAL_TYPE_PASSWORD);
 }
 
 TEST_F(CredentialManagerImplTest, MigrateWithEmptyStore) {
   // HTTP scheme is valid for localhost. Nothing should crash.
   NavigateAndCommit(GURL("http://127.0.0.1:8000/"));
 
   std::vector<GURL> federations;
-  ExpectZeroClickSignInFailure(false, true, federations);
+  ExpectZeroClickSignInFailure(CredentialMediationRequirement::kOptional, true,
+                               federations);
+}
+
+TEST_F(CredentialManagerImplTest, MediationRequiredPreventsAutoSignIn) {
+  form_.skip_zero_click = false;
+  store_->AddLogin(form_);
+
+  std::vector<GURL> federations;
+  bool called = false;
+  mojom::CredentialManagerError error;
+  base::Optional<CredentialInfo> credential;
+
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _))
+      .Times(testing::Exactly(1));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr()).Times(testing::Exactly(0));
+  CallGet(CredentialMediationRequirement::kRequired, true, federations,
+          base::Bind(&GetCredentialCallback, &called, &error, &credential));
+
+  RunAllPendingTasks();
+
+  EXPECT_TRUE(called);
+  EXPECT_EQ(mojom::CredentialManagerError::SUCCESS, error);
+  EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_PASSWORD, credential->type);
 }
 
 TEST_F(CredentialManagerImplTest, GetSynthesizedFormForOrigin) {
   PasswordStore::FormDigest synthesized =
       cm_service_impl_->GetSynthesizedFormForOrigin();
   EXPECT_EQ(kTestWebOrigin, synthesized.origin.spec());
   EXPECT_EQ(kTestWebOrigin, synthesized.signon_realm);
   EXPECT_EQ(autofill::PasswordForm::SCHEME_HTML, synthesized.scheme);
 }
 
@@ skipping 86 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