chromium/out/Default/gen/chrome/common/extensions/api/passwords_private.cc

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

// GENERATED FROM THE API DEFINITION IN
//   chrome/common/extensions/api/passwords_private.idl
// by tools/json_schema_compiler.
// DO NOT EDIT.

#include "chrome/common/extensions/api/passwords_private.h"

#include <memory>
#include <optional>
#include <ostream>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

#include "base/check.h"
#include "base/check_op.h"
#include "base/notreached.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "tools/json_schema_compiler/util.h"
#include <string_view>


UTF8ToUTF16;

namespace extensions {
namespace api {
namespace passwords_private {
//
// Types
//

const char* ToString(PlaintextReason enum_param) { … }

PlaintextReason ParsePlaintextReason(std::string_view enum_string) { … }

std::u16string GetPlaintextReasonParseError(std::string_view enum_string) { … }


const char* ToString(ExportProgressStatus enum_param) { … }

ExportProgressStatus ParseExportProgressStatus(std::string_view enum_string) { … }

std::u16string GetExportProgressStatusParseError(std::string_view enum_string) { … }


const char* ToString(CompromiseType enum_param) { … }

CompromiseType ParseCompromiseType(std::string_view enum_string) { … }

std::u16string GetCompromiseTypeParseError(std::string_view enum_string) { … }


const char* ToString(PasswordStoreSet enum_param) { … }

PasswordStoreSet ParsePasswordStoreSet(std::string_view enum_string) { … }

std::u16string GetPasswordStoreSetParseError(std::string_view enum_string) { … }


const char* ToString(PasswordCheckState enum_param) { … }

PasswordCheckState ParsePasswordCheckState(std::string_view enum_string) { … }

std::u16string GetPasswordCheckStateParseError(std::string_view enum_string) { … }


const char* ToString(ImportResultsStatus enum_param) { … }

ImportResultsStatus ParseImportResultsStatus(std::string_view enum_string) { … }

std::u16string GetImportResultsStatusParseError(std::string_view enum_string) { … }


const char* ToString(ImportEntryStatus enum_param) { … }

ImportEntryStatus ParseImportEntryStatus(std::string_view enum_string) { … }

std::u16string GetImportEntryStatusParseError(std::string_view enum_string) { … }


const char* ToString(FamilyFetchStatus enum_param) { … }

FamilyFetchStatus ParseFamilyFetchStatus(std::string_view enum_string) { … }

std::u16string GetFamilyFetchStatusParseError(std::string_view enum_string) { … }


PublicKey::PublicKey()
: … { … }

PublicKey::~PublicKey() = default;
PublicKey::PublicKey(PublicKey&& rhs) noexcept = default;
PublicKey& PublicKey::operator=(PublicKey&& rhs) noexcept = default;
PublicKey PublicKey::Clone() const { … }

// static
bool PublicKey::Populate(
    const base::Value::Dict& dict, PublicKey& out) { … }

// static
bool PublicKey::Populate(
    const base::Value& value, PublicKey& out) { … }

// static
std::optional<PublicKey> PublicKey::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<PublicKey> PublicKey::FromValue(const base::Value& value) { … }

base::Value::Dict PublicKey::ToValue() const { … }


RecipientInfo::RecipientInfo()
: … { … }

RecipientInfo::~RecipientInfo() = default;
RecipientInfo::RecipientInfo(RecipientInfo&& rhs) noexcept = default;
RecipientInfo& RecipientInfo::operator=(RecipientInfo&& rhs) noexcept = default;
RecipientInfo RecipientInfo::Clone() const { … }

// static
bool RecipientInfo::Populate(
    const base::Value::Dict& dict, RecipientInfo& out) { … }

// static
bool RecipientInfo::Populate(
    const base::Value& value, RecipientInfo& out) { … }

// static
std::optional<RecipientInfo> RecipientInfo::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<RecipientInfo> RecipientInfo::FromValue(const base::Value& value) { … }

base::Value::Dict RecipientInfo::ToValue() const { … }


FamilyFetchResults::FamilyFetchResults()
: … { … }

FamilyFetchResults::~FamilyFetchResults() = default;
FamilyFetchResults::FamilyFetchResults(FamilyFetchResults&& rhs) noexcept = default;
FamilyFetchResults& FamilyFetchResults::operator=(FamilyFetchResults&& rhs) noexcept = default;
FamilyFetchResults FamilyFetchResults::Clone() const { … }

// static
bool FamilyFetchResults::Populate(
    const base::Value::Dict& dict, FamilyFetchResults& out) { … }

// static
bool FamilyFetchResults::Populate(
    const base::Value& value, FamilyFetchResults& out) { … }

// static
std::optional<FamilyFetchResults> FamilyFetchResults::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<FamilyFetchResults> FamilyFetchResults::FromValue(const base::Value& value) { … }

base::Value::Dict FamilyFetchResults::ToValue() const { … }


ImportEntry::ImportEntry()
: … { … }

ImportEntry::~ImportEntry() = default;
ImportEntry::ImportEntry(ImportEntry&& rhs) noexcept = default;
ImportEntry& ImportEntry::operator=(ImportEntry&& rhs) noexcept = default;
ImportEntry ImportEntry::Clone() const { … }

// static
bool ImportEntry::Populate(
    const base::Value::Dict& dict, ImportEntry& out) { … }

// static
bool ImportEntry::Populate(
    const base::Value& value, ImportEntry& out) { … }

// static
std::optional<ImportEntry> ImportEntry::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ImportEntry> ImportEntry::FromValue(const base::Value& value) { … }

base::Value::Dict ImportEntry::ToValue() const { … }


ImportResults::ImportResults()
: … { … }

ImportResults::~ImportResults() = default;
ImportResults::ImportResults(ImportResults&& rhs) noexcept = default;
ImportResults& ImportResults::operator=(ImportResults&& rhs) noexcept = default;
ImportResults ImportResults::Clone() const { … }

// static
bool ImportResults::Populate(
    const base::Value::Dict& dict, ImportResults& out) { … }

// static
bool ImportResults::Populate(
    const base::Value& value, ImportResults& out) { … }

// static
std::optional<ImportResults> ImportResults::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ImportResults> ImportResults::FromValue(const base::Value& value) { … }

base::Value::Dict ImportResults::ToValue() const { … }


UrlCollection::UrlCollection()
 { … }

UrlCollection::~UrlCollection() = default;
UrlCollection::UrlCollection(UrlCollection&& rhs) noexcept = default;
UrlCollection& UrlCollection::operator=(UrlCollection&& rhs) noexcept = default;
UrlCollection UrlCollection::Clone() const { … }

// static
bool UrlCollection::Populate(
    const base::Value::Dict& dict, UrlCollection& out) { … }

// static
bool UrlCollection::Populate(
    const base::Value& value, UrlCollection& out) { … }

// static
std::optional<UrlCollection> UrlCollection::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<UrlCollection> UrlCollection::FromValue(const base::Value& value) { … }

base::Value::Dict UrlCollection::ToValue() const { … }


CompromisedInfo::CompromisedInfo()
: … { … }

CompromisedInfo::~CompromisedInfo() = default;
CompromisedInfo::CompromisedInfo(CompromisedInfo&& rhs) noexcept = default;
CompromisedInfo& CompromisedInfo::operator=(CompromisedInfo&& rhs) noexcept = default;
CompromisedInfo CompromisedInfo::Clone() const { … }

// static
bool CompromisedInfo::Populate(
    const base::Value::Dict& dict, CompromisedInfo& out) { … }

// static
bool CompromisedInfo::Populate(
    const base::Value& value, CompromisedInfo& out) { … }

// static
std::optional<CompromisedInfo> CompromisedInfo::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<CompromisedInfo> CompromisedInfo::FromValue(const base::Value& value) { … }

base::Value::Dict CompromisedInfo::ToValue() const { … }


DomainInfo::DomainInfo()
 { … }

DomainInfo::~DomainInfo() = default;
DomainInfo::DomainInfo(DomainInfo&& rhs) noexcept = default;
DomainInfo& DomainInfo::operator=(DomainInfo&& rhs) noexcept = default;
DomainInfo DomainInfo::Clone() const { … }

// static
bool DomainInfo::Populate(
    const base::Value::Dict& dict, DomainInfo& out) { … }

// static
bool DomainInfo::Populate(
    const base::Value& value, DomainInfo& out) { … }

// static
std::optional<DomainInfo> DomainInfo::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<DomainInfo> DomainInfo::FromValue(const base::Value& value) { … }

base::Value::Dict DomainInfo::ToValue() const { … }


PasswordUiEntry::PasswordUiEntry()
: … { … }

PasswordUiEntry::~PasswordUiEntry() = default;
PasswordUiEntry::PasswordUiEntry(PasswordUiEntry&& rhs) noexcept = default;
PasswordUiEntry& PasswordUiEntry::operator=(PasswordUiEntry&& rhs) noexcept = default;
PasswordUiEntry PasswordUiEntry::Clone() const { … }

// static
bool PasswordUiEntry::Populate(
    const base::Value::Dict& dict, PasswordUiEntry& out) { … }

// static
bool PasswordUiEntry::Populate(
    const base::Value& value, PasswordUiEntry& out) { … }

// static
std::optional<PasswordUiEntry> PasswordUiEntry::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<PasswordUiEntry> PasswordUiEntry::FromValue(const base::Value& value) { … }

base::Value::Dict PasswordUiEntry::ToValue() const { … }


CredentialGroup::CredentialGroup()
 { … }

CredentialGroup::~CredentialGroup() = default;
CredentialGroup::CredentialGroup(CredentialGroup&& rhs) noexcept = default;
CredentialGroup& CredentialGroup::operator=(CredentialGroup&& rhs) noexcept = default;
CredentialGroup CredentialGroup::Clone() const { … }

// static
bool CredentialGroup::Populate(
    const base::Value::Dict& dict, CredentialGroup& out) { … }

// static
bool CredentialGroup::Populate(
    const base::Value& value, CredentialGroup& out) { … }

// static
std::optional<CredentialGroup> CredentialGroup::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<CredentialGroup> CredentialGroup::FromValue(const base::Value& value) { … }

base::Value::Dict CredentialGroup::ToValue() const { … }


ExceptionEntry::ExceptionEntry()
: … { … }

ExceptionEntry::~ExceptionEntry() = default;
ExceptionEntry::ExceptionEntry(ExceptionEntry&& rhs) noexcept = default;
ExceptionEntry& ExceptionEntry::operator=(ExceptionEntry&& rhs) noexcept = default;
ExceptionEntry ExceptionEntry::Clone() const { … }

// static
bool ExceptionEntry::Populate(
    const base::Value::Dict& dict, ExceptionEntry& out) { … }

// static
bool ExceptionEntry::Populate(
    const base::Value& value, ExceptionEntry& out) { … }

// static
std::optional<ExceptionEntry> ExceptionEntry::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ExceptionEntry> ExceptionEntry::FromValue(const base::Value& value) { … }

base::Value::Dict ExceptionEntry::ToValue() const { … }


PasswordExportProgress::PasswordExportProgress()
: … { … }

PasswordExportProgress::~PasswordExportProgress() = default;
PasswordExportProgress::PasswordExportProgress(PasswordExportProgress&& rhs) noexcept = default;
PasswordExportProgress& PasswordExportProgress::operator=(PasswordExportProgress&& rhs) noexcept = default;
PasswordExportProgress PasswordExportProgress::Clone() const { … }

// static
bool PasswordExportProgress::Populate(
    const base::Value::Dict& dict, PasswordExportProgress& out) { … }

// static
bool PasswordExportProgress::Populate(
    const base::Value& value, PasswordExportProgress& out) { … }

// static
std::optional<PasswordExportProgress> PasswordExportProgress::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<PasswordExportProgress> PasswordExportProgress::FromValue(const base::Value& value) { … }

base::Value::Dict PasswordExportProgress::ToValue() const { … }


PasswordCheckStatus::PasswordCheckStatus()
: … { … }

PasswordCheckStatus::~PasswordCheckStatus() = default;
PasswordCheckStatus::PasswordCheckStatus(PasswordCheckStatus&& rhs) noexcept = default;
PasswordCheckStatus& PasswordCheckStatus::operator=(PasswordCheckStatus&& rhs) noexcept = default;
PasswordCheckStatus PasswordCheckStatus::Clone() const { … }

// static
bool PasswordCheckStatus::Populate(
    const base::Value::Dict& dict, PasswordCheckStatus& out) { … }

// static
bool PasswordCheckStatus::Populate(
    const base::Value& value, PasswordCheckStatus& out) { … }

// static
std::optional<PasswordCheckStatus> PasswordCheckStatus::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<PasswordCheckStatus> PasswordCheckStatus::FromValue(const base::Value& value) { … }

base::Value::Dict PasswordCheckStatus::ToValue() const { … }


AddPasswordOptions::AddPasswordOptions()
: … { … }

AddPasswordOptions::~AddPasswordOptions() = default;
AddPasswordOptions::AddPasswordOptions(AddPasswordOptions&& rhs) noexcept = default;
AddPasswordOptions& AddPasswordOptions::operator=(AddPasswordOptions&& rhs) noexcept = default;
AddPasswordOptions AddPasswordOptions::Clone() const { … }

// static
bool AddPasswordOptions::Populate(
    const base::Value::Dict& dict, AddPasswordOptions& out) { … }

// static
bool AddPasswordOptions::Populate(
    const base::Value& value, AddPasswordOptions& out) { … }

// static
std::optional<AddPasswordOptions> AddPasswordOptions::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<AddPasswordOptions> AddPasswordOptions::FromValue(const base::Value& value) { … }

base::Value::Dict AddPasswordOptions::ToValue() const { … }


PasswordUiEntryList::PasswordUiEntryList()
 { … }

PasswordUiEntryList::~PasswordUiEntryList() = default;
PasswordUiEntryList::PasswordUiEntryList(PasswordUiEntryList&& rhs) noexcept = default;
PasswordUiEntryList& PasswordUiEntryList::operator=(PasswordUiEntryList&& rhs) noexcept = default;
PasswordUiEntryList PasswordUiEntryList::Clone() const { … }

// static
bool PasswordUiEntryList::Populate(
    const base::Value::Dict& dict, PasswordUiEntryList& out) { … }

// static
bool PasswordUiEntryList::Populate(
    const base::Value& value, PasswordUiEntryList& out) { … }

// static
std::optional<PasswordUiEntryList> PasswordUiEntryList::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<PasswordUiEntryList> PasswordUiEntryList::FromValue(const base::Value& value) { … }

base::Value::Dict PasswordUiEntryList::ToValue() const { … }



//
// Functions
//

namespace RecordPasswordsPageAccessInSettings {

}  // namespace RecordPasswordsPageAccessInSettings

namespace ChangeCredential {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace ChangeCredential

namespace RemoveCredential {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace RemoveCredential

namespace RemovePasswordException {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace RemovePasswordException

namespace UndoRemoveSavedPasswordOrException {

}  // namespace UndoRemoveSavedPasswordOrException

namespace RequestPlaintextPassword {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const std::string& password) { … }
}  // namespace RequestPlaintextPassword

namespace RequestCredentialsDetails {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const std::vector<PasswordUiEntry>& entries) { … }
}  // namespace RequestCredentialsDetails

namespace GetSavedPasswordList {

base::Value::List Results::Create(const std::vector<PasswordUiEntry>& entries) { … }
}  // namespace GetSavedPasswordList

namespace GetCredentialGroups {

base::Value::List Results::Create(const std::vector<CredentialGroup>& entries) { … }
}  // namespace GetCredentialGroups

namespace GetPasswordExceptionList {

base::Value::List Results::Create(const std::vector<ExceptionEntry>& exceptions) { … }
}  // namespace GetPasswordExceptionList

namespace MovePasswordsToAccount {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace MovePasswordsToAccount

namespace FetchFamilyMembers {

base::Value::List Results::Create(const FamilyFetchResults& results) { … }
}  // namespace FetchFamilyMembers

namespace SharePassword {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace SharePassword

namespace ImportPasswords {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const ImportResults& results) { … }
}  // namespace ImportPasswords

namespace ContinueImport {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const ImportResults& results) { … }
}  // namespace ContinueImport

namespace ResetImporter {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace ResetImporter

namespace ExportPasswords {

base::Value::List Results::Create() { … }
}  // namespace ExportPasswords

namespace RequestExportProgressStatus {

base::Value::List Results::Create(const ExportProgressStatus& status) { … }
}  // namespace RequestExportProgressStatus

namespace IsOptedInForAccountStorage {

base::Value::List Results::Create(bool opted_in) { … }
}  // namespace IsOptedInForAccountStorage

namespace OptInForAccountStorage {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace OptInForAccountStorage

namespace GetInsecureCredentials {

base::Value::List Results::Create(const std::vector<PasswordUiEntry>& entries) { … }
}  // namespace GetInsecureCredentials

namespace GetCredentialsWithReusedPassword {

base::Value::List Results::Create(const std::vector<PasswordUiEntryList>& entries) { … }
}  // namespace GetCredentialsWithReusedPassword

namespace MuteInsecureCredential {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace MuteInsecureCredential

namespace UnmuteInsecureCredential {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace UnmuteInsecureCredential

namespace StartPasswordCheck {

base::Value::List Results::Create() { … }
}  // namespace StartPasswordCheck

namespace GetPasswordCheckStatus {

base::Value::List Results::Create(const PasswordCheckStatus& status) { … }
}  // namespace GetPasswordCheckStatus

namespace IsAccountStoreDefault {

base::Value::List Results::Create(bool is_default) { … }
}  // namespace IsAccountStoreDefault

namespace GetUrlCollection {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const UrlCollection& url_collection) { … }
}  // namespace GetUrlCollection

namespace AddPassword {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace AddPassword

namespace ExtendAuthValidity {

base::Value::List Results::Create() { … }
}  // namespace ExtendAuthValidity

namespace SwitchBiometricAuthBeforeFillingState {

base::Value::List Results::Create(bool result) { … }
}  // namespace SwitchBiometricAuthBeforeFillingState

namespace ShowAddShortcutDialog {

}  // namespace ShowAddShortcutDialog

namespace ShowExportedFileInShell {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace ShowExportedFileInShell

namespace ChangePasswordManagerPin {

base::Value::List Results::Create(bool success) { … }
}  // namespace ChangePasswordManagerPin

namespace IsPasswordManagerPinAvailable {

base::Value::List Results::Create(bool available) { … }
}  // namespace IsPasswordManagerPinAvailable

namespace DisconnectCloudAuthenticator {

base::Value::List Results::Create(bool success) { … }
}  // namespace DisconnectCloudAuthenticator

namespace IsConnectedToCloudAuthenticator {

base::Value::List Results::Create(bool connected) { … }
}  // namespace IsConnectedToCloudAuthenticator

namespace DeleteAllPasswordManagerData {

base::Value::List Results::Create(bool success) { … }
}  // namespace DeleteAllPasswordManagerData

//
// Events
//

namespace OnSavedPasswordsListChanged {

const char kEventName[] = …;

base::Value::List Create(const std::vector<PasswordUiEntry>& entries) { … }

}  // namespace OnSavedPasswordsListChanged

namespace OnPasswordExceptionsListChanged {

const char kEventName[] = …;

base::Value::List Create(const std::vector<ExceptionEntry>& exceptions) { … }

}  // namespace OnPasswordExceptionsListChanged

namespace OnPasswordsFileExportProgress {

const char kEventName[] = …;

base::Value::List Create(const PasswordExportProgress& status) { … }

}  // namespace OnPasswordsFileExportProgress

namespace OnAccountStorageOptInStateChanged {

const char kEventName[] = …;

base::Value::List Create(bool opted_in) { … }

}  // namespace OnAccountStorageOptInStateChanged

namespace OnInsecureCredentialsChanged {

const char kEventName[] = …;

base::Value::List Create(const std::vector<PasswordUiEntry>& insecure_credentials) { … }

}  // namespace OnInsecureCredentialsChanged

namespace OnPasswordCheckStatusChanged {

const char kEventName[] = …;

base::Value::List Create(const PasswordCheckStatus& status) { … }

}  // namespace OnPasswordCheckStatusChanged

namespace OnPasswordManagerAuthTimeout {

const char kEventName[] = …;

base::Value::List Create() { … }

}  // namespace OnPasswordManagerAuthTimeout

}  // namespace passwords_private
}  // namespace api
}  // namespace extensions