Deprecate CredentialRequestOptions.unmediated in favor mediation enum

components/password_manager/content/browser/credential_manager_impl.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 <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/user_metrics.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/password_manager/content/browser/content_password_manager_driver.h"
 #include "components/password_manager/content/browser/content_password_manager_driver_factory.h"
 #include "components/password_manager/core/browser/affiliated_match_helper.h"
 #include "components/password_manager/core/browser/credential_manager_logger.h"
 #include "components/password_manager/core/browser/form_fetcher_impl.h"
 #include "components/password_manager/core/browser/form_saver.h"
 #include "components/password_manager/core/browser/password_manager_client.h"
 #include "components/password_manager/core/browser/password_manager_metrics_util.h"
 #include "components/password_manager/core/browser/password_manager_util.h"
 #include "components/password_manager/core/browser/password_store.h"
-#include "components/password_manager/core/common/credential_manager_types.h"
 #include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "content/public/browser/web_contents.h"
 
 namespace password_manager {
 
 namespace {
 
 void RunMojoGetCallback(mojom::CredentialManager::GetCallback callback,
                         const CredentialInfo& info) {
   std::move(callback).Run(mojom::CredentialManagerError::SUCCESS, info);
@@ skipping 103 matching lines @@
       !client_->OnCredentialManagerUsed())
     return;
 
   if (!pending_require_user_mediation_) {
     pending_require_user_mediation_.reset(
         new CredentialManagerPendingRequireUserMediationTask(this));
   }
   pending_require_user_mediation_->AddOrigin(GetSynthesizedFormForOrigin());
 }
 
-void CredentialManagerImpl::Get(bool zero_click_only,
+void CredentialManagerImpl::Get(CredentialMediationRequirement mediation,
                                 bool include_passwords,
                                 const std::vector<GURL>& federations,
                                 GetCallback callback) {
   using metrics_util::LogCredentialManagerGetResult;
-  metrics_util::CredentialManagerGetMediation mediation_status =
-      zero_click_only ? metrics_util::CREDENTIAL_MANAGER_GET_UNMEDIATED
-                      : metrics_util::CREDENTIAL_MANAGER_GET_MEDIATED;
+
   PasswordStore* store = GetPasswordStore();
   if (password_manager_util::IsLoggingActive(client_)) {
     CredentialManagerLogger(client_->GetLogManager())
-        .LogRequestCredential(web_contents()->GetLastCommittedURL(),
-                              zero_click_only, federations);
+        .LogRequestCredential(web_contents()->GetLastCommittedURL(), mediation,
+                              federations);
   }
   if (pending_request_ || !store) {
     // Callback error.
     std::move(callback).Run(
         pending_request_
             ? mojom::CredentialManagerError::PENDINGREQUEST
             : mojom::CredentialManagerError::PASSWORDSTOREUNAVAILABLE,
         base::nullopt);
     LogCredentialManagerGetResult(metrics_util::CREDENTIAL_MANAGER_GET_REJECTED,
-                                  mediation_status);
+                                  mediation);
     return;
   }
 
   // Return an empty credential if the current page has TLS errors, or if the
   // page is being prerendered.
   if (!client_->IsFillingEnabledForCurrentPage() ||
       !client_->OnCredentialManagerUsed()) {
     std::move(callback).Run(mojom::CredentialManagerError::SUCCESS,
                             CredentialInfo());
     LogCredentialManagerGetResult(metrics_util::CREDENTIAL_MANAGER_GET_NONE,
-                                  mediation_status);
+                                  mediation);
     return;
   }
   // Return an empty credential if zero-click is required but disabled.
-  if (zero_click_only && !IsZeroClickAllowed()) {
+  if (mediation == CredentialMediationRequirement::kSilent &&
+      !IsZeroClickAllowed()) {
     // Callback with empty credential info.
     std::move(callback).Run(mojom::CredentialManagerError::SUCCESS,
                             CredentialInfo());
     LogCredentialManagerGetResult(
-        metrics_util::CREDENTIAL_MANAGER_GET_NONE_ZERO_CLICK_OFF,
-        mediation_status);
+        metrics_util::CREDENTIAL_MANAGER_GET_NONE_ZERO_CLICK_OFF, mediation);
     return;
   }
 
   pending_request_.reset(new CredentialManagerPendingRequestTask(
-      this, base::Bind(&RunMojoGetCallback, base::Passed(&callback)),
-      zero_click_only, include_passwords, federations));
+      this, base::Bind(&RunMojoGetCallback, base::Passed(&callback)), mediation,
+      include_passwords, federations));
   // This will result in a callback to
   // PendingRequestTask::OnGetPasswordStoreResults().
   GetPasswordStore()->GetLogins(GetSynthesizedFormForOrigin(),
                                 pending_request_.get());
 }
 
 bool CredentialManagerImpl::IsZeroClickAllowed() const {
   return *auto_signin_enabled_ && !client_->IsIncognito();
 }
 
@@ skipping 19 matching lines @@
   if (password_manager_util::IsLoggingActive(client_)) {
     CredentialManagerLogger(client_->GetLogManager())
         .LogSendCredential(web_contents()->GetLastCommittedURL(), info.type);
   }
   send_callback.Run(info);
   pending_request_.reset();
 }
 
 void CredentialManagerImpl::SendPasswordForm(
     const SendCredentialCallback& send_callback,
+    CredentialMediationRequirement mediation,
     const autofill::PasswordForm* form) {
   CredentialInfo info;
   if (form) {
     password_manager::CredentialType type_to_return =
         form->federation_origin.unique()
             ? CredentialType::CREDENTIAL_TYPE_PASSWORD
             : CredentialType::CREDENTIAL_TYPE_FEDERATED;
     info = CredentialInfo(*form, type_to_return);
     if (PasswordStore* store = GetPasswordStore()) {
       if (form->skip_zero_click && IsZeroClickAllowed()) {
         autofill::PasswordForm update_form = *form;
         update_form.skip_zero_click = false;
         store->UpdateLogin(update_form);
       }
     }
     base::RecordAction(
         base::UserMetricsAction("CredentialManager_AccountChooser_Accepted"));
     metrics_util::LogCredentialManagerGetResult(
-        metrics_util::CREDENTIAL_MANAGER_GET_ACCOUNT_CHOOSER,
-        metrics_util::CREDENTIAL_MANAGER_GET_MEDIATED);
+        metrics_util::CREDENTIAL_MANAGER_GET_ACCOUNT_CHOOSER, mediation);
   } else {
     base::RecordAction(
         base::UserMetricsAction("CredentialManager_AccountChooser_Dismissed"));
     metrics_util::LogCredentialManagerGetResult(
-        metrics_util::CREDENTIAL_MANAGER_GET_NONE,
-        metrics_util::CREDENTIAL_MANAGER_GET_MEDIATED);
+        metrics_util::CREDENTIAL_MANAGER_GET_NONE, mediation);
   }
   SendCredential(send_callback, info);
 }
 
 PasswordManagerClient* CredentialManagerImpl::client() const {
   return client_;
 }
 
 PasswordStore* CredentialManagerImpl::GetPasswordStore() {
   return client_ ? client_->GetPasswordStore() : nullptr;
 }
 
 void CredentialManagerImpl::DoneRequiringUserMediation() {
   DCHECK(pending_require_user_mediation_);
   pending_require_user_mediation_.reset();
 }
 
 PasswordStore::FormDigest CredentialManagerImpl::GetSynthesizedFormForOrigin()
     const {
   PasswordStore::FormDigest digest = {
       autofill::PasswordForm::SCHEME_HTML, std::string(),
       web_contents()->GetLastCommittedURL().GetOrigin()};
   digest.signon_realm = digest.origin.spec();
   return digest;
 }
 
 }  // namespace password_manager