mozilla-central/__GENERATED__/ipc/ipdl/PMLSTransactionParent.cpp (file symbol)

Copy as Markdown

Other Tools

//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/PMLSTransactionParent.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/dom/MLSTransactionMessage.h"
#include "mozilla/dom/MLSTransactionParent.h"
#include "mozilla/ipc/PBackgroundParent.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 {
auto PMLSTransactionParent::ProcessingError(
Result aCode,
const char* aReason) -> void
{
}
auto PMLSTransactionParent::ShouldContinueFromReplyTimeout() -> bool
{
return true;
}
MOZ_IMPLICIT PMLSTransactionParent::PMLSTransactionParent() :
mozilla::ipc::IToplevelProtocol("PMLSTransactionParent", kProtocolId, mozilla::ipc::ParentSide)
{
MOZ_COUNT_CTOR(PMLSTransactionParent);
}
PMLSTransactionParent::~PMLSTransactionParent()
{
MOZ_COUNT_DTOR(PMLSTransactionParent);
}
auto PMLSTransactionParent::ActorAlloc() -> void
{
MOZ_RELEASE_ASSERT(XRE_IsParentProcess(), "Invalid process for `PMLSTransactionParent'");
AddRef();
}
auto PMLSTransactionParent::ActorDealloc() -> void
{
Release();
}
auto PMLSTransactionParent::ManagedProtocolIds() const -> mozilla::Span<mozilla::ipc::ProtocolId const>
{
return {};
}
auto PMLSTransactionParent::GetManagedActors(mozilla::ipc::ProtocolId aProtocol) -> UntypedManagedContainer*
{
switch (aProtocol) {
default:
return nullptr;
}
}
auto PMLSTransactionParent::RejectPendingResponses(ResponseRejectReason aReason) -> void
{
mAsyncCallbacks.RejectPendingResponses(aReason);
}
auto PMLSTransactionParent::DeallocManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
FatalError("unreached");
return;
}
auto PMLSTransactionParent::OnMessageReceived(const Message& msg__) -> PMLSTransactionParent::Result
{
switch (msg__.type()) {
case PMLSTransaction::Msg_RequestStateDelete__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestStateDelete", OTHER);
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestStateDelete(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestStateDeleteResolver resolver = [resolver__ = std::move(resolver__)](const bool& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestStateDelete(std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestGroupStateDelete__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestGroupStateDelete", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__groupIdentifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__groupIdentifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& groupIdentifier = *maybe__groupIdentifier;
// Sentinel = 'groupIdentifier'
if ((!(((&(reader__)))->ReadSentinel(832505393)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__identifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__identifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& identifier = *maybe__identifier;
// Sentinel = 'identifier'
if ((!(((&(reader__)))->ReadSentinel(379978788)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestGroupStateDelete(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestGroupStateDeleteResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<GkGroupIdEpoch>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestGroupStateDelete(std::move(groupIdentifier), std::move(identifier), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestGenerateIdentityKeypair__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestGenerateIdentityKeypair", OTHER);
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestGenerateIdentityKeypair(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestGenerateIdentityKeypairResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<RawBytes>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestGenerateIdentityKeypair(std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestGenerateCredentialBasic__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestGenerateCredentialBasic", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__credName = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__credName) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& credName = *maybe__credName;
// Sentinel = 'credName'
if ((!(((&(reader__)))->ReadSentinel(237634336)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestGenerateCredentialBasic(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestGenerateCredentialBasicResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<RawBytes>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestGenerateCredentialBasic(std::move(credName), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestGenerateKeyPackage__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestGenerateKeyPackage", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__identity = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__identity) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& identity = *maybe__identity;
// Sentinel = 'identity'
if ((!(((&(reader__)))->ReadSentinel(251396971)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__credential = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__credential) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& credential = *maybe__credential;
// Sentinel = 'credential'
if ((!(((&(reader__)))->ReadSentinel(378209308)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestGenerateKeyPackage(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestGenerateKeyPackageResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<RawBytes>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestGenerateKeyPackage(std::move(identity), std::move(credential), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestGroupCreate__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestGroupCreate", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__identifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__identifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& identifier = *maybe__identifier;
// Sentinel = 'identifier'
if ((!(((&(reader__)))->ReadSentinel(379978788)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__credential = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__credential) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& credential = *maybe__credential;
// Sentinel = 'credential'
if ((!(((&(reader__)))->ReadSentinel(378209308)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__inOptGroupIdentifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__inOptGroupIdentifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& inOptGroupIdentifier = *maybe__inOptGroupIdentifier;
// Sentinel = 'inOptGroupIdentifier'
if ((!(((&(reader__)))->ReadSentinel(1415579675)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestGroupCreate(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestGroupCreateResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<GkGroupIdEpoch>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestGroupCreate(std::move(identifier), std::move(credential), std::move(inOptGroupIdentifier), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestGroupJoin__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestGroupJoin", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__identifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__identifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& identifier = *maybe__identifier;
// Sentinel = 'identifier'
if ((!(((&(reader__)))->ReadSentinel(379978788)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__welcome = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__welcome) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& welcome = *maybe__welcome;
// Sentinel = 'welcome'
if ((!(((&(reader__)))->ReadSentinel(198836973)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestGroupJoin(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestGroupJoinResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<GkGroupIdEpoch>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestGroupJoin(std::move(identifier), std::move(welcome), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestGroupAdd__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestGroupAdd", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__groupIdentifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__groupIdentifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& groupIdentifier = *maybe__groupIdentifier;
// Sentinel = 'groupIdentifier'
if ((!(((&(reader__)))->ReadSentinel(832505393)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__identifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__identifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& identifier = *maybe__identifier;
// Sentinel = 'identifier'
if ((!(((&(reader__)))->ReadSentinel(379978788)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__keyPackage = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__keyPackage) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& keyPackage = *maybe__keyPackage;
// Sentinel = 'keyPackage'
if ((!(((&(reader__)))->ReadSentinel(368313334)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestGroupAdd(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestGroupAddResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<GkMlsCommitOutput>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestGroupAdd(std::move(groupIdentifier), std::move(identifier), std::move(keyPackage), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestGroupProposeAdd__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestGroupProposeAdd", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__groupIdentifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__groupIdentifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& groupIdentifier = *maybe__groupIdentifier;
// Sentinel = 'groupIdentifier'
if ((!(((&(reader__)))->ReadSentinel(832505393)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__identifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__identifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& identifier = *maybe__identifier;
// Sentinel = 'identifier'
if ((!(((&(reader__)))->ReadSentinel(379978788)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__keyPackage = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__keyPackage) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& keyPackage = *maybe__keyPackage;
// Sentinel = 'keyPackage'
if ((!(((&(reader__)))->ReadSentinel(368313334)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestGroupProposeAdd(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestGroupProposeAddResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<RawBytes>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestGroupProposeAdd(std::move(groupIdentifier), std::move(identifier), std::move(keyPackage), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestGroupRemove__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestGroupRemove", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__groupIdentifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__groupIdentifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& groupIdentifier = *maybe__groupIdentifier;
// Sentinel = 'groupIdentifier'
if ((!(((&(reader__)))->ReadSentinel(832505393)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__identifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__identifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& identifier = *maybe__identifier;
// Sentinel = 'identifier'
if ((!(((&(reader__)))->ReadSentinel(379978788)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__remIdentifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__remIdentifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& remIdentifier = *maybe__remIdentifier;
// Sentinel = 'remIdentifier'
if ((!(((&(reader__)))->ReadSentinel(614335816)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestGroupRemove(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestGroupRemoveResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<GkMlsCommitOutput>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestGroupRemove(std::move(groupIdentifier), std::move(identifier), std::move(remIdentifier), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestGroupProposeRemove__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestGroupProposeRemove", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__groupIdentifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__groupIdentifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& groupIdentifier = *maybe__groupIdentifier;
// Sentinel = 'groupIdentifier'
if ((!(((&(reader__)))->ReadSentinel(832505393)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__identifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__identifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& identifier = *maybe__identifier;
// Sentinel = 'identifier'
if ((!(((&(reader__)))->ReadSentinel(379978788)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__remIdentifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__remIdentifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& remIdentifier = *maybe__remIdentifier;
// Sentinel = 'remIdentifier'
if ((!(((&(reader__)))->ReadSentinel(614335816)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestGroupProposeRemove(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestGroupProposeRemoveResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<RawBytes>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestGroupProposeRemove(std::move(groupIdentifier), std::move(identifier), std::move(remIdentifier), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestGroupClose__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestGroupClose", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__groupIdentifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__groupIdentifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& groupIdentifier = *maybe__groupIdentifier;
// Sentinel = 'groupIdentifier'
if ((!(((&(reader__)))->ReadSentinel(832505393)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__identifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__identifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& identifier = *maybe__identifier;
// Sentinel = 'identifier'
if ((!(((&(reader__)))->ReadSentinel(379978788)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestGroupClose(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestGroupCloseResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<GkMlsCommitOutput>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestGroupClose(std::move(groupIdentifier), std::move(identifier), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestGroupDetails__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestGroupDetails", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__groupIdentifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__groupIdentifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& groupIdentifier = *maybe__groupIdentifier;
// Sentinel = 'groupIdentifier'
if ((!(((&(reader__)))->ReadSentinel(832505393)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__identifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__identifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& identifier = *maybe__identifier;
// Sentinel = 'identifier'
if ((!(((&(reader__)))->ReadSentinel(379978788)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestGroupDetails(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestGroupDetailsResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<GkGroupDetails>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestGroupDetails(std::move(groupIdentifier), std::move(identifier), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestReceive__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestReceive", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__identifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__identifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& identifier = *maybe__identifier;
// Sentinel = 'identifier'
if ((!(((&(reader__)))->ReadSentinel(379978788)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__message = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__message) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& message = *maybe__message;
// Sentinel = 'message'
if ((!(((&(reader__)))->ReadSentinel(197198566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestReceive(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestReceiveResolver resolver = [resolver__ = std::move(resolver__)](const GkReceived& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestReceive(std::move(identifier), std::move(message), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestApplyPendingCommit__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestApplyPendingCommit", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__groupIdentifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__groupIdentifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& groupIdentifier = *maybe__groupIdentifier;
// Sentinel = 'groupIdentifier'
if ((!(((&(reader__)))->ReadSentinel(832505393)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__identifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__identifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& identifier = *maybe__identifier;
// Sentinel = 'identifier'
if ((!(((&(reader__)))->ReadSentinel(379978788)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestApplyPendingCommit(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestApplyPendingCommitResolver resolver = [resolver__ = std::move(resolver__)](const GkReceived& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestApplyPendingCommit(std::move(groupIdentifier), std::move(identifier), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestSend__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestSend", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__groupIdentifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__groupIdentifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& groupIdentifier = *maybe__groupIdentifier;
// Sentinel = 'groupIdentifier'
if ((!(((&(reader__)))->ReadSentinel(832505393)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__identifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__identifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& identifier = *maybe__identifier;
// Sentinel = 'identifier'
if ((!(((&(reader__)))->ReadSentinel(379978788)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__message = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__message) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& message = *maybe__message;
// Sentinel = 'message'
if ((!(((&(reader__)))->ReadSentinel(197198566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestSend(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestSendResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<RawBytes>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestSend(std::move(groupIdentifier), std::move(identifier), std::move(message), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestExportSecret__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestExportSecret", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__groupIdentifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__groupIdentifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& groupIdentifier = *maybe__groupIdentifier;
// Sentinel = 'groupIdentifier'
if ((!(((&(reader__)))->ReadSentinel(832505393)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__identifier = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__identifier) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& identifier = *maybe__identifier;
// Sentinel = 'identifier'
if ((!(((&(reader__)))->ReadSentinel(379978788)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__label = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__label) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& label = *maybe__label;
// Sentinel = 'label'
if ((!(((&(reader__)))->ReadSentinel(100729345)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__content = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__content) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& content = *maybe__content;
// Sentinel = 'content'
if ((!(((&(reader__)))->ReadSentinel(197853948)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto maybe__len = IPC::ReadParam<uint64_t>((&(reader__)));
if (!maybe__len) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
auto& len = *maybe__len;
// Sentinel = 'len'
if ((!(((&(reader__)))->ReadSentinel(41877824)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestExportSecret(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestExportSecretResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<GkExporterOutput>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestExportSecret(std::move(groupIdentifier), std::move(identifier), std::move(label), std::move(content), std::move(len), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PMLSTransaction::Msg_RequestGetGroupIdentifier__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PMLSTransaction::Msg_RequestGetGroupIdentifier", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__message = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
if (!maybe__message) {
FatalError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
auto& message = *maybe__message;
// Sentinel = 'message'
if ((!(((&(reader__)))->ReadSentinel(197198566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
return MsgValueError;
}
reader__.EndRead();
int32_t id__ = MSG_ROUTING_CONTROL;
UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestGetGroupIdentifier(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
RequestGetGroupIdentifierResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<RawBytes>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
IPC::MessageWriter writer__(*reply__, self__);
IPC::WriteParam((&(writer__)), aParam);
// Sentinel = 'result'
((&(writer__)))->WriteSentinel(153223840);
if (mozilla::ipc::LoggingEnabledFor("PMLSTransaction", mozilla::ipc::ParentSide)) {
mozilla::ipc::LogMessageForProtocol(
"PMLSTransactionParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
mozilla::ipc::IPCResult __ok = (static_cast<MLSTransactionParent*>(this))->RecvRequestGetGroupIdentifier(std::move(message), std::move(resolver));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
default:
return MsgNotKnown;
case SHMEM_CREATED_MESSAGE_TYPE:
{
if (!ShmemCreated(msg__)) {
return MsgPayloadError;
}
return MsgProcessed;
}
case SHMEM_DESTROYED_MESSAGE_TYPE:
{
if (!ShmemDestroyed(msg__)) {
return MsgPayloadError;
}
return MsgProcessed;
}
}
}
auto PMLSTransactionParent::OnMessageReceived(
const Message& msg__,
UniquePtr<Message>& reply__) -> PMLSTransactionParent::Result
{
MOZ_ASSERT_UNREACHABLE("message protocol not supported");
return MsgNotKnown;
}
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::PMLSTransactionParent*>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
MOZ_RELEASE_ASSERT(
aWriter->GetActor(),
"Cannot serialize managed actors without an actor");
int32_t id;
if (!aVar) {
id = 0; // kNullActorId
} else {
id = aVar->Id();
if (id == 1) { // kFreedActorId
aVar->FatalError("Actor has been |delete|d");
}
MOZ_RELEASE_ASSERT(
aWriter->GetActor()->GetIPCChannel() == aVar->GetIPCChannel(),
"Actor must be from the same channel as the"
" actor it's being sent over");
MOZ_RELEASE_ASSERT(
aVar->CanSend(),
"Actor must still be open when sending");
}
IPC::WriteParam(aWriter, id);
}
auto ParamTraits<::mozilla::dom::PMLSTransactionParent*>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
MOZ_RELEASE_ASSERT(
aReader->GetActor(),
"Cannot deserialize managed actors without an actor");
mozilla::Maybe<mozilla::ipc::IProtocol*> actor = aReader->GetActor()
->ReadActor(aReader, true, "PMLSTransaction", PMLSTransactionMsgStart);
if (actor.isSome()) {
return static_cast<::mozilla::dom::PMLSTransactionParent*>(actor.ref());
}
return {};
}
} // namespace IPC