sheet_models.cc | Explore in Territory

// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/ui/webauthn/sheet_models.h"

#include <cstddef>
#include <memory>
#include <optional>
#include <string>
#include <utility>

#include "base/check.h"
#include "base/check_op.h"
#include "base/memory/ptr_util.h"
#include "base/notreached.h"
#include "base/ranges/algorithm.h"
#include "base/strings/utf_string_conversions.h"
#include "build/build_config.h"
#include "chrome/app/vector_icons/vector_icons.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/profiles/profile_avatar_icon_util.h"
#include "chrome/browser/ui/webauthn/user_actions.h"
#include "chrome/browser/ui/webauthn/webauthn_ui_helpers.h"
#include "chrome/browser/webauthn/authenticator_request_dialog_model.h"
#include "chrome/grit/browser_resources.h"
#include "chrome/grit/generated_resources.h"
#include "components/signin/public/identity_manager/account_info.h"
#include "components/strings/grit/components_strings.h"
#include "content/public/browser/render_frame_host.h"
#include "device/fido/discoverable_credential_metadata.h"
#include "device/fido/fido_constants.h"
#include "device/fido/fido_types.h"
#include "device/fido/pin.h"
#include "third_party/abseil-cpp/absl/types/variant.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/resource/resource_bundle.h"

#if BUILDFLAG(IS_MAC)
#include "base/mac/mac_util.h"
#include "crypto/scoped_lacontext.h"
#include "device/fido/mac/util.h"
#endif

namespace {

CredentialMech;
EnclaveMech;
ICloudKeychainMech;
Step;

constexpr int kGpmArbitraryPinMinLength = …;

bool IsLocalPasskeyOrEnclaveAuthenticator(
    const AuthenticatorRequestDialogModel::Mechanism& mech) { … }

// Possibly returns a resident key warning if the model indicates that it's
// needed.
std::u16string PossibleResidentKeyWarning(
    AuthenticatorRequestDialogModel* dialog_model) { … }

}  // namespace

// AuthenticatorSheetModelBase ------------------------------------------------

AuthenticatorSheetModelBase::AuthenticatorSheetModelBase(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorSheetModelBase::AuthenticatorSheetModelBase(
    AuthenticatorRequestDialogModel* dialog_model,
    OtherMechanismButtonVisibility other_mechanism_button_visibility)
    : … { … }

AuthenticatorSheetModelBase::~AuthenticatorSheetModelBase() { … }

// static
std::u16string AuthenticatorSheetModelBase::GetRelyingPartyIdString(
    const AuthenticatorRequestDialogModel* dialog_model) { … }

bool AuthenticatorSheetModelBase::IsActivityIndicatorVisible() const { … }

bool AuthenticatorSheetModelBase::IsCancelButtonVisible() const { … }

bool AuthenticatorSheetModelBase::IsOtherMechanismButtonVisible() const { … }

std::u16string AuthenticatorSheetModelBase::GetOtherMechanismButtonLabel()
    const { … }

std::u16string AuthenticatorSheetModelBase::GetCancelButtonLabel() const { … }

bool AuthenticatorSheetModelBase::IsAcceptButtonVisible() const { … }

bool AuthenticatorSheetModelBase::IsAcceptButtonEnabled() const { … }

std::u16string AuthenticatorSheetModelBase::GetAcceptButtonLabel() const { … }

void AuthenticatorSheetModelBase::OnBack() { … }

void AuthenticatorSheetModelBase::OnAccept() { … }

void AuthenticatorSheetModelBase::OnCancel() { … }

void AuthenticatorSheetModelBase::OnModelDestroyed(
    AuthenticatorRequestDialogModel* model) { … }

// AuthenticatorMechanismSelectorSheetModel -----------------------------------

AuthenticatorMechanismSelectorSheetModel::
    AuthenticatorMechanismSelectorSheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

std::u16string AuthenticatorMechanismSelectorSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorMechanismSelectorSheetModel::GetStepDescription()
    const { … }

// AuthenticatorInsertAndActivateUsbSheetModel ----------------------

AuthenticatorInsertAndActivateUsbSheetModel::
    AuthenticatorInsertAndActivateUsbSheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

bool AuthenticatorInsertAndActivateUsbSheetModel::IsActivityIndicatorVisible()
    const { … }

std::u16string AuthenticatorInsertAndActivateUsbSheetModel::GetStepTitle()
    const { … }

std::u16string AuthenticatorInsertAndActivateUsbSheetModel::GetStepDescription()
    const { … }

std::u16string
AuthenticatorInsertAndActivateUsbSheetModel::GetAdditionalDescription() const { … }

// AuthenticatorTimeoutErrorModel ---------------------------------------------

AuthenticatorTimeoutErrorModel::AuthenticatorTimeoutErrorModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

std::u16string AuthenticatorTimeoutErrorModel::GetCancelButtonLabel() const { … }

std::u16string AuthenticatorTimeoutErrorModel::GetStepTitle() const { … }

std::u16string AuthenticatorTimeoutErrorModel::GetStepDescription() const { … }

// AuthenticatorNoAvailableTransportsErrorModel -------------------------------

AuthenticatorNoAvailableTransportsErrorModel::
    AuthenticatorNoAvailableTransportsErrorModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

std::u16string
AuthenticatorNoAvailableTransportsErrorModel::GetCancelButtonLabel() const { … }

std::u16string AuthenticatorNoAvailableTransportsErrorModel::GetStepTitle()
    const { … }

std::u16string
AuthenticatorNoAvailableTransportsErrorModel::GetStepDescription() const { … }

// AuthenticatorNoPasskeysErrorModel ------------------------------------------

AuthenticatorNoPasskeysErrorModel::AuthenticatorNoPasskeysErrorModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

std::u16string AuthenticatorNoPasskeysErrorModel::GetCancelButtonLabel() const { … }
std::u16string AuthenticatorNoPasskeysErrorModel::GetStepTitle() const { … }

std::u16string AuthenticatorNoPasskeysErrorModel::GetStepDescription() const { … }

// AuthenticatorNotRegisteredErrorModel ---------------------------------------

AuthenticatorNotRegisteredErrorModel::AuthenticatorNotRegisteredErrorModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

std::u16string AuthenticatorNotRegisteredErrorModel::GetCancelButtonLabel()
    const { … }

bool AuthenticatorNotRegisteredErrorModel::IsAcceptButtonVisible() const { … }

std::u16string AuthenticatorNotRegisteredErrorModel::GetAcceptButtonLabel()
    const { … }

std::u16string AuthenticatorNotRegisteredErrorModel::GetStepTitle() const { … }

std::u16string AuthenticatorNotRegisteredErrorModel::GetStepDescription()
    const { … }

void AuthenticatorNotRegisteredErrorModel::OnAccept() { … }

// AuthenticatorAlreadyRegisteredErrorModel -----------------------------------

AuthenticatorAlreadyRegisteredErrorModel::
    AuthenticatorAlreadyRegisteredErrorModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

std::u16string AuthenticatorAlreadyRegisteredErrorModel::GetCancelButtonLabel()
    const { … }

bool AuthenticatorAlreadyRegisteredErrorModel::IsAcceptButtonVisible() const { … }

std::u16string AuthenticatorAlreadyRegisteredErrorModel::GetAcceptButtonLabel()
    const { … }

std::u16string AuthenticatorAlreadyRegisteredErrorModel::GetStepTitle() const { … }

std::u16string AuthenticatorAlreadyRegisteredErrorModel::GetStepDescription()
    const { … }

void AuthenticatorAlreadyRegisteredErrorModel::OnAccept() { … }

// AuthenticatorInternalUnrecognizedErrorSheetModel ---------------------------

AuthenticatorInternalUnrecognizedErrorSheetModel::
    AuthenticatorInternalUnrecognizedErrorSheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

bool AuthenticatorInternalUnrecognizedErrorSheetModel::IsAcceptButtonVisible()
    const { … }

std::u16string
AuthenticatorInternalUnrecognizedErrorSheetModel::GetAcceptButtonLabel() const { … }

std::u16string AuthenticatorInternalUnrecognizedErrorSheetModel::GetStepTitle()
    const { … }

std::u16string
AuthenticatorInternalUnrecognizedErrorSheetModel::GetStepDescription() const { … }

void AuthenticatorInternalUnrecognizedErrorSheetModel::OnAccept() { … }

// AuthenticatorBlePowerOnManualSheetModel ------------------------------------

AuthenticatorBlePowerOnManualSheetModel::
    AuthenticatorBlePowerOnManualSheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

std::u16string AuthenticatorBlePowerOnManualSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorBlePowerOnManualSheetModel::GetStepDescription()
    const { … }

bool AuthenticatorBlePowerOnManualSheetModel::IsAcceptButtonVisible() const { … }

bool AuthenticatorBlePowerOnManualSheetModel::IsAcceptButtonEnabled() const { … }

std::u16string AuthenticatorBlePowerOnManualSheetModel::GetAcceptButtonLabel()
    const { … }

void AuthenticatorBlePowerOnManualSheetModel::OnBluetoothPoweredStateChanged() { … }

void AuthenticatorBlePowerOnManualSheetModel::OnAccept() { … }

// AuthenticatorBlePowerOnAutomaticSheetModel
// ------------------------------------

AuthenticatorBlePowerOnAutomaticSheetModel::
    AuthenticatorBlePowerOnAutomaticSheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

bool AuthenticatorBlePowerOnAutomaticSheetModel::IsActivityIndicatorVisible()
    const { … }

std::u16string AuthenticatorBlePowerOnAutomaticSheetModel::GetStepTitle()
    const { … }

std::u16string AuthenticatorBlePowerOnAutomaticSheetModel::GetStepDescription()
    const { … }

bool AuthenticatorBlePowerOnAutomaticSheetModel::IsAcceptButtonVisible() const { … }

bool AuthenticatorBlePowerOnAutomaticSheetModel::IsAcceptButtonEnabled() const { … }

std::u16string
AuthenticatorBlePowerOnAutomaticSheetModel::GetAcceptButtonLabel() const { … }

void AuthenticatorBlePowerOnAutomaticSheetModel::OnAccept() { … }

#if BUILDFLAG(IS_MAC)

// AuthenticatorBlePermissionMacSheetModel
// ------------------------------------

AuthenticatorBlePermissionMacSheetModel::
    AuthenticatorBlePermissionMacSheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : AuthenticatorSheetModelBase(dialog_model,
                                  OtherMechanismButtonVisibility::kVisible) {
  vector_illustrations_.emplace(kPasskeyErrorBluetoothIcon,
                                kPasskeyErrorBluetoothDarkIcon);
}

std::u16string AuthenticatorBlePermissionMacSheetModel::GetStepTitle() const {
  // An empty title causes the title View to be omitted.
  return u"";
}

std::u16string AuthenticatorBlePermissionMacSheetModel::GetStepDescription()
    const {
  return l10n_util::GetStringUTF16(IDS_WEBAUTHN_BLUETOOTH_PERMISSION);
}

bool AuthenticatorBlePermissionMacSheetModel::IsAcceptButtonVisible() const {
  return true;
}

bool AuthenticatorBlePermissionMacSheetModel::IsCancelButtonVisible() const {
  return true;
}

std::u16string AuthenticatorBlePermissionMacSheetModel::GetAcceptButtonLabel()
    const {
  return l10n_util::GetStringUTF16(IDS_OPEN_SETTINGS_LINK);
}

void AuthenticatorBlePermissionMacSheetModel::OnAccept() {
  dialog_model()->OpenBlePreferences();
}

// AuthenticatorTouchIdSheetModel
// ------------------------------------

AuthenticatorTouchIdSheetModel::AuthenticatorTouchIdSheetModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : AuthenticatorSheetModelBase(dialog_model,
                                  OtherMechanismButtonVisibility::kVisible) {
  webauthn::user_actions::RecordGpmTouchIdDialogShown(
      dialog_model->request_type == device::FidoRequestType::kMakeCredential);
}

std::u16string AuthenticatorTouchIdSheetModel::GetStepTitle() const {
  const std::u16string rp_id = GetRelyingPartyIdString(dialog_model());
  switch (dialog_model()->request_type) {
    case device::FidoRequestType::kMakeCredential:
      return l10n_util::GetStringFUTF16(IDS_WEBAUTHN_GPM_CREATE_PASSKEY_TITLE,
                                        rp_id);
    case device::FidoRequestType::kGetAssertion:
      return l10n_util::GetStringFUTF16(
          IDS_WEBAUTHN_CHOOSE_PASSKEY_FOR_RP_TITLE, rp_id);
  }
}

std::u16string AuthenticatorTouchIdSheetModel::GetStepDescription() const {
  switch (dialog_model()->request_type) {
    case device::FidoRequestType::kMakeCredential:
      return l10n_util::GetStringFUTF16(
          IDS_WEBAUTHN_GPM_CREATE_PASSKEY_DESC,
          base::UTF8ToUTF16(dialog_model()->GetGpmAccountEmail()));

    case device::FidoRequestType::kGetAssertion:
      return l10n_util::GetStringFUTF16(
          IDS_WEBAUTHN_TOUCH_ID_ASSERTION_DESC,
          GetRelyingPartyIdString(dialog_model()));
  }
}

bool AuthenticatorTouchIdSheetModel::IsAcceptButtonVisible() const {
  return !device::fido::mac::DeviceHasBiometricsAvailable();
}

bool AuthenticatorTouchIdSheetModel::IsCancelButtonVisible() const {
  return true;
}

std::u16string AuthenticatorTouchIdSheetModel::GetAcceptButtonLabel() const {
  return l10n_util::GetStringUTF16(IDS_WEBAUTHN_TOUCH_ID_ENTER_PASSWORD);
}

void AuthenticatorTouchIdSheetModel::OnAccept() {
  if (touch_id_completed_) {
    return;
  }
  webauthn::user_actions::RecordAcceptClick();
  touch_id_completed_ = true;
  dialog_model()->OnTouchIDComplete(false);
}

void AuthenticatorTouchIdSheetModel::OnTouchIDSensorTapped(
    std::optional<crypto::ScopedLAContext> lacontext) {
  // Ignore Touch ID ceremony status after the user has completed the ceremony.
  if (touch_id_completed_) {
    return;
  }
  if (!lacontext) {
    // Authentication failed. Update the button status and rebuild the sheet,
    // which will restart the Touch ID request if the sensor is not softlocked
    // or display a padlock icon if it is.
    dialog_model()->OnSheetModelChanged();
    return;
  }
  touch_id_completed_ = true;
  dialog_model()->lacontext = std::move(lacontext);
  dialog_model()->OnTouchIDComplete(true);
}

#endif  // IS_MAC

// AuthenticatorOffTheRecordInterstitialSheetModel
// -----------------------------------------

AuthenticatorOffTheRecordInterstitialSheetModel::
    AuthenticatorOffTheRecordInterstitialSheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

std::u16string AuthenticatorOffTheRecordInterstitialSheetModel::GetStepTitle()
    const { … }

std::u16string
AuthenticatorOffTheRecordInterstitialSheetModel::GetStepDescription() const { … }

bool AuthenticatorOffTheRecordInterstitialSheetModel::IsAcceptButtonVisible()
    const { … }

std::u16string
AuthenticatorOffTheRecordInterstitialSheetModel::GetAcceptButtonLabel() const { … }

void AuthenticatorOffTheRecordInterstitialSheetModel::OnAccept() { … }

std::u16string
AuthenticatorOffTheRecordInterstitialSheetModel::GetCancelButtonLabel() const { … }

// AuthenticatorPaaskSheetModel -----------------------------------------

AuthenticatorPaaskSheetModel::AuthenticatorPaaskSheetModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorPaaskSheetModel::~AuthenticatorPaaskSheetModel() = default;

bool AuthenticatorPaaskSheetModel::IsActivityIndicatorVisible() const { … }

std::u16string AuthenticatorPaaskSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorPaaskSheetModel::GetStepDescription() const { … }

bool AuthenticatorPaaskSheetModel::IsManageDevicesButtonVisible() const { … }

void AuthenticatorPaaskSheetModel::OnManageDevices() { … }

// AuthenticatorAndroidAccessorySheetModel ------------------------------------

AuthenticatorAndroidAccessorySheetModel::
    AuthenticatorAndroidAccessorySheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorAndroidAccessorySheetModel::
    ~AuthenticatorAndroidAccessorySheetModel() = default;

bool AuthenticatorAndroidAccessorySheetModel::IsActivityIndicatorVisible()
    const { … }

std::u16string AuthenticatorAndroidAccessorySheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorAndroidAccessorySheetModel::GetStepDescription()
    const { … }

// AuthenticatorClientPinEntrySheetModel
// -----------------------------------------

AuthenticatorClientPinEntrySheetModel::AuthenticatorClientPinEntrySheetModel(
    AuthenticatorRequestDialogModel* dialog_model,
    Mode mode,
    device::pin::PINEntryError error)
    : … { … }

AuthenticatorClientPinEntrySheetModel::
    ~AuthenticatorClientPinEntrySheetModel() = default;

void AuthenticatorClientPinEntrySheetModel::SetPinCode(
    std::u16string pin_code) { … }

void AuthenticatorClientPinEntrySheetModel::SetPinConfirmation(
    std::u16string pin_confirmation) { … }

std::u16string AuthenticatorClientPinEntrySheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorClientPinEntrySheetModel::GetStepDescription()
    const { … }

std::u16string AuthenticatorClientPinEntrySheetModel::GetError() const { … }

bool AuthenticatorClientPinEntrySheetModel::IsAcceptButtonVisible() const { … }

std::u16string AuthenticatorClientPinEntrySheetModel::GetAcceptButtonLabel()
    const { … }

void AuthenticatorClientPinEntrySheetModel::OnAccept() { … }

// AuthenticatorClientPinTapAgainSheetModel ----------------------

AuthenticatorClientPinTapAgainSheetModel::
    AuthenticatorClientPinTapAgainSheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorClientPinTapAgainSheetModel::
    ~AuthenticatorClientPinTapAgainSheetModel() = default;

bool AuthenticatorClientPinTapAgainSheetModel::IsActivityIndicatorVisible()
    const { … }

std::u16string AuthenticatorClientPinTapAgainSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorClientPinTapAgainSheetModel::GetStepDescription()
    const { … }

std::u16string
AuthenticatorClientPinTapAgainSheetModel::GetAdditionalDescription() const { … }

// AuthenticatorBioEnrollmentSheetModel ----------------------------------

// No illustration since the content already has a large animated
// fingerprint icon.
AuthenticatorBioEnrollmentSheetModel::AuthenticatorBioEnrollmentSheetModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorBioEnrollmentSheetModel::~AuthenticatorBioEnrollmentSheetModel() =
    default;

bool AuthenticatorBioEnrollmentSheetModel::IsActivityIndicatorVisible() const { … }

std::u16string AuthenticatorBioEnrollmentSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorBioEnrollmentSheetModel::GetStepDescription()
    const { … }

bool AuthenticatorBioEnrollmentSheetModel::IsAcceptButtonVisible() const { … }

std::u16string AuthenticatorBioEnrollmentSheetModel::GetAcceptButtonLabel()
    const { … }

bool AuthenticatorBioEnrollmentSheetModel::IsCancelButtonVisible() const { … }

std::u16string AuthenticatorBioEnrollmentSheetModel::GetCancelButtonLabel()
    const { … }

void AuthenticatorBioEnrollmentSheetModel::OnAccept() { … }

void AuthenticatorBioEnrollmentSheetModel::OnCancel() { … }

// AuthenticatorRetryUvSheetModel -------------------------------------

AuthenticatorRetryUvSheetModel::AuthenticatorRetryUvSheetModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorRetryUvSheetModel::~AuthenticatorRetryUvSheetModel() = default;

bool AuthenticatorRetryUvSheetModel::IsActivityIndicatorVisible() const { … }

std::u16string AuthenticatorRetryUvSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorRetryUvSheetModel::GetStepDescription() const { … }

std::u16string AuthenticatorRetryUvSheetModel::GetError() const { … }

// AuthenticatorGenericErrorSheetModel -----------------------------------

// static
std::unique_ptr<AuthenticatorGenericErrorSheetModel>
AuthenticatorGenericErrorSheetModel::ForClientPinErrorSoftBlock(
    AuthenticatorRequestDialogModel* dialog_model) { … }

// static
std::unique_ptr<AuthenticatorGenericErrorSheetModel>
AuthenticatorGenericErrorSheetModel::ForClientPinErrorHardBlock(
    AuthenticatorRequestDialogModel* dialog_model) { … }

// static
std::unique_ptr<AuthenticatorGenericErrorSheetModel>
AuthenticatorGenericErrorSheetModel::ForClientPinErrorAuthenticatorRemoved(
    AuthenticatorRequestDialogModel* dialog_model) { … }

// static
std::unique_ptr<AuthenticatorGenericErrorSheetModel>
AuthenticatorGenericErrorSheetModel::ForMissingCapability(
    AuthenticatorRequestDialogModel* dialog_model) { … }

// static
std::unique_ptr<AuthenticatorGenericErrorSheetModel>
AuthenticatorGenericErrorSheetModel::ForStorageFull(
    AuthenticatorRequestDialogModel* dialog_model) { … }

std::unique_ptr<AuthenticatorGenericErrorSheetModel>
AuthenticatorGenericErrorSheetModel::ForWindowsHelloNotEnabled(
    AuthenticatorRequestDialogModel* dialog_model) { … }

AuthenticatorGenericErrorSheetModel::AuthenticatorGenericErrorSheetModel(
    AuthenticatorRequestDialogModel* dialog_model,
    std::u16string title,
    std::u16string description)
    : … { … }

std::u16string AuthenticatorGenericErrorSheetModel::GetCancelButtonLabel()
    const { … }

bool AuthenticatorGenericErrorSheetModel::IsAcceptButtonVisible() const { … }

std::u16string AuthenticatorGenericErrorSheetModel::GetAcceptButtonLabel()
    const { … }

std::u16string AuthenticatorGenericErrorSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorGenericErrorSheetModel::GetStepDescription() const { … }

void AuthenticatorGenericErrorSheetModel::OnAccept() { … }

// AuthenticatorResidentCredentialConfirmationSheetView -----------------------

// TODO(crbug.com/40237082): Add more specific illustration once available. The
// "error" graphic is a large question mark, so it looks visually very similar.
AuthenticatorResidentCredentialConfirmationSheetView::
    AuthenticatorResidentCredentialConfirmationSheetView(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorResidentCredentialConfirmationSheetView::
    ~AuthenticatorResidentCredentialConfirmationSheetView() = default;

bool AuthenticatorResidentCredentialConfirmationSheetView::
    IsAcceptButtonVisible() const { … }

std::u16string
AuthenticatorResidentCredentialConfirmationSheetView::GetAcceptButtonLabel()
    const { … }

std::u16string
AuthenticatorResidentCredentialConfirmationSheetView::GetStepTitle() const { … }

std::u16string
AuthenticatorResidentCredentialConfirmationSheetView::GetStepDescription()
    const { … }

void AuthenticatorResidentCredentialConfirmationSheetView::OnAccept() { … }

// AuthenticatorSelectAccountSheetModel ---------------------------------------

AuthenticatorSelectAccountSheetModel::AuthenticatorSelectAccountSheetModel(
    AuthenticatorRequestDialogModel* dialog_model,
    UserVerificationMode mode,
    SelectionType type)
    : … { … }

AuthenticatorSelectAccountSheetModel::~AuthenticatorSelectAccountSheetModel() =
    default;

AuthenticatorSelectAccountSheetModel::SelectionType
AuthenticatorSelectAccountSheetModel::selection_type() const { … }

const device::DiscoverableCredentialMetadata&
AuthenticatorSelectAccountSheetModel::SingleCredential() const { … }

void AuthenticatorSelectAccountSheetModel::SetCurrentSelection(int selected) { … }

void AuthenticatorSelectAccountSheetModel::OnAccept() { … }

std::u16string AuthenticatorSelectAccountSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorSelectAccountSheetModel::GetStepDescription()
    const { … }

bool AuthenticatorSelectAccountSheetModel::IsAcceptButtonVisible() const { … }

std::u16string AuthenticatorSelectAccountSheetModel::GetAcceptButtonLabel()
    const { … }

// AttestationPermissionRequestSheetModel -------------------------------------

// TODO(crbug.com/40237082): Add more specific illustration once available.
AttestationPermissionRequestSheetModel::AttestationPermissionRequestSheetModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AttestationPermissionRequestSheetModel::
    ~AttestationPermissionRequestSheetModel() = default;

void AttestationPermissionRequestSheetModel::OnAccept() { … }

void AttestationPermissionRequestSheetModel::OnCancel() { … }

std::u16string AttestationPermissionRequestSheetModel::GetStepTitle() const { … }

std::u16string AttestationPermissionRequestSheetModel::GetStepDescription()
    const { … }

bool AttestationPermissionRequestSheetModel::IsAcceptButtonVisible() const { … }

std::u16string AttestationPermissionRequestSheetModel::GetAcceptButtonLabel()
    const { … }

bool AttestationPermissionRequestSheetModel::IsCancelButtonVisible() const { … }

std::u16string AttestationPermissionRequestSheetModel::GetCancelButtonLabel()
    const { … }

// EnterpriseAttestationPermissionRequestSheetModel ---------------------------

EnterpriseAttestationPermissionRequestSheetModel::
    EnterpriseAttestationPermissionRequestSheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

std::u16string EnterpriseAttestationPermissionRequestSheetModel::GetStepTitle()
    const { … }

std::u16string
EnterpriseAttestationPermissionRequestSheetModel::GetStepDescription() const { … }

// AuthenticatorQRSheetModel --------------------------------------------------

// No illustration since there already is the QR code.
AuthenticatorQRSheetModel::AuthenticatorQRSheetModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorQRSheetModel::~AuthenticatorQRSheetModel() = default;

std::u16string AuthenticatorQRSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorQRSheetModel::GetStepDescription() const { … }

bool AuthenticatorQRSheetModel::ShowSecurityKeyLabel() const { … }

std::u16string AuthenticatorQRSheetModel::GetSecurityKeyLabel() const { … }

// AuthenticatorConnectingSheetModel ------------------------------------------

AuthenticatorConnectingSheetModel::AuthenticatorConnectingSheetModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorConnectingSheetModel::~AuthenticatorConnectingSheetModel() =
    default;

std::u16string AuthenticatorConnectingSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorConnectingSheetModel::GetStepDescription() const { … }

// AuthenticatorConnectedSheetModel ------------------------------------------

AuthenticatorConnectedSheetModel::AuthenticatorConnectedSheetModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorConnectedSheetModel::~AuthenticatorConnectedSheetModel() = default;

bool AuthenticatorConnectedSheetModel::IsActivityIndicatorVisible() const { … }

std::u16string AuthenticatorConnectedSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorConnectedSheetModel::GetStepDescription() const { … }

// AuthenticatorCableErrorSheetModel ------------------------------------------

AuthenticatorCableErrorSheetModel::AuthenticatorCableErrorSheetModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorCableErrorSheetModel::~AuthenticatorCableErrorSheetModel() =
    default;

std::u16string AuthenticatorCableErrorSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorCableErrorSheetModel::GetStepDescription() const { … }

std::u16string AuthenticatorCableErrorSheetModel::GetCancelButtonLabel() const { … }

// AuthenticatorCreatePasskeySheetModel
// --------------------------------------------------

AuthenticatorCreatePasskeySheetModel::AuthenticatorCreatePasskeySheetModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorCreatePasskeySheetModel::~AuthenticatorCreatePasskeySheetModel() =
    default;

std::u16string AuthenticatorCreatePasskeySheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorCreatePasskeySheetModel::GetStepDescription()
    const { … }

std::u16string
AuthenticatorCreatePasskeySheetModel::passkey_storage_description() const { … }

bool AuthenticatorCreatePasskeySheetModel::IsAcceptButtonVisible() const { … }

std::u16string AuthenticatorCreatePasskeySheetModel::GetAcceptButtonLabel()
    const { … }

void AuthenticatorCreatePasskeySheetModel::OnAccept() { … }

// AuthenticatorGPMErrorSheetModel -------------------------------------------

AuthenticatorGPMErrorSheetModel::AuthenticatorGPMErrorSheetModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorGPMErrorSheetModel::~AuthenticatorGPMErrorSheetModel() = default;

std::u16string AuthenticatorGPMErrorSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorGPMErrorSheetModel::GetStepDescription() const { … }

// AuthenticatorGPMConnectingSheetModel --------------------------------------

AuthenticatorGPMConnectingSheetModel::AuthenticatorGPMConnectingSheetModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorGPMConnectingSheetModel::~AuthenticatorGPMConnectingSheetModel() =
    default;

std::u16string AuthenticatorGPMConnectingSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorGPMConnectingSheetModel::GetStepDescription()
    const { … }

// AuthenticatorPhoneConfirmationSheet --------------------------------

AuthenticatorPhoneConfirmationSheet::AuthenticatorPhoneConfirmationSheet(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorPhoneConfirmationSheet::~AuthenticatorPhoneConfirmationSheet() =
    default;

std::u16string AuthenticatorPhoneConfirmationSheet::GetStepTitle() const { … }

std::u16string AuthenticatorPhoneConfirmationSheet::GetStepDescription() const { … }

bool AuthenticatorPhoneConfirmationSheet::IsAcceptButtonVisible() const { … }

std::u16string AuthenticatorPhoneConfirmationSheet::GetAcceptButtonLabel()
    const { … }

void AuthenticatorPhoneConfirmationSheet::OnAccept() { … }

// AuthenticatorMultiSourcePickerSheetModel --------------------------------

AuthenticatorMultiSourcePickerSheetModel::
    AuthenticatorMultiSourcePickerSheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorMultiSourcePickerSheetModel::
    ~AuthenticatorMultiSourcePickerSheetModel() = default;

bool AuthenticatorMultiSourcePickerSheetModel::IsManageDevicesButtonVisible()
    const { … }

void AuthenticatorMultiSourcePickerSheetModel::OnManageDevices() { … }

std::u16string AuthenticatorMultiSourcePickerSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorMultiSourcePickerSheetModel::GetStepDescription()
    const { … }

// AuthenticatorPriorityMechanismSheetModel --------------------------------

AuthenticatorPriorityMechanismSheetModel::
    AuthenticatorPriorityMechanismSheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }
AuthenticatorPriorityMechanismSheetModel::
    ~AuthenticatorPriorityMechanismSheetModel() = default;

std::u16string AuthenticatorPriorityMechanismSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorPriorityMechanismSheetModel::GetStepDescription()
    const { … }

bool AuthenticatorPriorityMechanismSheetModel::IsAcceptButtonVisible() const { … }

std::u16string AuthenticatorPriorityMechanismSheetModel::GetAcceptButtonLabel()
    const { … }

void AuthenticatorPriorityMechanismSheetModel::OnAccept() { … }

// AuthenticatorGpmPinSheetModelBase -------------------------------------------

AuthenticatorGpmPinSheetModelBase::AuthenticatorGpmPinSheetModelBase(
    AuthenticatorRequestDialogModel* dialog_model,
    Mode mode)
    : … { … }

AuthenticatorGpmPinSheetModelBase::~AuthenticatorGpmPinSheetModelBase() =
    default;

std::u16string AuthenticatorGpmPinSheetModelBase::GetGpmAccountEmail() const { … }

std::u16string AuthenticatorGpmPinSheetModelBase::GetGpmAccountName() const { … }

gfx::Image AuthenticatorGpmPinSheetModelBase::GetGpmAccountImage() const { … }

std::u16string AuthenticatorGpmPinSheetModelBase::GetAccessibleDescription()
    const { … }

bool AuthenticatorGpmPinSheetModelBase::ui_disabled() const { … }

std::u16string AuthenticatorGpmPinSheetModelBase::GetStepTitle() const { … }

std::u16string AuthenticatorGpmPinSheetModelBase::GetStepDescription() const { … }

std::u16string AuthenticatorGpmPinSheetModelBase::GetError() const { … }

bool AuthenticatorGpmPinSheetModelBase::IsForgotGPMPinButtonVisible() const { … }

bool AuthenticatorGpmPinSheetModelBase::IsGPMPinOptionsButtonVisible() const { … }

void AuthenticatorGpmPinSheetModelBase::OnAccept() { … }

void AuthenticatorGpmPinSheetModelBase::OnForgotGPMPin() const { … }

void AuthenticatorGpmPinSheetModelBase::OnGPMPinOptionChosen(
    bool is_arbitrary) const { … }

// AuthenticatorGpmPinSheetModel -----------------------------------------------

AuthenticatorGpmPinSheetModel::AuthenticatorGpmPinSheetModel(
    AuthenticatorRequestDialogModel* dialog_model,
    int pin_digits_count,
    Mode mode)
    : … { … }

AuthenticatorGpmPinSheetModel::~AuthenticatorGpmPinSheetModel() = default;

void AuthenticatorGpmPinSheetModel::PinCharTyped(bool is_digit) { … }

int AuthenticatorGpmPinSheetModel::pin_digits_count() const { … }

void AuthenticatorGpmPinSheetModel::SetPin(std::u16string pin) { … }

std::u16string AuthenticatorGpmPinSheetModel::GetAccessibleName() const { … }

bool AuthenticatorGpmPinSheetModel::FullPinTyped() const { … }

bool AuthenticatorGpmPinSheetModel::IsAcceptButtonVisible() const { … }

bool AuthenticatorGpmPinSheetModel::IsAcceptButtonEnabled() const { … }

std::u16string AuthenticatorGpmPinSheetModel::GetAcceptButtonLabel() const { … }

std::u16string AuthenticatorGpmPinSheetModel::GetHint() const { … }

// AuthenticatorGpmArbitraryPinSheetModel --------------------------------------

AuthenticatorGpmArbitraryPinSheetModel::AuthenticatorGpmArbitraryPinSheetModel(
    AuthenticatorRequestDialogModel* dialog_model,
    Mode mode)
    : … { … }

AuthenticatorGpmArbitraryPinSheetModel::
    ~AuthenticatorGpmArbitraryPinSheetModel() = default;

void AuthenticatorGpmArbitraryPinSheetModel::SetPin(std::u16string pin) { … }

std::u16string AuthenticatorGpmArbitraryPinSheetModel::GetAccessibleName()
    const { … }

bool AuthenticatorGpmArbitraryPinSheetModel::IsAcceptButtonVisible() const { … }

bool AuthenticatorGpmArbitraryPinSheetModel::IsAcceptButtonEnabled() const { … }

std::u16string AuthenticatorGpmArbitraryPinSheetModel::GetAcceptButtonLabel()
    const { … }

std::u16string AuthenticatorGpmArbitraryPinSheetModel::GetHint() const { … }

// AuthenticatorTrustThisComputerAssertionSheetModel -------------------------

AuthenticatorTrustThisComputerAssertionSheetModel::
    AuthenticatorTrustThisComputerAssertionSheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorTrustThisComputerAssertionSheetModel::
    ~AuthenticatorTrustThisComputerAssertionSheetModel() = default;

std::u16string AuthenticatorTrustThisComputerAssertionSheetModel::GetStepTitle()
    const { … }

std::u16string
AuthenticatorTrustThisComputerAssertionSheetModel::GetStepDescription() const { … }

bool AuthenticatorTrustThisComputerAssertionSheetModel::IsCancelButtonVisible()
    const { … }

std::u16string
AuthenticatorTrustThisComputerAssertionSheetModel::GetCancelButtonLabel()
    const { … }

bool AuthenticatorTrustThisComputerAssertionSheetModel::IsAcceptButtonVisible()
    const { … }

std::u16string
AuthenticatorTrustThisComputerAssertionSheetModel::GetAcceptButtonLabel()
    const { … }

bool AuthenticatorTrustThisComputerAssertionSheetModel::
    IsOtherMechanismButtonVisible() const { … }

std::u16string AuthenticatorTrustThisComputerAssertionSheetModel::
    GetOtherMechanismButtonLabel() const { … }

void AuthenticatorTrustThisComputerAssertionSheetModel::OnBack() { … }

void AuthenticatorTrustThisComputerAssertionSheetModel::OnAccept() { … }

// AuthenticatorCreateGpmPasskeySheetModel -------------------------------------

AuthenticatorCreateGpmPasskeySheetModel::
    AuthenticatorCreateGpmPasskeySheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorCreateGpmPasskeySheetModel::
    ~AuthenticatorCreateGpmPasskeySheetModel() = default;

std::u16string AuthenticatorCreateGpmPasskeySheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorCreateGpmPasskeySheetModel::GetStepDescription()
    const { … }

bool AuthenticatorCreateGpmPasskeySheetModel::IsCancelButtonVisible() const { … }

std::u16string AuthenticatorCreateGpmPasskeySheetModel::GetCancelButtonLabel()
    const { … }

bool AuthenticatorCreateGpmPasskeySheetModel::IsAcceptButtonVisible() const { … }

std::u16string AuthenticatorCreateGpmPasskeySheetModel::GetAcceptButtonLabel()
    const { … }

void AuthenticatorCreateGpmPasskeySheetModel::OnAccept() { … }

// AuthenticatorGpmIncognitoCreateSheetModel ---------------------------------
AuthenticatorGpmIncognitoCreateSheetModel::
    AuthenticatorGpmIncognitoCreateSheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorGpmIncognitoCreateSheetModel::
    ~AuthenticatorGpmIncognitoCreateSheetModel() = default;

std::u16string AuthenticatorGpmIncognitoCreateSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorGpmIncognitoCreateSheetModel::GetStepDescription()
    const { … }

bool AuthenticatorGpmIncognitoCreateSheetModel::IsCancelButtonVisible() const { … }

std::u16string AuthenticatorGpmIncognitoCreateSheetModel::GetCancelButtonLabel()
    const { … }

bool AuthenticatorGpmIncognitoCreateSheetModel::IsAcceptButtonVisible() const { … }

std::u16string AuthenticatorGpmIncognitoCreateSheetModel::GetAcceptButtonLabel()
    const { … }
void AuthenticatorGpmIncognitoCreateSheetModel::OnAccept() { … }

// AuthenticatorTrustThisComputerCreationSheetModel ---------------------

AuthenticatorTrustThisComputerCreationSheetModel::
    AuthenticatorTrustThisComputerCreationSheetModel(
        AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorTrustThisComputerCreationSheetModel::
    ~AuthenticatorTrustThisComputerCreationSheetModel() = default;

std::u16string AuthenticatorTrustThisComputerCreationSheetModel::GetStepTitle()
    const { … }

std::u16string
AuthenticatorTrustThisComputerCreationSheetModel::GetStepDescription() const { … }

bool AuthenticatorTrustThisComputerCreationSheetModel::IsCancelButtonVisible()
    const { … }

std::u16string
AuthenticatorTrustThisComputerCreationSheetModel::GetCancelButtonLabel() const { … }

bool AuthenticatorTrustThisComputerCreationSheetModel::IsAcceptButtonVisible()
    const { … }

std::u16string
AuthenticatorTrustThisComputerCreationSheetModel::GetAcceptButtonLabel() const { … }

std::u16string
AuthenticatorTrustThisComputerCreationSheetModel::GetOtherMechanismButtonLabel()
    const { … }

void AuthenticatorTrustThisComputerCreationSheetModel::OnAccept() { … }

// AuthenticatorGPMLockedPinSheetModel ----------------------------------

AuthenticatorGPMLockedPinSheetModel::AuthenticatorGPMLockedPinSheetModel(
    AuthenticatorRequestDialogModel* dialog_model)
    : … { … }

AuthenticatorGPMLockedPinSheetModel::~AuthenticatorGPMLockedPinSheetModel() =
    default;

std::u16string AuthenticatorGPMLockedPinSheetModel::GetStepTitle() const { … }

std::u16string AuthenticatorGPMLockedPinSheetModel::GetStepDescription() const { … }

bool AuthenticatorGPMLockedPinSheetModel::IsAcceptButtonEnabled() const { … }

bool AuthenticatorGPMLockedPinSheetModel::IsAcceptButtonVisible() const { … }

std::u16string AuthenticatorGPMLockedPinSheetModel::GetAcceptButtonLabel()
    const { … }

void AuthenticatorGPMLockedPinSheetModel::OnAccept() { … }
chromium/chrome/browser/ui/webauthn/sheet_models.cc
