chromium/out/Default/gen/extensions/common/api/usb.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
//   extensions/common/api/usb.idl
// by tools/json_schema_compiler.
// DO NOT EDIT.

#include "extensions/common/api/usb.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 usb {
//
// Types
//

const char* ToString(Direction enum_param) { … }

Direction ParseDirection(std::string_view enum_string) { … }

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


const char* ToString(Recipient enum_param) { … }

Recipient ParseRecipient(std::string_view enum_string) { … }

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


const char* ToString(RequestType enum_param) { … }

RequestType ParseRequestType(std::string_view enum_string) { … }

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


const char* ToString(TransferType enum_param) { … }

TransferType ParseTransferType(std::string_view enum_string) { … }

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


const char* ToString(SynchronizationType enum_param) { … }

SynchronizationType ParseSynchronizationType(std::string_view enum_string) { … }

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


const char* ToString(UsageType enum_param) { … }

UsageType ParseUsageType(std::string_view enum_string) { … }

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


Device::Device()
: … { … }

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

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

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

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

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

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


ConnectionHandle::ConnectionHandle()
: … { … }

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

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

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

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

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

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


EndpointDescriptor::EndpointDescriptor()
: … { … }

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

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

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

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

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

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


InterfaceDescriptor::InterfaceDescriptor()
: … { … }

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

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

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

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

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

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


ConfigDescriptor::ConfigDescriptor()
: … { … }

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

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

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

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

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

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


ControlTransferInfo::ControlTransferInfo()
: … { … }

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

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

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

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

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

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


GenericTransferInfo::GenericTransferInfo()
: … { … }

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

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

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

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

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

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


IsochronousTransferInfo::IsochronousTransferInfo()
: … { … }

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

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

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

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

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

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


TransferResultInfo::TransferResultInfo()
 { … }

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

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

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

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

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

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


DeviceFilter::DeviceFilter()
 { … }

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

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

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

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

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

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


EnumerateDevicesOptions::EnumerateDevicesOptions()
 { … }

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

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

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

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

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

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


EnumerateDevicesAndRequestAccessOptions::EnumerateDevicesAndRequestAccessOptions()
: … { … }

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

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

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

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

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

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


DevicePromptOptions::DevicePromptOptions()
 { … }

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

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

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

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

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

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



//
// Functions
//

namespace GetDevices {

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<Device>& devices) { … }
}  // namespace GetDevices

namespace GetUserSelectedDevices {

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<Device>& devices) { … }
}  // namespace GetUserSelectedDevices

namespace GetConfigurations {

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<ConfigDescriptor>& configs) { … }
}  // namespace GetConfigurations

namespace RequestAccess {

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 success) { … }
}  // namespace RequestAccess

namespace OpenDevice {

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 ConnectionHandle& handle) { … }
}  // namespace OpenDevice

namespace FindDevices {

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<ConnectionHandle>& handles) { … }
}  // namespace FindDevices

namespace CloseDevice {

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 CloseDevice

namespace SetConfiguration {

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 SetConfiguration

namespace GetConfiguration {

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 ConfigDescriptor& config) { … }
}  // namespace GetConfiguration

namespace ListInterfaces {

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<InterfaceDescriptor>& descriptors) { … }
}  // namespace ListInterfaces

namespace ClaimInterface {

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 ClaimInterface

namespace ReleaseInterface {

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 ReleaseInterface

namespace SetInterfaceAlternateSetting {

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 SetInterfaceAlternateSetting

namespace ControlTransfer {

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 TransferResultInfo& info) { … }
}  // namespace ControlTransfer

namespace BulkTransfer {

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 TransferResultInfo& info) { … }
}  // namespace BulkTransfer

namespace InterruptTransfer {

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 TransferResultInfo& info) { … }
}  // namespace InterruptTransfer

namespace IsochronousTransfer {

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 TransferResultInfo& info) { … }
}  // namespace IsochronousTransfer

namespace ResetDevice {

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 success) { … }
}  // namespace ResetDevice

//
// Events
//

namespace OnDeviceAdded {

const char kEventName[] = …;

base::Value::List Create(const Device& device) { … }

}  // namespace OnDeviceAdded

namespace OnDeviceRemoved {

const char kEventName[] = …;

base::Value::List Create(const Device& device) { … }

}  // namespace OnDeviceRemoved

}  // namespace usb
}  // namespace api
}  // namespace extensions