Deprecate CredentialRequestOptions.unmediated in favor mediation enum

components/password_manager/core/browser/credential_manager_pending_request_task.cc

 // Copyright 2015 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/credential_manager_pending_request_task.h"
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 #include <utility>
@@ skipping 95 matching lines @@
   size_before = forms->size();
   FilterDuplicates(forms);
   *has_duplicates = (size_before != forms->size());
 }
 
 }  // namespace
 
 CredentialManagerPendingRequestTask::CredentialManagerPendingRequestTask(
     CredentialManagerPendingRequestTaskDelegate* delegate,
     const SendCredentialCallback& callback,
-    bool request_zero_click_only,
+    CredentialMediationRequirement mediation,
     bool include_passwords,
     const std::vector<GURL>& request_federations)
     : delegate_(delegate),
       send_callback_(callback),
-      zero_click_only_(request_zero_click_only),
+      mediation_(mediation),
       origin_(delegate_->GetOrigin()),
       include_passwords_(include_passwords) {
   CHECK(!delegate_->client()->DidLastPageLoadEncounterSSLErrors());
   for (const GURL& federation : request_federations)
     federations_.insert(url::Origin(federation.GetOrigin()).Serialize());
 }
 
 CredentialManagerPendingRequestTask::~CredentialManagerPendingRequestTask() =
     default;
 
@@ skipping 10 matching lines @@
 }
 
 void CredentialManagerPendingRequestTask::ProcessMigratedForms(
     std::vector<std::unique_ptr<autofill::PasswordForm>> forms) {
   ProcessForms(std::move(forms));
 }
 
 void CredentialManagerPendingRequestTask::ProcessForms(
     std::vector<std::unique_ptr<autofill::PasswordForm>> results) {
   using metrics_util::LogCredentialManagerGetResult;
-  metrics_util::CredentialManagerGetMediation mediation_status =
-      zero_click_only_ ? metrics_util::CREDENTIAL_MANAGER_GET_UNMEDIATED
-                       : metrics_util::CREDENTIAL_MANAGER_GET_MEDIATED;
   if (delegate_->GetOrigin() != origin_) {
     LogCredentialManagerGetResult(metrics_util::CREDENTIAL_MANAGER_GET_NONE,
-                                  mediation_status);
+                                  mediation_);
     delegate_->SendCredential(send_callback_, CredentialInfo());
     return;
   }
 
   std::vector<std::unique_ptr<autofill::PasswordForm>> local_results;
   std::vector<std::unique_ptr<autofill::PasswordForm>> psl_results;
   for (auto& form : results) {
     // Ensure that the form we're looking at matches the password and
     // federation filters provided.
     if (!((form->federation_origin.unique() && include_passwords_) ||
@@ skipping 12 matching lines @@
     } else if (form->is_public_suffix_match) {
       psl_results.push_back(std::move(form));
     }
   }
 
   bool has_empty_username = false;
   bool has_duplicates = false;
   FilterDuplicatesAndEmptyUsername(&local_results, &has_empty_username,
                                    &has_duplicates);
 
-  // We only perform zero-click sign-in when the result is completely
-  // unambigious. If there is one and only one entry, and zero-click is
+  // We only perform zero-click sign-in when it is not forbidden via the
+  // mediation requirement and the result is completely unambigious.
+  // If there is one and only one entry, and zero-click is
   // enabled for that entry, return it.
   //
   // Moreover, we only return such a credential if the user has opted-in via the
   // first-run experience.
   const bool can_use_autosignin =
+      mediation_ != CredentialMediationRequirement::kRequired &&
       local_results.size() == 1u && delegate_->IsZeroClickAllowed();
   if (can_use_autosignin && !local_results[0]->skip_zero_click &&
       !password_bubble_experiment::ShouldShowAutoSignInPromptFirstRunExperience(
           delegate_->client()->GetPrefs())) {
     CredentialInfo info(*local_results[0],
                         local_results[0]->federation_origin.unique()
                             ? CredentialType::CREDENTIAL_TYPE_PASSWORD
                             : CredentialType::CREDENTIAL_TYPE_FEDERATED);
     delegate_->client()->NotifyUserAutoSignin(std::move(local_results),
                                               origin_);
     base::RecordAction(base::UserMetricsAction("CredentialManager_Autosignin"));
     LogCredentialManagerGetResult(
-        metrics_util::CREDENTIAL_MANAGER_GET_AUTOSIGNIN, mediation_status);
+        metrics_util::CREDENTIAL_MANAGER_GET_AUTOSIGNIN, mediation_);
     delegate_->SendCredential(send_callback_, info);
     return;
   }
 
-  if (zero_click_only_) {
+  if (mediation_ == CredentialMediationRequirement::kSilent) {
     metrics_util::CredentialManagerGetResult get_result;
     if (local_results.empty())
       get_result = metrics_util::CREDENTIAL_MANAGER_GET_NONE_EMPTY_STORE;
     else if (!can_use_autosignin)
       get_result = metrics_util::CREDENTIAL_MANAGER_GET_NONE_MANY_CREDENTIALS;
     else if (local_results[0]->skip_zero_click)
       get_result = metrics_util::CREDENTIAL_MANAGER_GET_NONE_SIGNED_OUT;
     else
       get_result = metrics_util::CREDENTIAL_MANAGER_GET_NONE_FIRST_RUN;
 
     if (can_use_autosignin) {
       // The user had credentials, but either chose not to share them with the
       // site, or was prevented from doing so by lack of zero-click (or the
       // first-run experience). So, notify the client that we could potentially
       // have used zero-click.
       delegate_->client()->NotifyUserCouldBeAutoSignedIn(
           std::move(local_results[0]));
     }
 
-    LogCredentialManagerGetResult(get_result, mediation_status);
+    LogCredentialManagerGetResult(get_result, mediation_);
     delegate_->SendCredential(send_callback_, CredentialInfo());
     return;
   }
 
   // Time to show the account chooser. If |local_results| is empty then it
   // should list the PSL matches.
   if (local_results.empty()) {
     local_results = std::move(psl_results);
     FilterDuplicatesAndEmptyUsername(&local_results, &has_empty_username,
                                      &has_duplicates);
   }
 
   if (local_results.empty()) {
     LogCredentialManagerGetResult(
-        metrics_util::CREDENTIAL_MANAGER_GET_NONE_EMPTY_STORE,
-        mediation_status);
+        metrics_util::CREDENTIAL_MANAGER_GET_NONE_EMPTY_STORE, mediation_);
     delegate_->SendCredential(send_callback_, CredentialInfo());
     return;
   }
 
   ReportAccountChooserUsabilityMetrics(local_results, has_duplicates,
                                        has_empty_username);
   if (!delegate_->client()->PromptUserToChooseCredentials(
           std::move(local_results), origin_,
           base::Bind(
               &CredentialManagerPendingRequestTaskDelegate::SendPasswordForm,
-              base::Unretained(delegate_), send_callback_))) {
+              base::Unretained(delegate_), send_callback_, mediation_))) {
     LogCredentialManagerGetResult(metrics_util::CREDENTIAL_MANAGER_GET_NONE,
-                                  mediation_status);
+                                  mediation_);
     delegate_->SendCredential(send_callback_, CredentialInfo());
   }
 }
 
 }  // namespace password_manager