Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PBrowserParent.h"
#include "mozilla/dom/PBrowserChild.h"
#include "mozilla/dom/PPaymentRequest.h"
#include "mozilla/dom/PPaymentRequestParent.h"
#include "mozilla/dom/PPaymentRequestChild.h"
#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"
namespace mozilla {
namespace dom {
namespace PPaymentRequest {
nsresult
CreateEndpoints(
base::ProcessId aParentDestPid,
base::ProcessId aChildDestPid,
mozilla::ipc::Endpoint<::mozilla::dom::PPaymentRequestParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PPaymentRequestChild>* aChild)
{
return mozilla::ipc::CreateEndpoints(
mozilla::ipc::PrivateIPDLInterface(),
aParentDestPid, aChildDestPid, aParent, aChild);
}
mozilla::UniquePtr<IPC::Message>
Msg___delete__(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg___delete____ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply___delete__(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply___delete____ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_RequestPayment(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_RequestPayment__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_RespondPayment(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_RespondPayment__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ChangeShippingAddress(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ChangeShippingAddress__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ChangeShippingOption(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ChangeShippingOption__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ChangePayerDetail(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ChangePayerDetail__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ChangePaymentMethod(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ChangePaymentMethod__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
} // namespace PPaymentRequest
} // namespace dom
} // namespace mozilla
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentMethodData|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentMethodData>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).supportedMethods());
// Sentinel = 'supportedMethods'
(aWriter)->WriteSentinel(975111867);
IPC::WriteParam(aWriter, (aVar).data());
// Sentinel = 'data'
(aWriter)->WriteSentinel(67109275);
}
auto ParamTraits<::mozilla::dom::IPCPaymentMethodData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___supportedMethods = IPC::ReadParam<::nsString>(aReader);
if (!maybe___supportedMethods) {
aReader->FatalError("Error deserializing 'supportedMethods' (nsString) member of 'IPCPaymentMethodData'");
return {};
}
auto& _supportedMethods = *maybe___supportedMethods;
// Sentinel = 'supportedMethods'
if ((!((aReader)->ReadSentinel(975111867)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'supportedMethods' (nsString) member of 'IPCPaymentMethodData'");
return {};
}
auto maybe___data = IPC::ReadParam<::nsString>(aReader);
if (!maybe___data) {
aReader->FatalError("Error deserializing 'data' (nsString) member of 'IPCPaymentMethodData'");
return {};
}
auto& _data = *maybe___data;
// Sentinel = 'data'
if ((!((aReader)->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'data' (nsString) member of 'IPCPaymentMethodData'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_supportedMethods),
std::move(_data)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentCurrencyAmount|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentCurrencyAmount>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).currency());
// Sentinel = 'currency'
(aWriter)->WriteSentinel(257295212);
IPC::WriteParam(aWriter, (aVar).value());
// Sentinel = 'value'
(aWriter)->WriteSentinel(107610654);
}
auto ParamTraits<::mozilla::dom::IPCPaymentCurrencyAmount>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___currency = IPC::ReadParam<::nsString>(aReader);
if (!maybe___currency) {
aReader->FatalError("Error deserializing 'currency' (nsString) member of 'IPCPaymentCurrencyAmount'");
return {};
}
auto& _currency = *maybe___currency;
// Sentinel = 'currency'
if ((!((aReader)->ReadSentinel(257295212)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'currency' (nsString) member of 'IPCPaymentCurrencyAmount'");
return {};
}
auto maybe___value = IPC::ReadParam<::nsString>(aReader);
if (!maybe___value) {
aReader->FatalError("Error deserializing 'value' (nsString) member of 'IPCPaymentCurrencyAmount'");
return {};
}
auto& _value = *maybe___value;
// Sentinel = 'value'
if ((!((aReader)->ReadSentinel(107610654)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsString) member of 'IPCPaymentCurrencyAmount'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_currency),
std::move(_value)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentItem|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentItem>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).label());
// Sentinel = 'label'
(aWriter)->WriteSentinel(100729345);
IPC::WriteParam(aWriter, (aVar).amount());
// Sentinel = 'amount'
(aWriter)->WriteSentinel(148374165);
IPC::WriteParam(aWriter, (aVar).pending());
// Sentinel = 'pending'
(aWriter)->WriteSentinel(195625702);
}
auto ParamTraits<::mozilla::dom::IPCPaymentItem>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___label = IPC::ReadParam<::nsString>(aReader);
if (!maybe___label) {
aReader->FatalError("Error deserializing 'label' (nsString) member of 'IPCPaymentItem'");
return {};
}
auto& _label = *maybe___label;
// Sentinel = 'label'
if ((!((aReader)->ReadSentinel(100729345)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'label' (nsString) member of 'IPCPaymentItem'");
return {};
}
auto maybe___amount = IPC::ReadParam<::mozilla::dom::IPCPaymentCurrencyAmount>(aReader);
if (!maybe___amount) {
aReader->FatalError("Error deserializing 'amount' (IPCPaymentCurrencyAmount) member of 'IPCPaymentItem'");
return {};
}
auto& _amount = *maybe___amount;
// Sentinel = 'amount'
if ((!((aReader)->ReadSentinel(148374165)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'amount' (IPCPaymentCurrencyAmount) member of 'IPCPaymentItem'");
return {};
}
auto maybe___pending = IPC::ReadParam<bool>(aReader);
if (!maybe___pending) {
aReader->FatalError("Error deserializing 'pending' (bool) member of 'IPCPaymentItem'");
return {};
}
auto& _pending = *maybe___pending;
// Sentinel = 'pending'
if ((!((aReader)->ReadSentinel(195625702)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'pending' (bool) member of 'IPCPaymentItem'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_label),
std::move(_amount),
std::move(_pending)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentDetailsModifier|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentDetailsModifier>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).supportedMethods());
// Sentinel = 'supportedMethods'
(aWriter)->WriteSentinel(975111867);
IPC::WriteParam(aWriter, (aVar).total());
// Sentinel = 'total'
(aWriter)->WriteSentinel(110035493);
IPC::WriteParam(aWriter, (aVar).additionalDisplayItems());
// Sentinel = 'additionalDisplayItems'
(aWriter)->WriteSentinel(1715407090);
IPC::WriteParam(aWriter, (aVar).data());
// Sentinel = 'data'
(aWriter)->WriteSentinel(67109275);
IPC::WriteParam(aWriter, (aVar).additionalDisplayItemsPassed());
// Sentinel = 'additionalDisplayItemsPassed'
(aWriter)->WriteSentinel(2751662930);
}
auto ParamTraits<::mozilla::dom::IPCPaymentDetailsModifier>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___supportedMethods = IPC::ReadParam<::nsString>(aReader);
if (!maybe___supportedMethods) {
aReader->FatalError("Error deserializing 'supportedMethods' (nsString) member of 'IPCPaymentDetailsModifier'");
return {};
}
auto& _supportedMethods = *maybe___supportedMethods;
// Sentinel = 'supportedMethods'
if ((!((aReader)->ReadSentinel(975111867)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'supportedMethods' (nsString) member of 'IPCPaymentDetailsModifier'");
return {};
}
auto maybe___total = IPC::ReadParam<::mozilla::dom::IPCPaymentItem>(aReader);
if (!maybe___total) {
aReader->FatalError("Error deserializing 'total' (IPCPaymentItem) member of 'IPCPaymentDetailsModifier'");
return {};
}
auto& _total = *maybe___total;
// Sentinel = 'total'
if ((!((aReader)->ReadSentinel(110035493)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'total' (IPCPaymentItem) member of 'IPCPaymentDetailsModifier'");
return {};
}
auto maybe___additionalDisplayItems = IPC::ReadParam<nsTArray<::mozilla::dom::IPCPaymentItem>>(aReader);
if (!maybe___additionalDisplayItems) {
aReader->FatalError("Error deserializing 'additionalDisplayItems' (IPCPaymentItem[]) member of 'IPCPaymentDetailsModifier'");
return {};
}
auto& _additionalDisplayItems = *maybe___additionalDisplayItems;
// Sentinel = 'additionalDisplayItems'
if ((!((aReader)->ReadSentinel(1715407090)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'additionalDisplayItems' (IPCPaymentItem[]) member of 'IPCPaymentDetailsModifier'");
return {};
}
auto maybe___data = IPC::ReadParam<::nsString>(aReader);
if (!maybe___data) {
aReader->FatalError("Error deserializing 'data' (nsString) member of 'IPCPaymentDetailsModifier'");
return {};
}
auto& _data = *maybe___data;
// Sentinel = 'data'
if ((!((aReader)->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'data' (nsString) member of 'IPCPaymentDetailsModifier'");
return {};
}
auto maybe___additionalDisplayItemsPassed = IPC::ReadParam<bool>(aReader);
if (!maybe___additionalDisplayItemsPassed) {
aReader->FatalError("Error deserializing 'additionalDisplayItemsPassed' (bool) member of 'IPCPaymentDetailsModifier'");
return {};
}
auto& _additionalDisplayItemsPassed = *maybe___additionalDisplayItemsPassed;
// Sentinel = 'additionalDisplayItemsPassed'
if ((!((aReader)->ReadSentinel(2751662930)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'additionalDisplayItemsPassed' (bool) member of 'IPCPaymentDetailsModifier'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_supportedMethods),
std::move(_total),
std::move(_additionalDisplayItems),
std::move(_data),
std::move(_additionalDisplayItemsPassed)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentShippingOption|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentShippingOption>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).id());
// Sentinel = 'id'
(aWriter)->WriteSentinel(20447438);
IPC::WriteParam(aWriter, (aVar).label());
// Sentinel = 'label'
(aWriter)->WriteSentinel(100729345);
IPC::WriteParam(aWriter, (aVar).amount());
// Sentinel = 'amount'
(aWriter)->WriteSentinel(148374165);
IPC::WriteParam(aWriter, (aVar).selected());
// Sentinel = 'selected'
(aWriter)->WriteSentinel(251265866);
}
auto ParamTraits<::mozilla::dom::IPCPaymentShippingOption>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___id = IPC::ReadParam<::nsString>(aReader);
if (!maybe___id) {
aReader->FatalError("Error deserializing 'id' (nsString) member of 'IPCPaymentShippingOption'");
return {};
}
auto& _id = *maybe___id;
// Sentinel = 'id'
if ((!((aReader)->ReadSentinel(20447438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsString) member of 'IPCPaymentShippingOption'");
return {};
}
auto maybe___label = IPC::ReadParam<::nsString>(aReader);
if (!maybe___label) {
aReader->FatalError("Error deserializing 'label' (nsString) member of 'IPCPaymentShippingOption'");
return {};
}
auto& _label = *maybe___label;
// Sentinel = 'label'
if ((!((aReader)->ReadSentinel(100729345)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'label' (nsString) member of 'IPCPaymentShippingOption'");
return {};
}
auto maybe___amount = IPC::ReadParam<::mozilla::dom::IPCPaymentCurrencyAmount>(aReader);
if (!maybe___amount) {
aReader->FatalError("Error deserializing 'amount' (IPCPaymentCurrencyAmount) member of 'IPCPaymentShippingOption'");
return {};
}
auto& _amount = *maybe___amount;
// Sentinel = 'amount'
if ((!((aReader)->ReadSentinel(148374165)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'amount' (IPCPaymentCurrencyAmount) member of 'IPCPaymentShippingOption'");
return {};
}
auto maybe___selected = IPC::ReadParam<bool>(aReader);
if (!maybe___selected) {
aReader->FatalError("Error deserializing 'selected' (bool) member of 'IPCPaymentShippingOption'");
return {};
}
auto& _selected = *maybe___selected;
// Sentinel = 'selected'
if ((!((aReader)->ReadSentinel(251265866)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'selected' (bool) member of 'IPCPaymentShippingOption'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_id),
std::move(_label),
std::move(_amount),
std::move(_selected)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentDetails|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentDetails>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).id());
// Sentinel = 'id'
(aWriter)->WriteSentinel(20447438);
IPC::WriteParam(aWriter, (aVar).total());
// Sentinel = 'total'
(aWriter)->WriteSentinel(110035493);
IPC::WriteParam(aWriter, (aVar).displayItems());
// Sentinel = 'displayItems'
(aWriter)->WriteSentinel(541263097);
IPC::WriteParam(aWriter, (aVar).shippingOptions());
// Sentinel = 'shippingOptions'
(aWriter)->WriteSentinel(845022799);
IPC::WriteParam(aWriter, (aVar).modifiers());
// Sentinel = 'modifiers'
(aWriter)->WriteSentinel(313525187);
IPC::WriteParam(aWriter, (aVar).error());
// Sentinel = 'error'
(aWriter)->WriteSentinel(107741739);
IPC::WriteParam(aWriter, (aVar).shippingAddressErrors());
// Sentinel = 'shippingAddressErrors'
(aWriter)->WriteSentinel(1588463782);
IPC::WriteParam(aWriter, (aVar).payerErrors());
// Sentinel = 'payerErrors'
(aWriter)->WriteSentinel(460326047);
IPC::WriteParam(aWriter, (aVar).paymentMethodErrors());
// Sentinel = 'paymentMethodErrors'
(aWriter)->WriteSentinel(1316751325);
}
auto ParamTraits<::mozilla::dom::IPCPaymentDetails>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___id = IPC::ReadParam<::nsString>(aReader);
if (!maybe___id) {
aReader->FatalError("Error deserializing 'id' (nsString) member of 'IPCPaymentDetails'");
return {};
}
auto& _id = *maybe___id;
// Sentinel = 'id'
if ((!((aReader)->ReadSentinel(20447438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsString) member of 'IPCPaymentDetails'");
return {};
}
auto maybe___total = IPC::ReadParam<::mozilla::dom::IPCPaymentItem>(aReader);
if (!maybe___total) {
aReader->FatalError("Error deserializing 'total' (IPCPaymentItem) member of 'IPCPaymentDetails'");
return {};
}
auto& _total = *maybe___total;
// Sentinel = 'total'
if ((!((aReader)->ReadSentinel(110035493)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'total' (IPCPaymentItem) member of 'IPCPaymentDetails'");
return {};
}
auto maybe___displayItems = IPC::ReadParam<nsTArray<::mozilla::dom::IPCPaymentItem>>(aReader);
if (!maybe___displayItems) {
aReader->FatalError("Error deserializing 'displayItems' (IPCPaymentItem[]) member of 'IPCPaymentDetails'");
return {};
}
auto& _displayItems = *maybe___displayItems;
// Sentinel = 'displayItems'
if ((!((aReader)->ReadSentinel(541263097)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'displayItems' (IPCPaymentItem[]) member of 'IPCPaymentDetails'");
return {};
}
auto maybe___shippingOptions = IPC::ReadParam<nsTArray<::mozilla::dom::IPCPaymentShippingOption>>(aReader);
if (!maybe___shippingOptions) {
aReader->FatalError("Error deserializing 'shippingOptions' (IPCPaymentShippingOption[]) member of 'IPCPaymentDetails'");
return {};
}
auto& _shippingOptions = *maybe___shippingOptions;
// Sentinel = 'shippingOptions'
if ((!((aReader)->ReadSentinel(845022799)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'shippingOptions' (IPCPaymentShippingOption[]) member of 'IPCPaymentDetails'");
return {};
}
auto maybe___modifiers = IPC::ReadParam<nsTArray<::mozilla::dom::IPCPaymentDetailsModifier>>(aReader);
if (!maybe___modifiers) {
aReader->FatalError("Error deserializing 'modifiers' (IPCPaymentDetailsModifier[]) member of 'IPCPaymentDetails'");
return {};
}
auto& _modifiers = *maybe___modifiers;
// Sentinel = 'modifiers'
if ((!((aReader)->ReadSentinel(313525187)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'modifiers' (IPCPaymentDetailsModifier[]) member of 'IPCPaymentDetails'");
return {};
}
auto maybe___error = IPC::ReadParam<::nsString>(aReader);
if (!maybe___error) {
aReader->FatalError("Error deserializing 'error' (nsString) member of 'IPCPaymentDetails'");
return {};
}
auto& _error = *maybe___error;
// Sentinel = 'error'
if ((!((aReader)->ReadSentinel(107741739)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'error' (nsString) member of 'IPCPaymentDetails'");
return {};
}
auto maybe___shippingAddressErrors = IPC::ReadParam<::nsString>(aReader);
if (!maybe___shippingAddressErrors) {
aReader->FatalError("Error deserializing 'shippingAddressErrors' (nsString) member of 'IPCPaymentDetails'");
return {};
}
auto& _shippingAddressErrors = *maybe___shippingAddressErrors;
// Sentinel = 'shippingAddressErrors'
if ((!((aReader)->ReadSentinel(1588463782)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'shippingAddressErrors' (nsString) member of 'IPCPaymentDetails'");
return {};
}
auto maybe___payerErrors = IPC::ReadParam<::nsString>(aReader);
if (!maybe___payerErrors) {
aReader->FatalError("Error deserializing 'payerErrors' (nsString) member of 'IPCPaymentDetails'");
return {};
}
auto& _payerErrors = *maybe___payerErrors;
// Sentinel = 'payerErrors'
if ((!((aReader)->ReadSentinel(460326047)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'payerErrors' (nsString) member of 'IPCPaymentDetails'");
return {};
}
auto maybe___paymentMethodErrors = IPC::ReadParam<::nsString>(aReader);
if (!maybe___paymentMethodErrors) {
aReader->FatalError("Error deserializing 'paymentMethodErrors' (nsString) member of 'IPCPaymentDetails'");
return {};
}
auto& _paymentMethodErrors = *maybe___paymentMethodErrors;
// Sentinel = 'paymentMethodErrors'
if ((!((aReader)->ReadSentinel(1316751325)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'paymentMethodErrors' (nsString) member of 'IPCPaymentDetails'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_id),
std::move(_total),
std::move(_displayItems),
std::move(_shippingOptions),
std::move(_modifiers),
std::move(_error),
std::move(_shippingAddressErrors),
std::move(_payerErrors),
std::move(_paymentMethodErrors)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentOptions|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentOptions>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestPayerName());
// Sentinel = 'requestPayerName'
(aWriter)->WriteSentinel(952632972);
IPC::WriteParam(aWriter, (aVar).requestPayerEmail());
// Sentinel = 'requestPayerEmail'
(aWriter)->WriteSentinel(1067910899);
IPC::WriteParam(aWriter, (aVar).requestPayerPhone());
// Sentinel = 'requestPayerPhone'
(aWriter)->WriteSentinel(1073153797);
IPC::WriteParam(aWriter, (aVar).requestShipping());
// Sentinel = 'requestShipping'
(aWriter)->WriteSentinel(850986572);
IPC::WriteParam(aWriter, (aVar).requestBillingAddress());
// Sentinel = 'requestBillingAddress'
(aWriter)->WriteSentinel(1591281809);
IPC::WriteParam(aWriter, (aVar).shippingType());
// Sentinel = 'shippingType'
(aWriter)->WriteSentinel(552076549);
}
auto ParamTraits<::mozilla::dom::IPCPaymentOptions>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestPayerName = IPC::ReadParam<bool>(aReader);
if (!maybe___requestPayerName) {
aReader->FatalError("Error deserializing 'requestPayerName' (bool) member of 'IPCPaymentOptions'");
return {};
}
auto& _requestPayerName = *maybe___requestPayerName;
// Sentinel = 'requestPayerName'
if ((!((aReader)->ReadSentinel(952632972)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestPayerName' (bool) member of 'IPCPaymentOptions'");
return {};
}
auto maybe___requestPayerEmail = IPC::ReadParam<bool>(aReader);
if (!maybe___requestPayerEmail) {
aReader->FatalError("Error deserializing 'requestPayerEmail' (bool) member of 'IPCPaymentOptions'");
return {};
}
auto& _requestPayerEmail = *maybe___requestPayerEmail;
// Sentinel = 'requestPayerEmail'
if ((!((aReader)->ReadSentinel(1067910899)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestPayerEmail' (bool) member of 'IPCPaymentOptions'");
return {};
}
auto maybe___requestPayerPhone = IPC::ReadParam<bool>(aReader);
if (!maybe___requestPayerPhone) {
aReader->FatalError("Error deserializing 'requestPayerPhone' (bool) member of 'IPCPaymentOptions'");
return {};
}
auto& _requestPayerPhone = *maybe___requestPayerPhone;
// Sentinel = 'requestPayerPhone'
if ((!((aReader)->ReadSentinel(1073153797)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestPayerPhone' (bool) member of 'IPCPaymentOptions'");
return {};
}
auto maybe___requestShipping = IPC::ReadParam<bool>(aReader);
if (!maybe___requestShipping) {
aReader->FatalError("Error deserializing 'requestShipping' (bool) member of 'IPCPaymentOptions'");
return {};
}
auto& _requestShipping = *maybe___requestShipping;
// Sentinel = 'requestShipping'
if ((!((aReader)->ReadSentinel(850986572)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestShipping' (bool) member of 'IPCPaymentOptions'");
return {};
}
auto maybe___requestBillingAddress = IPC::ReadParam<bool>(aReader);
if (!maybe___requestBillingAddress) {
aReader->FatalError("Error deserializing 'requestBillingAddress' (bool) member of 'IPCPaymentOptions'");
return {};
}
auto& _requestBillingAddress = *maybe___requestBillingAddress;
// Sentinel = 'requestBillingAddress'
if ((!((aReader)->ReadSentinel(1591281809)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestBillingAddress' (bool) member of 'IPCPaymentOptions'");
return {};
}
auto maybe___shippingType = IPC::ReadParam<::nsString>(aReader);
if (!maybe___shippingType) {
aReader->FatalError("Error deserializing 'shippingType' (nsString) member of 'IPCPaymentOptions'");
return {};
}
auto& _shippingType = *maybe___shippingType;
// Sentinel = 'shippingType'
if ((!((aReader)->ReadSentinel(552076549)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'shippingType' (nsString) member of 'IPCPaymentOptions'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestPayerName),
std::move(_requestPayerEmail),
std::move(_requestPayerPhone),
std::move(_requestShipping),
std::move(_requestBillingAddress),
std::move(_shippingType)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentCreateActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentCreateActionRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestId());
// Sentinel = 'requestId'
(aWriter)->WriteSentinel(320799671);
IPC::WriteParam(aWriter, (aVar).topLevelPrincipal());
// Sentinel = 'topLevelPrincipal'
(aWriter)->WriteSentinel(1049167598);
IPC::WriteParam(aWriter, (aVar).methodData());
// Sentinel = 'methodData'
(aWriter)->WriteSentinel(375063548);
IPC::WriteParam(aWriter, (aVar).details());
// Sentinel = 'details'
(aWriter)->WriteSentinel(191824615);
IPC::WriteParam(aWriter, (aVar).options());
// Sentinel = 'options'
(aWriter)->WriteSentinel(204735245);
IPC::WriteParam(aWriter, (aVar).shippingOption());
// Sentinel = 'shippingOption'
(aWriter)->WriteSentinel(739182044);
(aWriter)->WriteBytes((&((aVar).topOuterWindowId())), 8);
// Sentinel = 'topOuterWindowId'
(aWriter)->WriteSentinel(949356168);
}
auto ParamTraits<::mozilla::dom::IPCPaymentCreateActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___requestId) {
aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCreateActionRequest'");
return {};
}
auto& _requestId = *maybe___requestId;
// Sentinel = 'requestId'
if ((!((aReader)->ReadSentinel(320799671)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCreateActionRequest'");
return {};
}
auto maybe___topLevelPrincipal = IPC::ReadParam<RefPtr<::nsIPrincipal>>(aReader);
if (!maybe___topLevelPrincipal) {
aReader->FatalError("Error deserializing 'topLevelPrincipal' (nsIPrincipal) member of 'IPCPaymentCreateActionRequest'");
return {};
}
auto& _topLevelPrincipal = *maybe___topLevelPrincipal;
// Sentinel = 'topLevelPrincipal'
if ((!((aReader)->ReadSentinel(1049167598)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'topLevelPrincipal' (nsIPrincipal) member of 'IPCPaymentCreateActionRequest'");
return {};
}
auto maybe___methodData = IPC::ReadParam<nsTArray<::mozilla::dom::IPCPaymentMethodData>>(aReader);
if (!maybe___methodData) {
aReader->FatalError("Error deserializing 'methodData' (IPCPaymentMethodData[]) member of 'IPCPaymentCreateActionRequest'");
return {};
}
auto& _methodData = *maybe___methodData;
// Sentinel = 'methodData'
if ((!((aReader)->ReadSentinel(375063548)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'methodData' (IPCPaymentMethodData[]) member of 'IPCPaymentCreateActionRequest'");
return {};
}
auto maybe___details = IPC::ReadParam<::mozilla::dom::IPCPaymentDetails>(aReader);
if (!maybe___details) {
aReader->FatalError("Error deserializing 'details' (IPCPaymentDetails) member of 'IPCPaymentCreateActionRequest'");
return {};
}
auto& _details = *maybe___details;
// Sentinel = 'details'
if ((!((aReader)->ReadSentinel(191824615)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'details' (IPCPaymentDetails) member of 'IPCPaymentCreateActionRequest'");
return {};
}
auto maybe___options = IPC::ReadParam<::mozilla::dom::IPCPaymentOptions>(aReader);
if (!maybe___options) {
aReader->FatalError("Error deserializing 'options' (IPCPaymentOptions) member of 'IPCPaymentCreateActionRequest'");
return {};
}
auto& _options = *maybe___options;
// Sentinel = 'options'
if ((!((aReader)->ReadSentinel(204735245)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'options' (IPCPaymentOptions) member of 'IPCPaymentCreateActionRequest'");
return {};
}
auto maybe___shippingOption = IPC::ReadParam<::nsString>(aReader);
if (!maybe___shippingOption) {
aReader->FatalError("Error deserializing 'shippingOption' (nsString) member of 'IPCPaymentCreateActionRequest'");
return {};
}
auto& _shippingOption = *maybe___shippingOption;
// Sentinel = 'shippingOption'
if ((!((aReader)->ReadSentinel(739182044)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'shippingOption' (nsString) member of 'IPCPaymentCreateActionRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::uint64_t{0},
std::move(_requestId),
std::move(_topLevelPrincipal),
std::move(_methodData),
std::move(_details),
std::move(_options),
std::move(_shippingOption)};
if ((!((aReader)->ReadBytesInto((&((result__)->topOuterWindowId())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'topOuterWindowId'
if ((!((aReader)->ReadSentinel(949356168)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentCanMakeActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentCanMakeActionRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestId());
// Sentinel = 'requestId'
(aWriter)->WriteSentinel(320799671);
}
auto ParamTraits<::mozilla::dom::IPCPaymentCanMakeActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___requestId) {
aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCanMakeActionRequest'");
return {};
}
auto& _requestId = *maybe___requestId;
// Sentinel = 'requestId'
if ((!((aReader)->ReadSentinel(320799671)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCanMakeActionRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestId)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentShowActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentShowActionRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestId());
// Sentinel = 'requestId'
(aWriter)->WriteSentinel(320799671);
IPC::WriteParam(aWriter, (aVar).isUpdating());
// Sentinel = 'isUpdating'
(aWriter)->WriteSentinel(376570905);
}
auto ParamTraits<::mozilla::dom::IPCPaymentShowActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___requestId) {
aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentShowActionRequest'");
return {};
}
auto& _requestId = *maybe___requestId;
// Sentinel = 'requestId'
if ((!((aReader)->ReadSentinel(320799671)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentShowActionRequest'");
return {};
}
auto maybe___isUpdating = IPC::ReadParam<bool>(aReader);
if (!maybe___isUpdating) {
aReader->FatalError("Error deserializing 'isUpdating' (bool) member of 'IPCPaymentShowActionRequest'");
return {};
}
auto& _isUpdating = *maybe___isUpdating;
// Sentinel = 'isUpdating'
if ((!((aReader)->ReadSentinel(376570905)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isUpdating' (bool) member of 'IPCPaymentShowActionRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestId),
std::move(_isUpdating)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentAbortActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentAbortActionRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestId());
// Sentinel = 'requestId'
(aWriter)->WriteSentinel(320799671);
}
auto ParamTraits<::mozilla::dom::IPCPaymentAbortActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___requestId) {
aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentAbortActionRequest'");
return {};
}
auto& _requestId = *maybe___requestId;
// Sentinel = 'requestId'
if ((!((aReader)->ReadSentinel(320799671)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentAbortActionRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestId)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentCompleteActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentCompleteActionRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestId());
// Sentinel = 'requestId'
(aWriter)->WriteSentinel(320799671);
IPC::WriteParam(aWriter, (aVar).completeStatus());
// Sentinel = 'completeStatus'
(aWriter)->WriteSentinel(732038622);
}
auto ParamTraits<::mozilla::dom::IPCPaymentCompleteActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___requestId) {
aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCompleteActionRequest'");
return {};
}
auto& _requestId = *maybe___requestId;
// Sentinel = 'requestId'
if ((!((aReader)->ReadSentinel(320799671)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCompleteActionRequest'");
return {};
}
auto maybe___completeStatus = IPC::ReadParam<::nsString>(aReader);
if (!maybe___completeStatus) {
aReader->FatalError("Error deserializing 'completeStatus' (nsString) member of 'IPCPaymentCompleteActionRequest'");
return {};
}
auto& _completeStatus = *maybe___completeStatus;
// Sentinel = 'completeStatus'
if ((!((aReader)->ReadSentinel(732038622)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'completeStatus' (nsString) member of 'IPCPaymentCompleteActionRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestId),
std::move(_completeStatus)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentUpdateActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentUpdateActionRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestId());
// Sentinel = 'requestId'
(aWriter)->WriteSentinel(320799671);
IPC::WriteParam(aWriter, (aVar).details());
// Sentinel = 'details'
(aWriter)->WriteSentinel(191824615);
IPC::WriteParam(aWriter, (aVar).shippingOption());
// Sentinel = 'shippingOption'
(aWriter)->WriteSentinel(739182044);
}
auto ParamTraits<::mozilla::dom::IPCPaymentUpdateActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___requestId) {
aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentUpdateActionRequest'");
return {};
}
auto& _requestId = *maybe___requestId;
// Sentinel = 'requestId'
if ((!((aReader)->ReadSentinel(320799671)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentUpdateActionRequest'");
return {};
}
auto maybe___details = IPC::ReadParam<::mozilla::dom::IPCPaymentDetails>(aReader);
if (!maybe___details) {
aReader->FatalError("Error deserializing 'details' (IPCPaymentDetails) member of 'IPCPaymentUpdateActionRequest'");
return {};
}
auto& _details = *maybe___details;
// Sentinel = 'details'
if ((!((aReader)->ReadSentinel(191824615)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'details' (IPCPaymentDetails) member of 'IPCPaymentUpdateActionRequest'");
return {};
}
auto maybe___shippingOption = IPC::ReadParam<::nsString>(aReader);
if (!maybe___shippingOption) {
aReader->FatalError("Error deserializing 'shippingOption' (nsString) member of 'IPCPaymentUpdateActionRequest'");
return {};
}
auto& _shippingOption = *maybe___shippingOption;
// Sentinel = 'shippingOption'
if ((!((aReader)->ReadSentinel(739182044)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'shippingOption' (nsString) member of 'IPCPaymentUpdateActionRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestId),
std::move(_details),
std::move(_shippingOption)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentCloseActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentCloseActionRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestId());
// Sentinel = 'requestId'
(aWriter)->WriteSentinel(320799671);
}
auto ParamTraits<::mozilla::dom::IPCPaymentCloseActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___requestId) {
aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCloseActionRequest'");
return {};
}
auto& _requestId = *maybe___requestId;
// Sentinel = 'requestId'
if ((!((aReader)->ReadSentinel(320799671)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCloseActionRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestId)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentRetryActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentRetryActionRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestId());
// Sentinel = 'requestId'
(aWriter)->WriteSentinel(320799671);
IPC::WriteParam(aWriter, (aVar).error());
// Sentinel = 'error'
(aWriter)->WriteSentinel(107741739);
IPC::WriteParam(aWriter, (aVar).payerErrors());
// Sentinel = 'payerErrors'
(aWriter)->WriteSentinel(460326047);
IPC::WriteParam(aWriter, (aVar).paymentMethodErrors());
// Sentinel = 'paymentMethodErrors'
(aWriter)->WriteSentinel(1316751325);
IPC::WriteParam(aWriter, (aVar).shippingAddressErrors());
// Sentinel = 'shippingAddressErrors'
(aWriter)->WriteSentinel(1588463782);
}
auto ParamTraits<::mozilla::dom::IPCPaymentRetryActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___requestId) {
aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentRetryActionRequest'");
return {};
}
auto& _requestId = *maybe___requestId;
// Sentinel = 'requestId'
if ((!((aReader)->ReadSentinel(320799671)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentRetryActionRequest'");
return {};
}
auto maybe___error = IPC::ReadParam<::nsString>(aReader);
if (!maybe___error) {
aReader->FatalError("Error deserializing 'error' (nsString) member of 'IPCPaymentRetryActionRequest'");
return {};
}
auto& _error = *maybe___error;
// Sentinel = 'error'
if ((!((aReader)->ReadSentinel(107741739)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'error' (nsString) member of 'IPCPaymentRetryActionRequest'");
return {};
}
auto maybe___payerErrors = IPC::ReadParam<::nsString>(aReader);
if (!maybe___payerErrors) {
aReader->FatalError("Error deserializing 'payerErrors' (nsString) member of 'IPCPaymentRetryActionRequest'");
return {};
}
auto& _payerErrors = *maybe___payerErrors;
// Sentinel = 'payerErrors'
if ((!((aReader)->ReadSentinel(460326047)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'payerErrors' (nsString) member of 'IPCPaymentRetryActionRequest'");
return {};
}
auto maybe___paymentMethodErrors = IPC::ReadParam<::nsString>(aReader);
if (!maybe___paymentMethodErrors) {
aReader->FatalError("Error deserializing 'paymentMethodErrors' (nsString) member of 'IPCPaymentRetryActionRequest'");
return {};
}
auto& _paymentMethodErrors = *maybe___paymentMethodErrors;
// Sentinel = 'paymentMethodErrors'
if ((!((aReader)->ReadSentinel(1316751325)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'paymentMethodErrors' (nsString) member of 'IPCPaymentRetryActionRequest'");
return {};
}
auto maybe___shippingAddressErrors = IPC::ReadParam<::nsString>(aReader);
if (!maybe___shippingAddressErrors) {
aReader->FatalError("Error deserializing 'shippingAddressErrors' (nsString) member of 'IPCPaymentRetryActionRequest'");
return {};
}
auto& _shippingAddressErrors = *maybe___shippingAddressErrors;
// Sentinel = 'shippingAddressErrors'
if ((!((aReader)->ReadSentinel(1588463782)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'shippingAddressErrors' (nsString) member of 'IPCPaymentRetryActionRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestId),
std::move(_error),
std::move(_payerErrors),
std::move(_paymentMethodErrors),
std::move(_shippingAddressErrors)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPCPaymentActionRequest|
//
namespace mozilla {
namespace dom {
auto IPCPaymentActionRequest::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TIPCPaymentCreateActionRequest:
{
(ptr_IPCPaymentCreateActionRequest())->~IPCPaymentCreateActionRequest__tdef();
break;
}
case TIPCPaymentCanMakeActionRequest:
{
(ptr_IPCPaymentCanMakeActionRequest())->~IPCPaymentCanMakeActionRequest__tdef();
break;
}
case TIPCPaymentShowActionRequest:
{
(ptr_IPCPaymentShowActionRequest())->~IPCPaymentShowActionRequest__tdef();
break;
}
case TIPCPaymentAbortActionRequest:
{
(ptr_IPCPaymentAbortActionRequest())->~IPCPaymentAbortActionRequest__tdef();
break;
}
case TIPCPaymentCompleteActionRequest:
{
(ptr_IPCPaymentCompleteActionRequest())->~IPCPaymentCompleteActionRequest__tdef();
break;
}
case TIPCPaymentUpdateActionRequest:
{
(ptr_IPCPaymentUpdateActionRequest())->~IPCPaymentUpdateActionRequest__tdef();
break;
}
case TIPCPaymentCloseActionRequest:
{
(ptr_IPCPaymentCloseActionRequest())->~IPCPaymentCloseActionRequest__tdef();
break;
}
case TIPCPaymentRetryActionRequest:
{
(ptr_IPCPaymentRetryActionRequest())->~IPCPaymentRetryActionRequest__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentCreateActionRequest& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest(aOther);
mType = TIPCPaymentCreateActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentCreateActionRequest&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest(std::move(aOther));
mType = TIPCPaymentCreateActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentCanMakeActionRequest& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest(aOther);
mType = TIPCPaymentCanMakeActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentCanMakeActionRequest&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest(std::move(aOther));
mType = TIPCPaymentCanMakeActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentShowActionRequest& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest(aOther);
mType = TIPCPaymentShowActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentShowActionRequest&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest(std::move(aOther));
mType = TIPCPaymentShowActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentAbortActionRequest& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest(aOther);
mType = TIPCPaymentAbortActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentAbortActionRequest&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest(std::move(aOther));
mType = TIPCPaymentAbortActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentCompleteActionRequest& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest(aOther);
mType = TIPCPaymentCompleteActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentCompleteActionRequest&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest(std::move(aOther));
mType = TIPCPaymentCompleteActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentUpdateActionRequest& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest(aOther);
mType = TIPCPaymentUpdateActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentUpdateActionRequest&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest(std::move(aOther));
mType = TIPCPaymentUpdateActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentCloseActionRequest& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest(aOther);
mType = TIPCPaymentCloseActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentCloseActionRequest&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest(std::move(aOther));
mType = TIPCPaymentCloseActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentRetryActionRequest& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest(aOther);
mType = TIPCPaymentRetryActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentRetryActionRequest&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest(std::move(aOther));
mType = TIPCPaymentRetryActionRequest;
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentActionRequest& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TIPCPaymentCreateActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest((aOther).get_IPCPaymentCreateActionRequest());
break;
}
case TIPCPaymentCanMakeActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest((aOther).get_IPCPaymentCanMakeActionRequest());
break;
}
case TIPCPaymentShowActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest((aOther).get_IPCPaymentShowActionRequest());
break;
}
case TIPCPaymentAbortActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest((aOther).get_IPCPaymentAbortActionRequest());
break;
}
case TIPCPaymentCompleteActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest((aOther).get_IPCPaymentCompleteActionRequest());
break;
}
case TIPCPaymentUpdateActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest((aOther).get_IPCPaymentUpdateActionRequest());
break;
}
case TIPCPaymentCloseActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest((aOther).get_IPCPaymentCloseActionRequest());
break;
}
case TIPCPaymentRetryActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest((aOther).get_IPCPaymentRetryActionRequest());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentActionRequest&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TIPCPaymentCreateActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest(std::move((aOther).get_IPCPaymentCreateActionRequest()));
(aOther).MaybeDestroy();
break;
}
case TIPCPaymentCanMakeActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest(std::move((aOther).get_IPCPaymentCanMakeActionRequest()));
(aOther).MaybeDestroy();
break;
}
case TIPCPaymentShowActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest(std::move((aOther).get_IPCPaymentShowActionRequest()));
(aOther).MaybeDestroy();
break;
}
case TIPCPaymentAbortActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest(std::move((aOther).get_IPCPaymentAbortActionRequest()));
(aOther).MaybeDestroy();
break;
}
case TIPCPaymentCompleteActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest(std::move((aOther).get_IPCPaymentCompleteActionRequest()));
(aOther).MaybeDestroy();
break;
}
case TIPCPaymentUpdateActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest(std::move((aOther).get_IPCPaymentUpdateActionRequest()));
(aOther).MaybeDestroy();
break;
}
case TIPCPaymentCloseActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest(std::move((aOther).get_IPCPaymentCloseActionRequest()));
(aOther).MaybeDestroy();
break;
}
case TIPCPaymentRetryActionRequest:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest(std::move((aOther).get_IPCPaymentRetryActionRequest()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
IPCPaymentActionRequest::~IPCPaymentActionRequest()
{
MaybeDestroy();
}
auto IPCPaymentActionRequest::operator=(const IPCPaymentCreateActionRequest& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest(aRhs);
mType = TIPCPaymentCreateActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(IPCPaymentCreateActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest(std::move(aRhs));
mType = TIPCPaymentCreateActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(const IPCPaymentCanMakeActionRequest& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest(aRhs);
mType = TIPCPaymentCanMakeActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(IPCPaymentCanMakeActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest(std::move(aRhs));
mType = TIPCPaymentCanMakeActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(const IPCPaymentShowActionRequest& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest(aRhs);
mType = TIPCPaymentShowActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(IPCPaymentShowActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest(std::move(aRhs));
mType = TIPCPaymentShowActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(const IPCPaymentAbortActionRequest& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest(aRhs);
mType = TIPCPaymentAbortActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(IPCPaymentAbortActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest(std::move(aRhs));
mType = TIPCPaymentAbortActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(const IPCPaymentCompleteActionRequest& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest(aRhs);
mType = TIPCPaymentCompleteActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(IPCPaymentCompleteActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest(std::move(aRhs));
mType = TIPCPaymentCompleteActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(const IPCPaymentUpdateActionRequest& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest(aRhs);
mType = TIPCPaymentUpdateActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(IPCPaymentUpdateActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest(std::move(aRhs));
mType = TIPCPaymentUpdateActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(const IPCPaymentCloseActionRequest& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest(aRhs);
mType = TIPCPaymentCloseActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(IPCPaymentCloseActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest(std::move(aRhs));
mType = TIPCPaymentCloseActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(const IPCPaymentRetryActionRequest& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest(aRhs);
mType = TIPCPaymentRetryActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(IPCPaymentRetryActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest(std::move(aRhs));
mType = TIPCPaymentRetryActionRequest;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(const IPCPaymentActionRequest& aRhs) -> IPCPaymentActionRequest&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TIPCPaymentCreateActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest((aRhs).get_IPCPaymentCreateActionRequest());
break;
}
case TIPCPaymentCanMakeActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest((aRhs).get_IPCPaymentCanMakeActionRequest());
break;
}
case TIPCPaymentShowActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest((aRhs).get_IPCPaymentShowActionRequest());
break;
}
case TIPCPaymentAbortActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest((aRhs).get_IPCPaymentAbortActionRequest());
break;
}
case TIPCPaymentCompleteActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest((aRhs).get_IPCPaymentCompleteActionRequest());
break;
}
case TIPCPaymentUpdateActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest((aRhs).get_IPCPaymentUpdateActionRequest());
break;
}
case TIPCPaymentCloseActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest((aRhs).get_IPCPaymentCloseActionRequest());
break;
}
case TIPCPaymentRetryActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest((aRhs).get_IPCPaymentRetryActionRequest());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto IPCPaymentActionRequest::operator=(IPCPaymentActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TIPCPaymentCreateActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest(std::move((aRhs).get_IPCPaymentCreateActionRequest()));
(aRhs).MaybeDestroy();
break;
}
case TIPCPaymentCanMakeActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest(std::move((aRhs).get_IPCPaymentCanMakeActionRequest()));
(aRhs).MaybeDestroy();
break;
}
case TIPCPaymentShowActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest(std::move((aRhs).get_IPCPaymentShowActionRequest()));
(aRhs).MaybeDestroy();
break;
}
case TIPCPaymentAbortActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest(std::move((aRhs).get_IPCPaymentAbortActionRequest()));
(aRhs).MaybeDestroy();
break;
}
case TIPCPaymentCompleteActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest(std::move((aRhs).get_IPCPaymentCompleteActionRequest()));
(aRhs).MaybeDestroy();
break;
}
case TIPCPaymentUpdateActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest(std::move((aRhs).get_IPCPaymentUpdateActionRequest()));
(aRhs).MaybeDestroy();
break;
}
case TIPCPaymentCloseActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest(std::move((aRhs).get_IPCPaymentCloseActionRequest()));
(aRhs).MaybeDestroy();
break;
}
case TIPCPaymentRetryActionRequest:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest(std::move((aRhs).get_IPCPaymentRetryActionRequest()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentActionRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::IPCPaymentActionRequest union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'IPCPaymentActionRequest'
(aWriter)->WriteSentinel(1725761794);
switch (type) {
case union__::TIPCPaymentCreateActionRequest:
{
IPC::WriteParam(aWriter, (aVar).get_IPCPaymentCreateActionRequest());
// Sentinel = 'TIPCPaymentCreateActionRequest'
(aWriter)->WriteSentinel(2905344938);
return;
}
case union__::TIPCPaymentCanMakeActionRequest:
{
IPC::WriteParam(aWriter, (aVar).get_IPCPaymentCanMakeActionRequest());
// Sentinel = 'TIPCPaymentCanMakeActionRequest'
(aWriter)->WriteSentinel(3058306022);
return;
}
case union__::TIPCPaymentShowActionRequest:
{
IPC::WriteParam(aWriter, (aVar).get_IPCPaymentShowActionRequest());
// Sentinel = 'TIPCPaymentShowActionRequest'
(aWriter)->WriteSentinel(2550139639);
return;
}
case union__::TIPCPaymentAbortActionRequest:
{
IPC::WriteParam(aWriter, (aVar).get_IPCPaymentAbortActionRequest());
// Sentinel = 'TIPCPaymentAbortActionRequest'
(aWriter)->WriteSentinel(2719157070);
return;
}
case union__::TIPCPaymentCompleteActionRequest:
{
IPC::WriteParam(aWriter, (aVar).get_IPCPaymentCompleteActionRequest());
// Sentinel = 'TIPCPaymentCompleteActionRequest'
(aWriter)->WriteSentinel(3341159567);
return;
}
case union__::TIPCPaymentUpdateActionRequest:
{
IPC::WriteParam(aWriter, (aVar).get_IPCPaymentUpdateActionRequest());
// Sentinel = 'TIPCPaymentUpdateActionRequest'
(aWriter)->WriteSentinel(2924284857);
return;
}
case union__::TIPCPaymentCloseActionRequest:
{
IPC::WriteParam(aWriter, (aVar).get_IPCPaymentCloseActionRequest());
// Sentinel = 'TIPCPaymentCloseActionRequest'
(aWriter)->WriteSentinel(2719877964);
return;
}
case union__::TIPCPaymentRetryActionRequest:
{
IPC::WriteParam(aWriter, (aVar).get_IPCPaymentRetryActionRequest());
// Sentinel = 'TIPCPaymentRetryActionRequest'
(aWriter)->WriteSentinel(2752383852);
return;
}
default:
{
aWriter->FatalError("unknown variant of union IPCPaymentActionRequest");
return;
}
}
}
auto ParamTraits<::mozilla::dom::IPCPaymentActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::IPCPaymentActionRequest union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union IPCPaymentActionRequest");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'IPCPaymentActionRequest'
if ((!((aReader)->ReadSentinel(1725761794)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union IPCPaymentActionRequest");
return {};
}
switch (type) {
case union__::TIPCPaymentCreateActionRequest:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentCreateActionRequest>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCPaymentCreateActionRequest of union IPCPaymentActionRequest");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCPaymentCreateActionRequest'
if ((!((aReader)->ReadSentinel(2905344938)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentCreateActionRequest of union IPCPaymentActionRequest");
return {};
}
return std::move(tmp);
}
case union__::TIPCPaymentCanMakeActionRequest:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentCanMakeActionRequest>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCPaymentCanMakeActionRequest of union IPCPaymentActionRequest");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCPaymentCanMakeActionRequest'
if ((!((aReader)->ReadSentinel(3058306022)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentCanMakeActionRequest of union IPCPaymentActionRequest");
return {};
}
return std::move(tmp);
}
case union__::TIPCPaymentShowActionRequest:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentShowActionRequest>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCPaymentShowActionRequest of union IPCPaymentActionRequest");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCPaymentShowActionRequest'
if ((!((aReader)->ReadSentinel(2550139639)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentShowActionRequest of union IPCPaymentActionRequest");
return {};
}
return std::move(tmp);
}
case union__::TIPCPaymentAbortActionRequest:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentAbortActionRequest>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCPaymentAbortActionRequest of union IPCPaymentActionRequest");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCPaymentAbortActionRequest'
if ((!((aReader)->ReadSentinel(2719157070)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentAbortActionRequest of union IPCPaymentActionRequest");
return {};
}
return std::move(tmp);
}
case union__::TIPCPaymentCompleteActionRequest:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentCompleteActionRequest>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCPaymentCompleteActionRequest of union IPCPaymentActionRequest");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCPaymentCompleteActionRequest'
if ((!((aReader)->ReadSentinel(3341159567)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentCompleteActionRequest of union IPCPaymentActionRequest");
return {};
}
return std::move(tmp);
}
case union__::TIPCPaymentUpdateActionRequest:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentUpdateActionRequest>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCPaymentUpdateActionRequest of union IPCPaymentActionRequest");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCPaymentUpdateActionRequest'
if ((!((aReader)->ReadSentinel(2924284857)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentUpdateActionRequest of union IPCPaymentActionRequest");
return {};
}
return std::move(tmp);
}
case union__::TIPCPaymentCloseActionRequest:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentCloseActionRequest>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCPaymentCloseActionRequest of union IPCPaymentActionRequest");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCPaymentCloseActionRequest'
if ((!((aReader)->ReadSentinel(2719877964)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentCloseActionRequest of union IPCPaymentActionRequest");
return {};
}
return std::move(tmp);
}
case union__::TIPCPaymentRetryActionRequest:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentRetryActionRequest>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCPaymentRetryActionRequest of union IPCPaymentActionRequest");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCPaymentRetryActionRequest'
if ((!((aReader)->ReadSentinel(2752383852)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentRetryActionRequest of union IPCPaymentActionRequest");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union IPCPaymentActionRequest");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentCanMakeActionResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentCanMakeActionResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestId());
// Sentinel = 'requestId'
(aWriter)->WriteSentinel(320799671);
IPC::WriteParam(aWriter, (aVar).result());
// Sentinel = 'result'
(aWriter)->WriteSentinel(153223840);
}
auto ParamTraits<::mozilla::dom::IPCPaymentCanMakeActionResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___requestId) {
aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCanMakeActionResponse'");
return {};
}
auto& _requestId = *maybe___requestId;
// Sentinel = 'requestId'
if ((!((aReader)->ReadSentinel(320799671)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCanMakeActionResponse'");
return {};
}
auto maybe___result = IPC::ReadParam<bool>(aReader);
if (!maybe___result) {
aReader->FatalError("Error deserializing 'result' (bool) member of 'IPCPaymentCanMakeActionResponse'");
return {};
}
auto& _result = *maybe___result;
// Sentinel = 'result'
if ((!((aReader)->ReadSentinel(153223840)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'result' (bool) member of 'IPCPaymentCanMakeActionResponse'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestId),
std::move(_result)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentAddress|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentAddress>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).country());
// Sentinel = 'country'
(aWriter)->WriteSentinel(202375957);
IPC::WriteParam(aWriter, (aVar).addressLine());
// Sentinel = 'addressLine'
(aWriter)->WriteSentinel(445777007);
IPC::WriteParam(aWriter, (aVar).region());
// Sentinel = 'region'
(aWriter)->WriteSentinel(147718789);
IPC::WriteParam(aWriter, (aVar).regionCode());
// Sentinel = 'regionCode'
(aWriter)->WriteSentinel(375915520);
IPC::WriteParam(aWriter, (aVar).city());
// Sentinel = 'city'
(aWriter)->WriteSentinel(69992890);
IPC::WriteParam(aWriter, (aVar).dependentLocality());
// Sentinel = 'dependentLocality'
(aWriter)->WriteSentinel(1040451321);
IPC::WriteParam(aWriter, (aVar).postalCode());
// Sentinel = 'postalCode'
(aWriter)->WriteSentinel(385680399);
IPC::WriteParam(aWriter, (aVar).sortingCode());
// Sentinel = 'sortingCode'
(aWriter)->WriteSentinel(468714626);
IPC::WriteParam(aWriter, (aVar).organization());
// Sentinel = 'organization'
(aWriter)->WriteSentinel(553387286);
IPC::WriteParam(aWriter, (aVar).recipient());
// Sentinel = 'recipient'
(aWriter)->WriteSentinel(313590724);
IPC::WriteParam(aWriter, (aVar).phone());
// Sentinel = 'phone'
(aWriter)->WriteSentinel(107151899);
}
auto ParamTraits<::mozilla::dom::IPCPaymentAddress>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___country = IPC::ReadParam<::nsString>(aReader);
if (!maybe___country) {
aReader->FatalError("Error deserializing 'country' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto& _country = *maybe___country;
// Sentinel = 'country'
if ((!((aReader)->ReadSentinel(202375957)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'country' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto maybe___addressLine = IPC::ReadParam<nsTArray<::nsString>>(aReader);
if (!maybe___addressLine) {
aReader->FatalError("Error deserializing 'addressLine' (nsString[]) member of 'IPCPaymentAddress'");
return {};
}
auto& _addressLine = *maybe___addressLine;
// Sentinel = 'addressLine'
if ((!((aReader)->ReadSentinel(445777007)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'addressLine' (nsString[]) member of 'IPCPaymentAddress'");
return {};
}
auto maybe___region = IPC::ReadParam<::nsString>(aReader);
if (!maybe___region) {
aReader->FatalError("Error deserializing 'region' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto& _region = *maybe___region;
// Sentinel = 'region'
if ((!((aReader)->ReadSentinel(147718789)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'region' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto maybe___regionCode = IPC::ReadParam<::nsString>(aReader);
if (!maybe___regionCode) {
aReader->FatalError("Error deserializing 'regionCode' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto& _regionCode = *maybe___regionCode;
// Sentinel = 'regionCode'
if ((!((aReader)->ReadSentinel(375915520)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'regionCode' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto maybe___city = IPC::ReadParam<::nsString>(aReader);
if (!maybe___city) {
aReader->FatalError("Error deserializing 'city' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto& _city = *maybe___city;
// Sentinel = 'city'
if ((!((aReader)->ReadSentinel(69992890)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'city' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto maybe___dependentLocality = IPC::ReadParam<::nsString>(aReader);
if (!maybe___dependentLocality) {
aReader->FatalError("Error deserializing 'dependentLocality' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto& _dependentLocality = *maybe___dependentLocality;
// Sentinel = 'dependentLocality'
if ((!((aReader)->ReadSentinel(1040451321)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'dependentLocality' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto maybe___postalCode = IPC::ReadParam<::nsString>(aReader);
if (!maybe___postalCode) {
aReader->FatalError("Error deserializing 'postalCode' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto& _postalCode = *maybe___postalCode;
// Sentinel = 'postalCode'
if ((!((aReader)->ReadSentinel(385680399)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'postalCode' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto maybe___sortingCode = IPC::ReadParam<::nsString>(aReader);
if (!maybe___sortingCode) {
aReader->FatalError("Error deserializing 'sortingCode' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto& _sortingCode = *maybe___sortingCode;
// Sentinel = 'sortingCode'
if ((!((aReader)->ReadSentinel(468714626)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'sortingCode' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto maybe___organization = IPC::ReadParam<::nsString>(aReader);
if (!maybe___organization) {
aReader->FatalError("Error deserializing 'organization' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto& _organization = *maybe___organization;
// Sentinel = 'organization'
if ((!((aReader)->ReadSentinel(553387286)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'organization' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto maybe___recipient = IPC::ReadParam<::nsString>(aReader);
if (!maybe___recipient) {
aReader->FatalError("Error deserializing 'recipient' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto& _recipient = *maybe___recipient;
// Sentinel = 'recipient'
if ((!((aReader)->ReadSentinel(313590724)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'recipient' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto maybe___phone = IPC::ReadParam<::nsString>(aReader);
if (!maybe___phone) {
aReader->FatalError("Error deserializing 'phone' (nsString) member of 'IPCPaymentAddress'");
return {};
}
auto& _phone = *maybe___phone;
// Sentinel = 'phone'
if ((!((aReader)->ReadSentinel(107151899)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'phone' (nsString) member of 'IPCPaymentAddress'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_country),
std::move(_addressLine),
std::move(_region),
std::move(_regionCode),
std::move(_city),
std::move(_dependentLocality),
std::move(_postalCode),
std::move(_sortingCode),
std::move(_organization),
std::move(_recipient),
std::move(_phone)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCGeneralResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCGeneralResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).data());
// Sentinel = 'data'
(aWriter)->WriteSentinel(67109275);
}
auto ParamTraits<::mozilla::dom::IPCGeneralResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___data = IPC::ReadParam<::nsString>(aReader);
if (!maybe___data) {
aReader->FatalError("Error deserializing 'data' (nsString) member of 'IPCGeneralResponse'");
return {};
}
auto& _data = *maybe___data;
// Sentinel = 'data'
if ((!((aReader)->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'data' (nsString) member of 'IPCGeneralResponse'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_data)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCBasicCardResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCBasicCardResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).cardholderName());
// Sentinel = 'cardholderName'
(aWriter)->WriteSentinel(709756314);
IPC::WriteParam(aWriter, (aVar).cardNumber());
// Sentinel = 'cardNumber'
(aWriter)->WriteSentinel(365954052);
IPC::WriteParam(aWriter, (aVar).expiryMonth());
// Sentinel = 'expiryMonth'
(aWriter)->WriteSentinel(471139496);
IPC::WriteParam(aWriter, (aVar).expiryYear());
// Sentinel = 'expiryYear'
(aWriter)->WriteSentinel(392365107);
IPC::WriteParam(aWriter, (aVar).cardSecurityCode());
// Sentinel = 'cardSecurityCode'
(aWriter)->WriteSentinel(914294382);
IPC::WriteParam(aWriter, (aVar).billingAddress());
// Sentinel = 'billingAddress'
(aWriter)->WriteSentinel(705037736);
}
auto ParamTraits<::mozilla::dom::IPCBasicCardResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___cardholderName = IPC::ReadParam<::nsString>(aReader);
if (!maybe___cardholderName) {
aReader->FatalError("Error deserializing 'cardholderName' (nsString) member of 'IPCBasicCardResponse'");
return {};
}
auto& _cardholderName = *maybe___cardholderName;
// Sentinel = 'cardholderName'
if ((!((aReader)->ReadSentinel(709756314)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cardholderName' (nsString) member of 'IPCBasicCardResponse'");
return {};
}
auto maybe___cardNumber = IPC::ReadParam<::nsString>(aReader);
if (!maybe___cardNumber) {
aReader->FatalError("Error deserializing 'cardNumber' (nsString) member of 'IPCBasicCardResponse'");
return {};
}
auto& _cardNumber = *maybe___cardNumber;
// Sentinel = 'cardNumber'
if ((!((aReader)->ReadSentinel(365954052)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cardNumber' (nsString) member of 'IPCBasicCardResponse'");
return {};
}
auto maybe___expiryMonth = IPC::ReadParam<::nsString>(aReader);
if (!maybe___expiryMonth) {
aReader->FatalError("Error deserializing 'expiryMonth' (nsString) member of 'IPCBasicCardResponse'");
return {};
}
auto& _expiryMonth = *maybe___expiryMonth;
// Sentinel = 'expiryMonth'
if ((!((aReader)->ReadSentinel(471139496)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'expiryMonth' (nsString) member of 'IPCBasicCardResponse'");
return {};
}
auto maybe___expiryYear = IPC::ReadParam<::nsString>(aReader);
if (!maybe___expiryYear) {
aReader->FatalError("Error deserializing 'expiryYear' (nsString) member of 'IPCBasicCardResponse'");
return {};
}
auto& _expiryYear = *maybe___expiryYear;
// Sentinel = 'expiryYear'
if ((!((aReader)->ReadSentinel(392365107)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'expiryYear' (nsString) member of 'IPCBasicCardResponse'");
return {};
}
auto maybe___cardSecurityCode = IPC::ReadParam<::nsString>(aReader);
if (!maybe___cardSecurityCode) {
aReader->FatalError("Error deserializing 'cardSecurityCode' (nsString) member of 'IPCBasicCardResponse'");
return {};
}
auto& _cardSecurityCode = *maybe___cardSecurityCode;
// Sentinel = 'cardSecurityCode'
if ((!((aReader)->ReadSentinel(914294382)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cardSecurityCode' (nsString) member of 'IPCBasicCardResponse'");
return {};
}
auto maybe___billingAddress = IPC::ReadParam<::mozilla::dom::IPCPaymentAddress>(aReader);
if (!maybe___billingAddress) {
aReader->FatalError("Error deserializing 'billingAddress' (IPCPaymentAddress) member of 'IPCBasicCardResponse'");
return {};
}
auto& _billingAddress = *maybe___billingAddress;
// Sentinel = 'billingAddress'
if ((!((aReader)->ReadSentinel(705037736)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'billingAddress' (IPCPaymentAddress) member of 'IPCBasicCardResponse'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_cardholderName),
std::move(_cardNumber),
std::move(_expiryMonth),
std::move(_expiryYear),
std::move(_cardSecurityCode),
std::move(_billingAddress)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPCPaymentResponseData|
//
namespace mozilla {
namespace dom {
auto IPCPaymentResponseData::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TIPCGeneralResponse:
{
(ptr_IPCGeneralResponse())->~IPCGeneralResponse__tdef();
break;
}
case TIPCBasicCardResponse:
{
(ptr_IPCBasicCardResponse())->~IPCBasicCardResponse__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT IPCPaymentResponseData::IPCPaymentResponseData(const IPCGeneralResponse& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse(aOther);
mType = TIPCGeneralResponse;
}
MOZ_IMPLICIT IPCPaymentResponseData::IPCPaymentResponseData(IPCGeneralResponse&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse(std::move(aOther));
mType = TIPCGeneralResponse;
}
MOZ_IMPLICIT IPCPaymentResponseData::IPCPaymentResponseData(const IPCBasicCardResponse& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse(aOther);
mType = TIPCBasicCardResponse;
}
MOZ_IMPLICIT IPCPaymentResponseData::IPCPaymentResponseData(IPCBasicCardResponse&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse(std::move(aOther));
mType = TIPCBasicCardResponse;
}
MOZ_IMPLICIT IPCPaymentResponseData::IPCPaymentResponseData(const IPCPaymentResponseData& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TIPCGeneralResponse:
{
new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse((aOther).get_IPCGeneralResponse());
break;
}
case TIPCBasicCardResponse:
{
new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse((aOther).get_IPCBasicCardResponse());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT IPCPaymentResponseData::IPCPaymentResponseData(IPCPaymentResponseData&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TIPCGeneralResponse:
{
new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse(std::move((aOther).get_IPCGeneralResponse()));
(aOther).MaybeDestroy();
break;
}
case TIPCBasicCardResponse:
{
new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse(std::move((aOther).get_IPCBasicCardResponse()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
IPCPaymentResponseData::~IPCPaymentResponseData()
{
MaybeDestroy();
}
auto IPCPaymentResponseData::operator=(const IPCGeneralResponse& aRhs) -> IPCPaymentResponseData&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse(aRhs);
mType = TIPCGeneralResponse;
return (*(this));
}
auto IPCPaymentResponseData::operator=(IPCGeneralResponse&& aRhs) -> IPCPaymentResponseData&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse(std::move(aRhs));
mType = TIPCGeneralResponse;
return (*(this));
}
auto IPCPaymentResponseData::operator=(const IPCBasicCardResponse& aRhs) -> IPCPaymentResponseData&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse(aRhs);
mType = TIPCBasicCardResponse;
return (*(this));
}
auto IPCPaymentResponseData::operator=(IPCBasicCardResponse&& aRhs) -> IPCPaymentResponseData&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse(std::move(aRhs));
mType = TIPCBasicCardResponse;
return (*(this));
}
auto IPCPaymentResponseData::operator=(const IPCPaymentResponseData& aRhs) -> IPCPaymentResponseData&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TIPCGeneralResponse:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse((aRhs).get_IPCGeneralResponse());
break;
}
case TIPCBasicCardResponse:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse((aRhs).get_IPCBasicCardResponse());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto IPCPaymentResponseData::operator=(IPCPaymentResponseData&& aRhs) -> IPCPaymentResponseData&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TIPCGeneralResponse:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse(std::move((aRhs).get_IPCGeneralResponse()));
(aRhs).MaybeDestroy();
break;
}
case TIPCBasicCardResponse:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse(std::move((aRhs).get_IPCBasicCardResponse()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentResponseData>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::IPCPaymentResponseData union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'IPCPaymentResponseData'
(aWriter)->WriteSentinel(1590954116);
switch (type) {
case union__::TIPCGeneralResponse:
{
IPC::WriteParam(aWriter, (aVar).get_IPCGeneralResponse());
// Sentinel = 'TIPCGeneralResponse'
(aWriter)->WriteSentinel(1140066110);
return;
}
case union__::TIPCBasicCardResponse:
{
IPC::WriteParam(aWriter, (aVar).get_IPCBasicCardResponse());
// Sentinel = 'TIPCBasicCardResponse'
(aWriter)->WriteSentinel(1360267228);
return;
}
default:
{
aWriter->FatalError("unknown variant of union IPCPaymentResponseData");
return;
}
}
}
auto ParamTraits<::mozilla::dom::IPCPaymentResponseData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::IPCPaymentResponseData union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union IPCPaymentResponseData");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'IPCPaymentResponseData'
if ((!((aReader)->ReadSentinel(1590954116)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union IPCPaymentResponseData");
return {};
}
switch (type) {
case union__::TIPCGeneralResponse:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCGeneralResponse>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCGeneralResponse of union IPCPaymentResponseData");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCGeneralResponse'
if ((!((aReader)->ReadSentinel(1140066110)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCGeneralResponse of union IPCPaymentResponseData");
return {};
}
return std::move(tmp);
}
case union__::TIPCBasicCardResponse:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCBasicCardResponse>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCBasicCardResponse of union IPCPaymentResponseData");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCBasicCardResponse'
if ((!((aReader)->ReadSentinel(1360267228)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCBasicCardResponse of union IPCPaymentResponseData");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union IPCPaymentResponseData");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentShowActionResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentShowActionResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestId());
// Sentinel = 'requestId'
(aWriter)->WriteSentinel(320799671);
IPC::WriteParam(aWriter, (aVar).methodName());
// Sentinel = 'methodName'
(aWriter)->WriteSentinel(377029635);
IPC::WriteParam(aWriter, (aVar).data());
// Sentinel = 'data'
(aWriter)->WriteSentinel(67109275);
IPC::WriteParam(aWriter, (aVar).payerName());
// Sentinel = 'payerName'
(aWriter)->WriteSentinel(310510499);
IPC::WriteParam(aWriter, (aVar).payerEmail());
// Sentinel = 'payerEmail'
(aWriter)->WriteSentinel(376964106);
IPC::WriteParam(aWriter, (aVar).payerPhone());
// Sentinel = 'payerPhone'
(aWriter)->WriteSentinel(382207004);
(aWriter)->WriteBytes((&((aVar).status())), 4);
// Sentinel = 'status'
(aWriter)->WriteSentinel(154731173);
}
auto ParamTraits<::mozilla::dom::IPCPaymentShowActionResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___requestId) {
aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentShowActionResponse'");
return {};
}
auto& _requestId = *maybe___requestId;
// Sentinel = 'requestId'
if ((!((aReader)->ReadSentinel(320799671)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentShowActionResponse'");
return {};
}
auto maybe___methodName = IPC::ReadParam<::nsString>(aReader);
if (!maybe___methodName) {
aReader->FatalError("Error deserializing 'methodName' (nsString) member of 'IPCPaymentShowActionResponse'");
return {};
}
auto& _methodName = *maybe___methodName;
// Sentinel = 'methodName'
if ((!((aReader)->ReadSentinel(377029635)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'methodName' (nsString) member of 'IPCPaymentShowActionResponse'");
return {};
}
auto maybe___data = IPC::ReadParam<::mozilla::dom::IPCPaymentResponseData>(aReader);
if (!maybe___data) {
aReader->FatalError("Error deserializing 'data' (IPCPaymentResponseData) member of 'IPCPaymentShowActionResponse'");
return {};
}
auto& _data = *maybe___data;
// Sentinel = 'data'
if ((!((aReader)->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'data' (IPCPaymentResponseData) member of 'IPCPaymentShowActionResponse'");
return {};
}
auto maybe___payerName = IPC::ReadParam<::nsString>(aReader);
if (!maybe___payerName) {
aReader->FatalError("Error deserializing 'payerName' (nsString) member of 'IPCPaymentShowActionResponse'");
return {};
}
auto& _payerName = *maybe___payerName;
// Sentinel = 'payerName'
if ((!((aReader)->ReadSentinel(310510499)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'payerName' (nsString) member of 'IPCPaymentShowActionResponse'");
return {};
}
auto maybe___payerEmail = IPC::ReadParam<::nsString>(aReader);
if (!maybe___payerEmail) {
aReader->FatalError("Error deserializing 'payerEmail' (nsString) member of 'IPCPaymentShowActionResponse'");
return {};
}
auto& _payerEmail = *maybe___payerEmail;
// Sentinel = 'payerEmail'
if ((!((aReader)->ReadSentinel(376964106)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'payerEmail' (nsString) member of 'IPCPaymentShowActionResponse'");
return {};
}
auto maybe___payerPhone = IPC::ReadParam<::nsString>(aReader);
if (!maybe___payerPhone) {
aReader->FatalError("Error deserializing 'payerPhone' (nsString) member of 'IPCPaymentShowActionResponse'");
return {};
}
auto& _payerPhone = *maybe___payerPhone;
// Sentinel = 'payerPhone'
if ((!((aReader)->ReadSentinel(382207004)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'payerPhone' (nsString) member of 'IPCPaymentShowActionResponse'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestId),
::uint32_t{0},
std::move(_methodName),
std::move(_data),
std::move(_payerName),
std::move(_payerEmail),
std::move(_payerPhone)};
if ((!((aReader)->ReadBytesInto((&((result__)->status())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'status'
if ((!((aReader)->ReadSentinel(154731173)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentAbortActionResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentAbortActionResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestId());
// Sentinel = 'requestId'
(aWriter)->WriteSentinel(320799671);
IPC::WriteParam(aWriter, (aVar).isSucceeded());
// Sentinel = 'isSucceeded'
(aWriter)->WriteSentinel(445449314);
}
auto ParamTraits<::mozilla::dom::IPCPaymentAbortActionResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___requestId) {
aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentAbortActionResponse'");
return {};
}
auto& _requestId = *maybe___requestId;
// Sentinel = 'requestId'
if ((!((aReader)->ReadSentinel(320799671)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentAbortActionResponse'");
return {};
}
auto maybe___isSucceeded = IPC::ReadParam<bool>(aReader);
if (!maybe___isSucceeded) {
aReader->FatalError("Error deserializing 'isSucceeded' (bool) member of 'IPCPaymentAbortActionResponse'");
return {};
}
auto& _isSucceeded = *maybe___isSucceeded;
// Sentinel = 'isSucceeded'
if ((!((aReader)->ReadSentinel(445449314)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isSucceeded' (bool) member of 'IPCPaymentAbortActionResponse'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestId),
std::move(_isSucceeded)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentCompleteActionResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentCompleteActionResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestId());
// Sentinel = 'requestId'
(aWriter)->WriteSentinel(320799671);
IPC::WriteParam(aWriter, (aVar).isCompleted());
// Sentinel = 'isCompleted'
(aWriter)->WriteSentinel(448005242);
}
auto ParamTraits<::mozilla::dom::IPCPaymentCompleteActionResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
if (!maybe___requestId) {
aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCompleteActionResponse'");
return {};
}
auto& _requestId = *maybe___requestId;
// Sentinel = 'requestId'
if ((!((aReader)->ReadSentinel(320799671)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCompleteActionResponse'");
return {};
}
auto maybe___isCompleted = IPC::ReadParam<bool>(aReader);
if (!maybe___isCompleted) {
aReader->FatalError("Error deserializing 'isCompleted' (bool) member of 'IPCPaymentCompleteActionResponse'");
return {};
}
auto& _isCompleted = *maybe___isCompleted;
// Sentinel = 'isCompleted'
if ((!((aReader)->ReadSentinel(448005242)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isCompleted' (bool) member of 'IPCPaymentCompleteActionResponse'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestId),
std::move(_isCompleted)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPCPaymentActionResponse|
//
namespace mozilla {
namespace dom {
auto IPCPaymentActionResponse::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TIPCPaymentCanMakeActionResponse:
{
(ptr_IPCPaymentCanMakeActionResponse())->~IPCPaymentCanMakeActionResponse__tdef();
break;
}
case TIPCPaymentShowActionResponse:
{
(ptr_IPCPaymentShowActionResponse())->~IPCPaymentShowActionResponse__tdef();
break;
}
case TIPCPaymentAbortActionResponse:
{
(ptr_IPCPaymentAbortActionResponse())->~IPCPaymentAbortActionResponse__tdef();
break;
}
case TIPCPaymentCompleteActionResponse:
{
(ptr_IPCPaymentCompleteActionResponse())->~IPCPaymentCompleteActionResponse__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(const IPCPaymentCanMakeActionResponse& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse(aOther);
mType = TIPCPaymentCanMakeActionResponse;
}
MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(IPCPaymentCanMakeActionResponse&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse(std::move(aOther));
mType = TIPCPaymentCanMakeActionResponse;
}
MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(const IPCPaymentShowActionResponse& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse(aOther);
mType = TIPCPaymentShowActionResponse;
}
MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(IPCPaymentShowActionResponse&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse(std::move(aOther));
mType = TIPCPaymentShowActionResponse;
}
MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(const IPCPaymentAbortActionResponse& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse(aOther);
mType = TIPCPaymentAbortActionResponse;
}
MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(IPCPaymentAbortActionResponse&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse(std::move(aOther));
mType = TIPCPaymentAbortActionResponse;
}
MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(const IPCPaymentCompleteActionResponse& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse(aOther);
mType = TIPCPaymentCompleteActionResponse;
}
MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(IPCPaymentCompleteActionResponse&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse(std::move(aOther));
mType = TIPCPaymentCompleteActionResponse;
}
MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(const IPCPaymentActionResponse& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TIPCPaymentCanMakeActionResponse:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse((aOther).get_IPCPaymentCanMakeActionResponse());
break;
}
case TIPCPaymentShowActionResponse:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse((aOther).get_IPCPaymentShowActionResponse());
break;
}
case TIPCPaymentAbortActionResponse:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse((aOther).get_IPCPaymentAbortActionResponse());
break;
}
case TIPCPaymentCompleteActionResponse:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse((aOther).get_IPCPaymentCompleteActionResponse());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(IPCPaymentActionResponse&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TIPCPaymentCanMakeActionResponse:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse(std::move((aOther).get_IPCPaymentCanMakeActionResponse()));
(aOther).MaybeDestroy();
break;
}
case TIPCPaymentShowActionResponse:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse(std::move((aOther).get_IPCPaymentShowActionResponse()));
(aOther).MaybeDestroy();
break;
}
case TIPCPaymentAbortActionResponse:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse(std::move((aOther).get_IPCPaymentAbortActionResponse()));
(aOther).MaybeDestroy();
break;
}
case TIPCPaymentCompleteActionResponse:
{
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse(std::move((aOther).get_IPCPaymentCompleteActionResponse()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
IPCPaymentActionResponse::~IPCPaymentActionResponse()
{
MaybeDestroy();
}
auto IPCPaymentActionResponse::operator=(const IPCPaymentCanMakeActionResponse& aRhs) -> IPCPaymentActionResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse(aRhs);
mType = TIPCPaymentCanMakeActionResponse;
return (*(this));
}
auto IPCPaymentActionResponse::operator=(IPCPaymentCanMakeActionResponse&& aRhs) -> IPCPaymentActionResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse(std::move(aRhs));
mType = TIPCPaymentCanMakeActionResponse;
return (*(this));
}
auto IPCPaymentActionResponse::operator=(const IPCPaymentShowActionResponse& aRhs) -> IPCPaymentActionResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse(aRhs);
mType = TIPCPaymentShowActionResponse;
return (*(this));
}
auto IPCPaymentActionResponse::operator=(IPCPaymentShowActionResponse&& aRhs) -> IPCPaymentActionResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse(std::move(aRhs));
mType = TIPCPaymentShowActionResponse;
return (*(this));
}
auto IPCPaymentActionResponse::operator=(const IPCPaymentAbortActionResponse& aRhs) -> IPCPaymentActionResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse(aRhs);
mType = TIPCPaymentAbortActionResponse;
return (*(this));
}
auto IPCPaymentActionResponse::operator=(IPCPaymentAbortActionResponse&& aRhs) -> IPCPaymentActionResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse(std::move(aRhs));
mType = TIPCPaymentAbortActionResponse;
return (*(this));
}
auto IPCPaymentActionResponse::operator=(const IPCPaymentCompleteActionResponse& aRhs) -> IPCPaymentActionResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse(aRhs);
mType = TIPCPaymentCompleteActionResponse;
return (*(this));
}
auto IPCPaymentActionResponse::operator=(IPCPaymentCompleteActionResponse&& aRhs) -> IPCPaymentActionResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse(std::move(aRhs));
mType = TIPCPaymentCompleteActionResponse;
return (*(this));
}
auto IPCPaymentActionResponse::operator=(const IPCPaymentActionResponse& aRhs) -> IPCPaymentActionResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TIPCPaymentCanMakeActionResponse:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse((aRhs).get_IPCPaymentCanMakeActionResponse());
break;
}
case TIPCPaymentShowActionResponse:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse((aRhs).get_IPCPaymentShowActionResponse());
break;
}
case TIPCPaymentAbortActionResponse:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse((aRhs).get_IPCPaymentAbortActionResponse());
break;
}
case TIPCPaymentCompleteActionResponse:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse((aRhs).get_IPCPaymentCompleteActionResponse());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto IPCPaymentActionResponse::operator=(IPCPaymentActionResponse&& aRhs) -> IPCPaymentActionResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TIPCPaymentCanMakeActionResponse:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse(std::move((aRhs).get_IPCPaymentCanMakeActionResponse()));
(aRhs).MaybeDestroy();
break;
}
case TIPCPaymentShowActionResponse:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse(std::move((aRhs).get_IPCPaymentShowActionResponse()));
(aRhs).MaybeDestroy();
break;
}
case TIPCPaymentAbortActionResponse:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse(std::move((aRhs).get_IPCPaymentAbortActionResponse()));
(aRhs).MaybeDestroy();
break;
}
case TIPCPaymentCompleteActionResponse:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse(std::move((aRhs).get_IPCPaymentCompleteActionResponse()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentActionResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::IPCPaymentActionResponse union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'IPCPaymentActionResponse'
(aWriter)->WriteSentinel(1884162408);
switch (type) {
case union__::TIPCPaymentCanMakeActionResponse:
{
IPC::WriteParam(aWriter, (aVar).get_IPCPaymentCanMakeActionResponse());
// Sentinel = 'TIPCPaymentCanMakeActionResponse'
(aWriter)->WriteSentinel(3265203276);
return;
}
case union__::TIPCPaymentShowActionResponse:
{
IPC::WriteParam(aWriter, (aVar).get_IPCPaymentShowActionResponse());
// Sentinel = 'TIPCPaymentShowActionResponse'
(aWriter)->WriteSentinel(2741373789);
return;
}
case union__::TIPCPaymentAbortActionResponse:
{
IPC::WriteParam(aWriter, (aVar).get_IPCPaymentAbortActionResponse());
// Sentinel = 'TIPCPaymentAbortActionResponse'
(aWriter)->WriteSentinel(2916092852);
return;
}
case union__::TIPCPaymentCompleteActionResponse:
{
IPC::WriteParam(aWriter, (aVar).get_IPCPaymentCompleteActionResponse());
// Sentinel = 'TIPCPaymentCompleteActionResponse'
(aWriter)->WriteSentinel(3559132405);
return;
}
default:
{
aWriter->FatalError("unknown variant of union IPCPaymentActionResponse");
return;
}
}
}
auto ParamTraits<::mozilla::dom::IPCPaymentActionResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::IPCPaymentActionResponse union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union IPCPaymentActionResponse");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'IPCPaymentActionResponse'
if ((!((aReader)->ReadSentinel(1884162408)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union IPCPaymentActionResponse");
return {};
}
switch (type) {
case union__::TIPCPaymentCanMakeActionResponse:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentCanMakeActionResponse>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCPaymentCanMakeActionResponse of union IPCPaymentActionResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCPaymentCanMakeActionResponse'
if ((!((aReader)->ReadSentinel(3265203276)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentCanMakeActionResponse of union IPCPaymentActionResponse");
return {};
}
return std::move(tmp);
}
case union__::TIPCPaymentShowActionResponse:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentShowActionResponse>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCPaymentShowActionResponse of union IPCPaymentActionResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCPaymentShowActionResponse'
if ((!((aReader)->ReadSentinel(2741373789)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentShowActionResponse of union IPCPaymentActionResponse");
return {};
}
return std::move(tmp);
}
case union__::TIPCPaymentAbortActionResponse:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentAbortActionResponse>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCPaymentAbortActionResponse of union IPCPaymentActionResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCPaymentAbortActionResponse'
if ((!((aReader)->ReadSentinel(2916092852)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentAbortActionResponse of union IPCPaymentActionResponse");
return {};
}
return std::move(tmp);
}
case union__::TIPCPaymentCompleteActionResponse:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentCompleteActionResponse>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCPaymentCompleteActionResponse of union IPCPaymentActionResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCPaymentCompleteActionResponse'
if ((!((aReader)->ReadSentinel(3559132405)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentCompleteActionResponse of union IPCPaymentActionResponse");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union IPCPaymentActionResponse");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCGeneralChangeDetails|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCGeneralChangeDetails>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).details());
// Sentinel = 'details'
(aWriter)->WriteSentinel(191824615);
}
auto ParamTraits<::mozilla::dom::IPCGeneralChangeDetails>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___details = IPC::ReadParam<::nsString>(aReader);
if (!maybe___details) {
aReader->FatalError("Error deserializing 'details' (nsString) member of 'IPCGeneralChangeDetails'");
return {};
}
auto& _details = *maybe___details;
// Sentinel = 'details'
if ((!((aReader)->ReadSentinel(191824615)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'details' (nsString) member of 'IPCGeneralChangeDetails'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_details)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCBasicCardChangeDetails|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCBasicCardChangeDetails>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).billingAddress());
// Sentinel = 'billingAddress'
(aWriter)->WriteSentinel(705037736);
}
auto ParamTraits<::mozilla::dom::IPCBasicCardChangeDetails>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___billingAddress = IPC::ReadParam<::mozilla::dom::IPCPaymentAddress>(aReader);
if (!maybe___billingAddress) {
aReader->FatalError("Error deserializing 'billingAddress' (IPCPaymentAddress) member of 'IPCBasicCardChangeDetails'");
return {};
}
auto& _billingAddress = *maybe___billingAddress;
// Sentinel = 'billingAddress'
if ((!((aReader)->ReadSentinel(705037736)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'billingAddress' (IPCPaymentAddress) member of 'IPCBasicCardChangeDetails'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_billingAddress)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPCMethodChangeDetails|
//
namespace mozilla {
namespace dom {
auto IPCMethodChangeDetails::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TIPCGeneralChangeDetails:
{
(ptr_IPCGeneralChangeDetails())->~IPCGeneralChangeDetails__tdef();
break;
}
case TIPCBasicCardChangeDetails:
{
(ptr_IPCBasicCardChangeDetails())->~IPCBasicCardChangeDetails__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT IPCMethodChangeDetails::IPCMethodChangeDetails(const IPCGeneralChangeDetails& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails(aOther);
mType = TIPCGeneralChangeDetails;
}
MOZ_IMPLICIT IPCMethodChangeDetails::IPCMethodChangeDetails(IPCGeneralChangeDetails&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails(std::move(aOther));
mType = TIPCGeneralChangeDetails;
}
MOZ_IMPLICIT IPCMethodChangeDetails::IPCMethodChangeDetails(const IPCBasicCardChangeDetails& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails(aOther);
mType = TIPCBasicCardChangeDetails;
}
MOZ_IMPLICIT IPCMethodChangeDetails::IPCMethodChangeDetails(IPCBasicCardChangeDetails&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails(std::move(aOther));
mType = TIPCBasicCardChangeDetails;
}
MOZ_IMPLICIT IPCMethodChangeDetails::IPCMethodChangeDetails(const IPCMethodChangeDetails& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TIPCGeneralChangeDetails:
{
new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails((aOther).get_IPCGeneralChangeDetails());
break;
}
case TIPCBasicCardChangeDetails:
{
new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails((aOther).get_IPCBasicCardChangeDetails());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT IPCMethodChangeDetails::IPCMethodChangeDetails(IPCMethodChangeDetails&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TIPCGeneralChangeDetails:
{
new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails(std::move((aOther).get_IPCGeneralChangeDetails()));
(aOther).MaybeDestroy();
break;
}
case TIPCBasicCardChangeDetails:
{
new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails(std::move((aOther).get_IPCBasicCardChangeDetails()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
IPCMethodChangeDetails::~IPCMethodChangeDetails()
{
MaybeDestroy();
}
auto IPCMethodChangeDetails::operator=(const IPCGeneralChangeDetails& aRhs) -> IPCMethodChangeDetails&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails(aRhs);
mType = TIPCGeneralChangeDetails;
return (*(this));
}
auto IPCMethodChangeDetails::operator=(IPCGeneralChangeDetails&& aRhs) -> IPCMethodChangeDetails&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails(std::move(aRhs));
mType = TIPCGeneralChangeDetails;
return (*(this));
}
auto IPCMethodChangeDetails::operator=(const IPCBasicCardChangeDetails& aRhs) -> IPCMethodChangeDetails&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails(aRhs);
mType = TIPCBasicCardChangeDetails;
return (*(this));
}
auto IPCMethodChangeDetails::operator=(IPCBasicCardChangeDetails&& aRhs) -> IPCMethodChangeDetails&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails(std::move(aRhs));
mType = TIPCBasicCardChangeDetails;
return (*(this));
}
auto IPCMethodChangeDetails::operator=(const IPCMethodChangeDetails& aRhs) -> IPCMethodChangeDetails&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TIPCGeneralChangeDetails:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails((aRhs).get_IPCGeneralChangeDetails());
break;
}
case TIPCBasicCardChangeDetails:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails((aRhs).get_IPCBasicCardChangeDetails());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto IPCMethodChangeDetails::operator=(IPCMethodChangeDetails&& aRhs) -> IPCMethodChangeDetails&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TIPCGeneralChangeDetails:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails(std::move((aRhs).get_IPCGeneralChangeDetails()));
(aRhs).MaybeDestroy();
break;
}
case TIPCBasicCardChangeDetails:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails(std::move((aRhs).get_IPCBasicCardChangeDetails()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::IPCMethodChangeDetails>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::IPCMethodChangeDetails union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'IPCMethodChangeDetails'
(aWriter)->WriteSentinel(1530071114);
switch (type) {
case union__::TIPCGeneralChangeDetails:
{
IPC::WriteParam(aWriter, (aVar).get_IPCGeneralChangeDetails());
// Sentinel = 'TIPCGeneralChangeDetails'
(aWriter)->WriteSentinel(1797654779);
return;
}
case union__::TIPCBasicCardChangeDetails:
{
IPC::WriteParam(aWriter, (aVar).get_IPCBasicCardChangeDetails());
// Sentinel = 'TIPCBasicCardChangeDetails'
(aWriter)->WriteSentinel(2069629337);
return;
}
default:
{
aWriter->FatalError("unknown variant of union IPCMethodChangeDetails");
return;
}
}
}
auto ParamTraits<::mozilla::dom::IPCMethodChangeDetails>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::IPCMethodChangeDetails union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union IPCMethodChangeDetails");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'IPCMethodChangeDetails'
if ((!((aReader)->ReadSentinel(1530071114)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union IPCMethodChangeDetails");
return {};
}
switch (type) {
case union__::TIPCGeneralChangeDetails:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCGeneralChangeDetails>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCGeneralChangeDetails of union IPCMethodChangeDetails");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCGeneralChangeDetails'
if ((!((aReader)->ReadSentinel(1797654779)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCGeneralChangeDetails of union IPCMethodChangeDetails");
return {};
}
return std::move(tmp);
}
case union__::TIPCBasicCardChangeDetails:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCBasicCardChangeDetails>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCBasicCardChangeDetails of union IPCMethodChangeDetails");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCBasicCardChangeDetails'
if ((!((aReader)->ReadSentinel(2069629337)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCBasicCardChangeDetails of union IPCMethodChangeDetails");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union IPCMethodChangeDetails");
return {};
}
}
}
} // namespace IPC