//
// 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(
        mozilla::ipc::ProtocolId 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);

            mozilla::ipc::ActorId 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();
            mozilla::ipc::ActorId 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);

            mozilla::ipc::ActorId 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();
            mozilla::ipc::ActorId 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();
            mozilla::ipc::ActorId 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();
            mozilla::ipc::ActorId 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();
            mozilla::ipc::ActorId 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();
            mozilla::ipc::ActorId 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();
            mozilla::ipc::ActorId 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();
            mozilla::ipc::ActorId 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();
            mozilla::ipc::ActorId 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();
            mozilla::ipc::ActorId 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();
            mozilla::ipc::ActorId 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_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();
            mozilla::ipc::ActorId 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_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();
            mozilla::ipc::ActorId 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_RequestHasPendingProposals__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_RequestHasPendingProposals", 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();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestHasPendingProposals(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            RequestHasPendingProposalsResolver 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))->RecvRequestHasPendingProposals(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_RequestClearPendingProposals__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_RequestClearPendingProposals", 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();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestClearPendingProposals(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            RequestClearPendingProposalsResolver 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))->RecvRequestClearPendingProposals(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_RequestHasPendingCommit__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_RequestHasPendingCommit", 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();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestHasPendingCommit(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            RequestHasPendingCommitResolver 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))->RecvRequestHasPendingCommit(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_RequestClearPendingCommit__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_RequestClearPendingCommit", 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();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestClearPendingCommit(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            RequestClearPendingCommitResolver 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))->RecvRequestClearPendingCommit(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_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();
            mozilla::ipc::ActorId 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_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();
            mozilla::ipc::ActorId 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();
            mozilla::ipc::ActorId 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;
        }
    case PMLSTransaction::Msg_RequestGetGroupEpoch__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_RequestGetGroupEpoch", 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();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PMLSTransaction::Reply_RequestGetGroupEpoch(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            RequestGetGroupEpochResolver 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))->RecvRequestGetGroupEpoch(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
{
    IPC::WriteParam(aWriter, static_cast<mozilla::ipc::IProtocol*>(aVar));
    // Sentinel = 'PMLSTransaction'
    (aWriter)->WriteSentinel(726599107);
}

auto ParamTraits<::mozilla::dom::PMLSTransactionParent*>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe__actor = IPC::ReadParam<mozilla::ipc::IProtocol*>(aReader);
    if (!maybe__actor) {
        aReader->FatalError("Error deserializing managed PMLSTransaction actor");
        return {};

    }
    auto& actor = *maybe__actor;
    // Sentinel = 'PMLSTransaction'
    if ((!((aReader)->ReadSentinel(726599107)))) {
        mozilla::ipc::SentinelReadError("Error deserializing managed PMLSTransaction actor");
        return {};
    }

    if (actor && actor->GetProtocolId() != PMLSTransactionMsgStart) {
        aReader->FatalError("Unexpected actor type (expected PMLSTransaction)");

        return {};
    }
    return static_cast<::mozilla::dom::PMLSTransactionParent*>(actor);
}

} // namespace IPC
