autofill_private.cc | Explore in Territory

// 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/autofill_private.idl
// by tools/json_schema_compiler.
// DO NOT EDIT.

#include "chrome/common/extensions/api/autofill_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 autofill_private {
//
// Types
//

AccountInfo::AccountInfo()
: … { … }

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

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

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

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

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

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


const char* ToString(FieldType enum_param) { … }

FieldType ParseFieldType(std::string_view enum_string) { … }

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


const char* ToString(AddressRecordType enum_param) { … }

AddressRecordType ParseAddressRecordType(std::string_view enum_string) { … }

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


AutofillMetadata::AutofillMetadata()
: … { … }

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

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

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

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

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

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


AddressField::AddressField()
: … { … }

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

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

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

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

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

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


AddressEntry::AddressEntry()
 { … }

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

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

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

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

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

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


CountryEntry::CountryEntry()
 { … }

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

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

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

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

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

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


AddressComponent::AddressComponent()
: … { … }

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

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

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

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

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

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


AddressComponentRow::AddressComponentRow()
 { … }

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

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

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

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

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

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


AddressComponents::AddressComponents()
 { … }

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

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

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

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

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

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


CreditCardEntry::CreditCardEntry()
 { … }

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

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

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

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

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

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


IbanEntry::IbanEntry()
 { … }

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

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

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

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

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

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



//
// Functions
//

namespace GetAccountInfo {

base::Value::List Results::Create(const AccountInfo& account_info) { … }
}  // namespace GetAccountInfo

namespace SaveAddress {

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 SaveAddress

namespace GetCountryList {

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<CountryEntry>& countries) { … }
}  // namespace GetCountryList

namespace GetAddressComponents {

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 AddressComponents& components) { … }
}  // namespace GetAddressComponents

namespace GetAddressList {

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

namespace SaveCreditCard {

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 SaveCreditCard

namespace SaveIban {

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 SaveIban

namespace RemoveEntry {

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 RemoveEntry

namespace GetCreditCardList {

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

namespace GetIbanList {

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

namespace IsValidIban {

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(bool is_valid) { … }
}  // namespace IsValidIban

namespace MigrateCreditCards {

}  // namespace MigrateCreditCards

namespace LogServerCardLinkClicked {

}  // namespace LogServerCardLinkClicked

namespace AddVirtualCard {

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 AddVirtualCard

namespace RemoveVirtualCard {

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 RemoveVirtualCard

namespace AuthenticateUserAndFlipMandatoryAuthToggle {

}  // namespace AuthenticateUserAndFlipMandatoryAuthToggle

namespace GetLocalCard {

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 CreditCardEntry& card) { … }
}  // namespace GetLocalCard

namespace CheckIfDeviceAuthAvailable {

base::Value::List Results::Create(bool is_device_auth_available) { … }
}  // namespace CheckIfDeviceAuthAvailable

namespace BulkDeleteAllCvcs {

}  // namespace BulkDeleteAllCvcs

namespace SetAutofillSyncToggleEnabled {

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 SetAutofillSyncToggleEnabled

//
// Events
//

namespace OnPersonalDataChanged {

const char kEventName[] = …;

base::Value::List Create(const std::vector<AddressEntry>& address_entries, const std::vector<CreditCardEntry>& credit_card_entries, const std::vector<IbanEntry>& ibans, const AccountInfo& account_info) { … }

}  // namespace OnPersonalDataChanged

}  // namespace autofill_private
}  // namespace api
}  // namespace extensions
chromium/out/Default/gen/chrome/common/extensions/api/autofill_private.cc
