//
// Automatically generated by ipdlc.
// Edit at your own risk
//


#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/ipc/PBackgroundSharedTypes.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"


//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ContentSecurityPolicy|
//
namespace mozilla {
namespace ipc {
auto ContentSecurityPolicy::operator==(const ContentSecurityPolicy& _o) const -> bool
{
    if ((!((policy()) == ((_o).policy())))) {
        return false;
    }
    if ((!((reportOnlyFlag()) == ((_o).reportOnlyFlag())))) {
        return false;
    }
    if ((!((deliveredViaMetaTagFlag()) == ((_o).deliveredViaMetaTagFlag())))) {
        return false;
    }
    if ((!((hasRequireTrustedTypesForDirective()) == ((_o).hasRequireTrustedTypesForDirective())))) {
        return false;
    }
    return true;
}

auto ContentSecurityPolicy::operator!=(const ContentSecurityPolicy& _o) const -> bool
{
    return (!(operator==(_o)));
}

} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::ContentSecurityPolicy>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).policy());
    // Sentinel = 'policy'
    (aWriter)->WriteSentinel(150667921);
    IPC::WriteParam(aWriter, (aVar).reportOnlyFlag());
    // Sentinel = 'reportOnlyFlag'
    (aWriter)->WriteSentinel(735839673);
    IPC::WriteParam(aWriter, (aVar).deliveredViaMetaTagFlag());
    // Sentinel = 'deliveredViaMetaTagFlag'
    (aWriter)->WriteSentinel(1836517618);
    IPC::WriteParam(aWriter, (aVar).hasRequireTrustedTypesForDirective());
    // Sentinel = 'hasRequireTrustedTypesForDirective'
    (aWriter)->WriteSentinel(4075490784);
}

auto ParamTraits<::mozilla::ipc::ContentSecurityPolicy>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___policy = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___policy) {
        aReader->FatalError("Error deserializing 'policy' (nsString) member of 'ContentSecurityPolicy'");
        return {};

    }
    auto& _policy = *maybe___policy;
    // Sentinel = 'policy'
    if ((!((aReader)->ReadSentinel(150667921)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'policy' (nsString) member of 'ContentSecurityPolicy'");
        return {};
    }
    auto maybe___reportOnlyFlag = IPC::ReadParam<bool>(aReader);
    if (!maybe___reportOnlyFlag) {
        aReader->FatalError("Error deserializing 'reportOnlyFlag' (bool) member of 'ContentSecurityPolicy'");
        return {};

    }
    auto& _reportOnlyFlag = *maybe___reportOnlyFlag;
    // Sentinel = 'reportOnlyFlag'
    if ((!((aReader)->ReadSentinel(735839673)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'reportOnlyFlag' (bool) member of 'ContentSecurityPolicy'");
        return {};
    }
    auto maybe___deliveredViaMetaTagFlag = IPC::ReadParam<bool>(aReader);
    if (!maybe___deliveredViaMetaTagFlag) {
        aReader->FatalError("Error deserializing 'deliveredViaMetaTagFlag' (bool) member of 'ContentSecurityPolicy'");
        return {};

    }
    auto& _deliveredViaMetaTagFlag = *maybe___deliveredViaMetaTagFlag;
    // Sentinel = 'deliveredViaMetaTagFlag'
    if ((!((aReader)->ReadSentinel(1836517618)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'deliveredViaMetaTagFlag' (bool) member of 'ContentSecurityPolicy'");
        return {};
    }
    auto maybe___hasRequireTrustedTypesForDirective = IPC::ReadParam<bool>(aReader);
    if (!maybe___hasRequireTrustedTypesForDirective) {
        aReader->FatalError("Error deserializing 'hasRequireTrustedTypesForDirective' (bool) member of 'ContentSecurityPolicy'");
        return {};

    }
    auto& _hasRequireTrustedTypesForDirective = *maybe___hasRequireTrustedTypesForDirective;
    // Sentinel = 'hasRequireTrustedTypesForDirective'
    if ((!((aReader)->ReadSentinel(4075490784)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hasRequireTrustedTypesForDirective' (bool) member of 'ContentSecurityPolicy'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_policy),
            std::move(_reportOnlyFlag),
            std::move(_deliveredViaMetaTagFlag),
            std::move(_hasRequireTrustedTypesForDirective)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ContentPrincipalInfo|
//
namespace mozilla {
namespace ipc {
auto ContentPrincipalInfo::operator==(const ContentPrincipalInfo& _o) const -> bool
{
    if ((!((attrs()) == ((_o).attrs())))) {
        return false;
    }
    if ((!((originNoSuffix()) == ((_o).originNoSuffix())))) {
        return false;
    }
    if ((!((spec()) == ((_o).spec())))) {
        return false;
    }
    if ((!((domain()) == ((_o).domain())))) {
        return false;
    }
    if ((!((baseDomain()) == ((_o).baseDomain())))) {
        return false;
    }
    return true;
}

auto ContentPrincipalInfo::operator!=(const ContentPrincipalInfo& _o) const -> bool
{
    return (!(operator==(_o)));
}

} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::ContentPrincipalInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).attrs());
    // Sentinel = 'attrs'
    (aWriter)->WriteSentinel(107807279);
    IPC::WriteParam(aWriter, (aVar).originNoSuffix());
    // Sentinel = 'originNoSuffix'
    (aWriter)->WriteSentinel(721618363);
    IPC::WriteParam(aWriter, (aVar).spec());
    // Sentinel = 'spec'
    (aWriter)->WriteSentinel(72155564);
    IPC::WriteParam(aWriter, (aVar).domain());
    // Sentinel = 'domain'
    (aWriter)->WriteSentinel(144704121);
    IPC::WriteParam(aWriter, (aVar).baseDomain());
    // Sentinel = 'baseDomain'
    (aWriter)->WriteSentinel(360449012);
}

auto ParamTraits<::mozilla::ipc::ContentPrincipalInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___attrs = IPC::ReadParam<::mozilla::OriginAttributes>(aReader);
    if (!maybe___attrs) {
        aReader->FatalError("Error deserializing 'attrs' (OriginAttributes) member of 'ContentPrincipalInfo'");
        return {};

    }
    auto& _attrs = *maybe___attrs;
    // Sentinel = 'attrs'
    if ((!((aReader)->ReadSentinel(107807279)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'attrs' (OriginAttributes) member of 'ContentPrincipalInfo'");
        return {};
    }
    auto maybe___originNoSuffix = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___originNoSuffix) {
        aReader->FatalError("Error deserializing 'originNoSuffix' (nsCString) member of 'ContentPrincipalInfo'");
        return {};

    }
    auto& _originNoSuffix = *maybe___originNoSuffix;
    // Sentinel = 'originNoSuffix'
    if ((!((aReader)->ReadSentinel(721618363)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'originNoSuffix' (nsCString) member of 'ContentPrincipalInfo'");
        return {};
    }
    auto maybe___spec = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___spec) {
        aReader->FatalError("Error deserializing 'spec' (nsCString) member of 'ContentPrincipalInfo'");
        return {};

    }
    auto& _spec = *maybe___spec;
    // Sentinel = 'spec'
    if ((!((aReader)->ReadSentinel(72155564)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'spec' (nsCString) member of 'ContentPrincipalInfo'");
        return {};
    }
    auto maybe___domain = IPC::ReadParam<mozilla::Maybe<::nsCString>>(aReader);
    if (!maybe___domain) {
        aReader->FatalError("Error deserializing 'domain' (nsCString?) member of 'ContentPrincipalInfo'");
        return {};

    }
    auto& _domain = *maybe___domain;
    // Sentinel = 'domain'
    if ((!((aReader)->ReadSentinel(144704121)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'domain' (nsCString?) member of 'ContentPrincipalInfo'");
        return {};
    }
    auto maybe___baseDomain = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___baseDomain) {
        aReader->FatalError("Error deserializing 'baseDomain' (nsCString) member of 'ContentPrincipalInfo'");
        return {};

    }
    auto& _baseDomain = *maybe___baseDomain;
    // Sentinel = 'baseDomain'
    if ((!((aReader)->ReadSentinel(360449012)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'baseDomain' (nsCString) member of 'ContentPrincipalInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_attrs),
            std::move(_originNoSuffix),
            std::move(_spec),
            std::move(_domain),
            std::move(_baseDomain)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SystemPrincipalInfo|
//
namespace mozilla {
namespace ipc {
auto SystemPrincipalInfo::operator==(const SystemPrincipalInfo& _o) const -> bool
{
    return true;
}

auto SystemPrincipalInfo::operator!=(const SystemPrincipalInfo& _o) const -> bool
{
    return (!(operator==(_o)));
}

} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::SystemPrincipalInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
}

auto ParamTraits<::mozilla::ipc::SystemPrincipalInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    IPC::ReadResult<paramType> result__{std::in_place};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct NullPrincipalInfo|
//
namespace mozilla {
namespace ipc {
auto NullPrincipalInfo::operator==(const NullPrincipalInfo& _o) const -> bool
{
    if ((!((attrs()) == ((_o).attrs())))) {
        return false;
    }
    if ((!((spec()) == ((_o).spec())))) {
        return false;
    }
    return true;
}

auto NullPrincipalInfo::operator!=(const NullPrincipalInfo& _o) const -> bool
{
    return (!(operator==(_o)));
}

} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::NullPrincipalInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).attrs());
    // Sentinel = 'attrs'
    (aWriter)->WriteSentinel(107807279);
    IPC::WriteParam(aWriter, (aVar).spec());
    // Sentinel = 'spec'
    (aWriter)->WriteSentinel(72155564);
}

auto ParamTraits<::mozilla::ipc::NullPrincipalInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___attrs = IPC::ReadParam<::mozilla::OriginAttributes>(aReader);
    if (!maybe___attrs) {
        aReader->FatalError("Error deserializing 'attrs' (OriginAttributes) member of 'NullPrincipalInfo'");
        return {};

    }
    auto& _attrs = *maybe___attrs;
    // Sentinel = 'attrs'
    if ((!((aReader)->ReadSentinel(107807279)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'attrs' (OriginAttributes) member of 'NullPrincipalInfo'");
        return {};
    }
    auto maybe___spec = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___spec) {
        aReader->FatalError("Error deserializing 'spec' (nsCString) member of 'NullPrincipalInfo'");
        return {};

    }
    auto& _spec = *maybe___spec;
    // Sentinel = 'spec'
    if ((!((aReader)->ReadSentinel(72155564)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'spec' (nsCString) member of 'NullPrincipalInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_attrs),
            std::move(_spec)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ExpandedPrincipalInfo|
//
namespace mozilla {
namespace ipc {
auto ExpandedPrincipalInfo::operator==(const ExpandedPrincipalInfo& _o) const -> bool
{
    if ((!((attrs()) == ((_o).attrs())))) {
        return false;
    }
    if ((!((allowlist()) == ((_o).allowlist())))) {
        return false;
    }
    return true;
}

auto ExpandedPrincipalInfo::operator!=(const ExpandedPrincipalInfo& _o) const -> bool
{
    return (!(operator==(_o)));
}

} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::ExpandedPrincipalInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).attrs());
    // Sentinel = 'attrs'
    (aWriter)->WriteSentinel(107807279);
    IPC::WriteParam(aWriter, (aVar).allowlist());
    // Sentinel = 'allowlist'
    (aWriter)->WriteSentinel(318243804);
}

auto ParamTraits<::mozilla::ipc::ExpandedPrincipalInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___attrs = IPC::ReadParam<::mozilla::OriginAttributes>(aReader);
    if (!maybe___attrs) {
        aReader->FatalError("Error deserializing 'attrs' (OriginAttributes) member of 'ExpandedPrincipalInfo'");
        return {};

    }
    auto& _attrs = *maybe___attrs;
    // Sentinel = 'attrs'
    if ((!((aReader)->ReadSentinel(107807279)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'attrs' (OriginAttributes) member of 'ExpandedPrincipalInfo'");
        return {};
    }
    auto maybe___allowlist = IPC::ReadParam<nsTArray<::mozilla::ipc::PrincipalInfo>>(aReader);
    if (!maybe___allowlist) {
        aReader->FatalError("Error deserializing 'allowlist' (PrincipalInfo[]) member of 'ExpandedPrincipalInfo'");
        return {};

    }
    auto& _allowlist = *maybe___allowlist;
    // Sentinel = 'allowlist'
    if ((!((aReader)->ReadSentinel(318243804)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'allowlist' (PrincipalInfo[]) member of 'ExpandedPrincipalInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_attrs),
            std::move(_allowlist)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union PrincipalInfo|
//
namespace mozilla {
namespace ipc {
auto PrincipalInfo::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TContentPrincipalInfo:
        {
            (ptr_ContentPrincipalInfo())->~ContentPrincipalInfo__tdef();
            break;
        }
    case TSystemPrincipalInfo:
        {
            (ptr_SystemPrincipalInfo())->~SystemPrincipalInfo__tdef();
            break;
        }
    case TNullPrincipalInfo:
        {
            (ptr_NullPrincipalInfo())->~NullPrincipalInfo__tdef();
            break;
        }
    case TExpandedPrincipalInfo:
        {
            delete ptr_ExpandedPrincipalInfo();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT PrincipalInfo::PrincipalInfo(const ContentPrincipalInfo& aOther)
{
    new (mozilla::KnownNotNull, ptr_ContentPrincipalInfo()) ContentPrincipalInfo(aOther);
    mType = TContentPrincipalInfo;
}

MOZ_IMPLICIT PrincipalInfo::PrincipalInfo(ContentPrincipalInfo&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ContentPrincipalInfo()) ContentPrincipalInfo(std::move(aOther));
    mType = TContentPrincipalInfo;
}

MOZ_IMPLICIT PrincipalInfo::PrincipalInfo(const SystemPrincipalInfo& aOther)
{
    new (mozilla::KnownNotNull, ptr_SystemPrincipalInfo()) SystemPrincipalInfo(aOther);
    mType = TSystemPrincipalInfo;
}

MOZ_IMPLICIT PrincipalInfo::PrincipalInfo(SystemPrincipalInfo&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SystemPrincipalInfo()) SystemPrincipalInfo(std::move(aOther));
    mType = TSystemPrincipalInfo;
}

MOZ_IMPLICIT PrincipalInfo::PrincipalInfo(const NullPrincipalInfo& aOther)
{
    new (mozilla::KnownNotNull, ptr_NullPrincipalInfo()) NullPrincipalInfo(aOther);
    mType = TNullPrincipalInfo;
}

MOZ_IMPLICIT PrincipalInfo::PrincipalInfo(NullPrincipalInfo&& aOther)
{
    new (mozilla::KnownNotNull, ptr_NullPrincipalInfo()) NullPrincipalInfo(std::move(aOther));
    mType = TNullPrincipalInfo;
}

MOZ_IMPLICIT PrincipalInfo::PrincipalInfo(const ExpandedPrincipalInfo& aOther)
{
    ptr_ExpandedPrincipalInfo() = new ExpandedPrincipalInfo(aOther);
    mType = TExpandedPrincipalInfo;
}

MOZ_IMPLICIT PrincipalInfo::PrincipalInfo(ExpandedPrincipalInfo&& aOther)
{
    ptr_ExpandedPrincipalInfo() = new ExpandedPrincipalInfo(std::move(aOther));
    mType = TExpandedPrincipalInfo;
}

MOZ_IMPLICIT PrincipalInfo::PrincipalInfo(const PrincipalInfo& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TContentPrincipalInfo:
        {
            new (mozilla::KnownNotNull, ptr_ContentPrincipalInfo()) ContentPrincipalInfo((aOther).get_ContentPrincipalInfo());
            break;
        }
    case TSystemPrincipalInfo:
        {
            new (mozilla::KnownNotNull, ptr_SystemPrincipalInfo()) SystemPrincipalInfo((aOther).get_SystemPrincipalInfo());
            break;
        }
    case TNullPrincipalInfo:
        {
            new (mozilla::KnownNotNull, ptr_NullPrincipalInfo()) NullPrincipalInfo((aOther).get_NullPrincipalInfo());
            break;
        }
    case TExpandedPrincipalInfo:
        {
            ptr_ExpandedPrincipalInfo() = new ExpandedPrincipalInfo((aOther).get_ExpandedPrincipalInfo());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT PrincipalInfo::PrincipalInfo(PrincipalInfo&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TContentPrincipalInfo:
        {
            new (mozilla::KnownNotNull, ptr_ContentPrincipalInfo()) ContentPrincipalInfo(std::move((aOther).get_ContentPrincipalInfo()));
            (aOther).MaybeDestroy();
            break;
        }
    case TSystemPrincipalInfo:
        {
            new (mozilla::KnownNotNull, ptr_SystemPrincipalInfo()) SystemPrincipalInfo(std::move((aOther).get_SystemPrincipalInfo()));
            (aOther).MaybeDestroy();
            break;
        }
    case TNullPrincipalInfo:
        {
            new (mozilla::KnownNotNull, ptr_NullPrincipalInfo()) NullPrincipalInfo(std::move((aOther).get_NullPrincipalInfo()));
            (aOther).MaybeDestroy();
            break;
        }
    case TExpandedPrincipalInfo:
        {
            ptr_ExpandedPrincipalInfo() = (aOther).ptr_ExpandedPrincipalInfo();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

PrincipalInfo::~PrincipalInfo()
{
    MaybeDestroy();
}

auto PrincipalInfo::operator=(const ContentPrincipalInfo& aRhs) -> PrincipalInfo&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ContentPrincipalInfo()) ContentPrincipalInfo(aRhs);
    mType = TContentPrincipalInfo;
    return (*(this));
}

auto PrincipalInfo::operator=(ContentPrincipalInfo&& aRhs) -> PrincipalInfo&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ContentPrincipalInfo()) ContentPrincipalInfo(std::move(aRhs));
    mType = TContentPrincipalInfo;
    return (*(this));
}

auto PrincipalInfo::operator=(const SystemPrincipalInfo& aRhs) -> PrincipalInfo&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_SystemPrincipalInfo()) SystemPrincipalInfo(aRhs);
    mType = TSystemPrincipalInfo;
    return (*(this));
}

auto PrincipalInfo::operator=(SystemPrincipalInfo&& aRhs) -> PrincipalInfo&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_SystemPrincipalInfo()) SystemPrincipalInfo(std::move(aRhs));
    mType = TSystemPrincipalInfo;
    return (*(this));
}

auto PrincipalInfo::operator=(const NullPrincipalInfo& aRhs) -> PrincipalInfo&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_NullPrincipalInfo()) NullPrincipalInfo(aRhs);
    mType = TNullPrincipalInfo;
    return (*(this));
}

auto PrincipalInfo::operator=(NullPrincipalInfo&& aRhs) -> PrincipalInfo&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_NullPrincipalInfo()) NullPrincipalInfo(std::move(aRhs));
    mType = TNullPrincipalInfo;
    return (*(this));
}

auto PrincipalInfo::operator=(const ExpandedPrincipalInfo& aRhs) -> PrincipalInfo&
{
    MaybeDestroy();
    ptr_ExpandedPrincipalInfo() = new ExpandedPrincipalInfo(aRhs);
    mType = TExpandedPrincipalInfo;
    return (*(this));
}

auto PrincipalInfo::operator=(ExpandedPrincipalInfo&& aRhs) -> PrincipalInfo&
{
    MaybeDestroy();
    ptr_ExpandedPrincipalInfo() = new ExpandedPrincipalInfo(std::move(aRhs));
    mType = TExpandedPrincipalInfo;
    return (*(this));
}

auto PrincipalInfo::operator=(const PrincipalInfo& aRhs) -> PrincipalInfo&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TContentPrincipalInfo:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ContentPrincipalInfo()) ContentPrincipalInfo((aRhs).get_ContentPrincipalInfo());
            break;
        }
    case TSystemPrincipalInfo:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_SystemPrincipalInfo()) SystemPrincipalInfo((aRhs).get_SystemPrincipalInfo());
            break;
        }
    case TNullPrincipalInfo:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_NullPrincipalInfo()) NullPrincipalInfo((aRhs).get_NullPrincipalInfo());
            break;
        }
    case TExpandedPrincipalInfo:
        {
            MaybeDestroy();
            ptr_ExpandedPrincipalInfo() = new ExpandedPrincipalInfo((aRhs).get_ExpandedPrincipalInfo());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto PrincipalInfo::operator=(PrincipalInfo&& aRhs) -> PrincipalInfo&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TContentPrincipalInfo:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ContentPrincipalInfo()) ContentPrincipalInfo(std::move((aRhs).get_ContentPrincipalInfo()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TSystemPrincipalInfo:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_SystemPrincipalInfo()) SystemPrincipalInfo(std::move((aRhs).get_SystemPrincipalInfo()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TNullPrincipalInfo:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_NullPrincipalInfo()) NullPrincipalInfo(std::move((aRhs).get_NullPrincipalInfo()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TExpandedPrincipalInfo:
        {
            MaybeDestroy();
            ptr_ExpandedPrincipalInfo() = (aRhs).ptr_ExpandedPrincipalInfo();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto PrincipalInfo::operator==(const ContentPrincipalInfo& aRhs) const -> bool
{
    return (get_ContentPrincipalInfo()) == (aRhs);
}

auto PrincipalInfo::operator==(const SystemPrincipalInfo& aRhs) const -> bool
{
    return (get_SystemPrincipalInfo()) == (aRhs);
}

auto PrincipalInfo::operator==(const NullPrincipalInfo& aRhs) const -> bool
{
    return (get_NullPrincipalInfo()) == (aRhs);
}

auto PrincipalInfo::operator==(const ExpandedPrincipalInfo& aRhs) const -> bool
{
    return (get_ExpandedPrincipalInfo()) == (aRhs);
}

auto PrincipalInfo::operator==(const PrincipalInfo& aRhs) const -> bool
{
    if ((type()) != ((aRhs).type())) {
        return false;
    }

    switch (type()) {
    case TContentPrincipalInfo:
        {
            return (get_ContentPrincipalInfo()) == ((aRhs).get_ContentPrincipalInfo());
        }
    case TSystemPrincipalInfo:
        {
            return (get_SystemPrincipalInfo()) == ((aRhs).get_SystemPrincipalInfo());
        }
    case TNullPrincipalInfo:
        {
            return (get_NullPrincipalInfo()) == ((aRhs).get_NullPrincipalInfo());
        }
    case TExpandedPrincipalInfo:
        {
            return (get_ExpandedPrincipalInfo()) == ((aRhs).get_ExpandedPrincipalInfo());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::PrincipalInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::ipc::PrincipalInfo union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'PrincipalInfo'
    (aWriter)->WriteSentinel(606209327);

    switch (type) {
    case union__::TContentPrincipalInfo:
        {
            IPC::WriteParam(aWriter, (aVar).get_ContentPrincipalInfo());
            // Sentinel = 'TContentPrincipalInfo'
            (aWriter)->WriteSentinel(1527842910);
            return;
        }
    case union__::TSystemPrincipalInfo:
        {
            IPC::WriteParam(aWriter, (aVar).get_SystemPrincipalInfo());
            // Sentinel = 'TSystemPrincipalInfo'
            (aWriter)->WriteSentinel(1411909640);
            return;
        }
    case union__::TNullPrincipalInfo:
        {
            IPC::WriteParam(aWriter, (aVar).get_NullPrincipalInfo());
            // Sentinel = 'TNullPrincipalInfo'
            (aWriter)->WriteSentinel(1120470814);
            return;
        }
    case union__::TExpandedPrincipalInfo:
        {
            IPC::WriteParam(aWriter, (aVar).get_ExpandedPrincipalInfo());
            // Sentinel = 'TExpandedPrincipalInfo'
            (aWriter)->WriteSentinel(1652492460);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union PrincipalInfo");
            return;
        }
    }
}

auto ParamTraits<::mozilla::ipc::PrincipalInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    typedef ::mozilla::ipc::PrincipalInfo union__;
    auto maybe__type = IPC::ReadParam<int>(aReader);
    if (!maybe__type) {
        aReader->FatalError("Error deserializing type of union PrincipalInfo");
        return {};

    }
    auto& type = *maybe__type;
    // Sentinel = 'PrincipalInfo'
    if ((!((aReader)->ReadSentinel(606209327)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union PrincipalInfo");
        return {};
    }

    switch (type) {
    case union__::TContentPrincipalInfo:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::ContentPrincipalInfo>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TContentPrincipalInfo of union PrincipalInfo");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TContentPrincipalInfo'
            if ((!((aReader)->ReadSentinel(1527842910)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TContentPrincipalInfo of union PrincipalInfo");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TSystemPrincipalInfo:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::SystemPrincipalInfo>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TSystemPrincipalInfo of union PrincipalInfo");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TSystemPrincipalInfo'
            if ((!((aReader)->ReadSentinel(1411909640)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSystemPrincipalInfo of union PrincipalInfo");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TNullPrincipalInfo:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::NullPrincipalInfo>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TNullPrincipalInfo of union PrincipalInfo");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TNullPrincipalInfo'
            if ((!((aReader)->ReadSentinel(1120470814)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TNullPrincipalInfo of union PrincipalInfo");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TExpandedPrincipalInfo:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::ExpandedPrincipalInfo>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TExpandedPrincipalInfo of union PrincipalInfo");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TExpandedPrincipalInfo'
            if ((!((aReader)->ReadSentinel(1652492460)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TExpandedPrincipalInfo of union PrincipalInfo");
                return {};
            }
            return std::move(tmp);
        }
    default:
        {
            aReader->FatalError("unknown variant of union PrincipalInfo");
            return {};
        }
    }
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CSPInfo|
//
namespace mozilla {
namespace ipc {
auto CSPInfo::operator==(const CSPInfo& _o) const -> bool
{
    if ((!((policyInfos()) == ((_o).policyInfos())))) {
        return false;
    }
    if ((!((requestPrincipalInfo()) == ((_o).requestPrincipalInfo())))) {
        return false;
    }
    if ((!((selfURISpec()) == ((_o).selfURISpec())))) {
        return false;
    }
    if ((!((referrer()) == ((_o).referrer())))) {
        return false;
    }
    if ((!((innerWindowID()) == ((_o).innerWindowID())))) {
        return false;
    }
    if ((!((requireTrustedTypesForDirectiveState()) == ((_o).requireTrustedTypesForDirectiveState())))) {
        return false;
    }
    if ((!((skipAllowInlineStyleCheck()) == ((_o).skipAllowInlineStyleCheck())))) {
        return false;
    }
    return true;
}

auto CSPInfo::operator!=(const CSPInfo& _o) const -> bool
{
    return (!(operator==(_o)));
}

} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::CSPInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).policyInfos());
    // Sentinel = 'policyInfos'
    (aWriter)->WriteSentinel(460850320);
    IPC::WriteParam(aWriter, (aVar).requestPrincipalInfo());
    // Sentinel = 'requestPrincipalInfo'
    (aWriter)->WriteSentinel(1470892088);
    IPC::WriteParam(aWriter, (aVar).selfURISpec());
    // Sentinel = 'selfURISpec'
    (aWriter)->WriteSentinel(425657382);
    IPC::WriteParam(aWriter, (aVar).referrer());
    // Sentinel = 'referrer'
    (aWriter)->WriteSentinel(252838750);
    IPC::WriteParam(aWriter, (aVar).requireTrustedTypesForDirectiveState());
    // Sentinel = 'requireTrustedTypesForDirectiveState'
    (aWriter)->WriteSentinel(332992197);
    IPC::WriteParam(aWriter, (aVar).skipAllowInlineStyleCheck());
    // Sentinel = 'skipAllowInlineStyleCheck'
    (aWriter)->WriteSentinel(2204240389);
    (aWriter)->WriteBytes((&((aVar).innerWindowID())), 8);
    // Sentinel = 'innerWindowID'
    (aWriter)->WriteSentinel(625870114);
}

auto ParamTraits<::mozilla::ipc::CSPInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___policyInfos = IPC::ReadParam<nsTArray<::mozilla::ipc::ContentSecurityPolicy>>(aReader);
    if (!maybe___policyInfos) {
        aReader->FatalError("Error deserializing 'policyInfos' (ContentSecurityPolicy[]) member of 'CSPInfo'");
        return {};

    }
    auto& _policyInfos = *maybe___policyInfos;
    // Sentinel = 'policyInfos'
    if ((!((aReader)->ReadSentinel(460850320)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'policyInfos' (ContentSecurityPolicy[]) member of 'CSPInfo'");
        return {};
    }
    auto maybe___requestPrincipalInfo = IPC::ReadParam<::mozilla::ipc::PrincipalInfo>(aReader);
    if (!maybe___requestPrincipalInfo) {
        aReader->FatalError("Error deserializing 'requestPrincipalInfo' (PrincipalInfo) member of 'CSPInfo'");
        return {};

    }
    auto& _requestPrincipalInfo = *maybe___requestPrincipalInfo;
    // Sentinel = 'requestPrincipalInfo'
    if ((!((aReader)->ReadSentinel(1470892088)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestPrincipalInfo' (PrincipalInfo) member of 'CSPInfo'");
        return {};
    }
    auto maybe___selfURISpec = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___selfURISpec) {
        aReader->FatalError("Error deserializing 'selfURISpec' (nsCString) member of 'CSPInfo'");
        return {};

    }
    auto& _selfURISpec = *maybe___selfURISpec;
    // Sentinel = 'selfURISpec'
    if ((!((aReader)->ReadSentinel(425657382)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'selfURISpec' (nsCString) member of 'CSPInfo'");
        return {};
    }
    auto maybe___referrer = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___referrer) {
        aReader->FatalError("Error deserializing 'referrer' (nsCString) member of 'CSPInfo'");
        return {};

    }
    auto& _referrer = *maybe___referrer;
    // Sentinel = 'referrer'
    if ((!((aReader)->ReadSentinel(252838750)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'referrer' (nsCString) member of 'CSPInfo'");
        return {};
    }
    auto maybe___requireTrustedTypesForDirectiveState = IPC::ReadParam<::nsIContentSecurityPolicy::RequireTrustedTypesForDirectiveState>(aReader);
    if (!maybe___requireTrustedTypesForDirectiveState) {
        aReader->FatalError("Error deserializing 'requireTrustedTypesForDirectiveState' (RequireTrustedTypesForDirectiveState) member of 'CSPInfo'");
        return {};

    }
    auto& _requireTrustedTypesForDirectiveState = *maybe___requireTrustedTypesForDirectiveState;
    // Sentinel = 'requireTrustedTypesForDirectiveState'
    if ((!((aReader)->ReadSentinel(332992197)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requireTrustedTypesForDirectiveState' (RequireTrustedTypesForDirectiveState) member of 'CSPInfo'");
        return {};
    }
    auto maybe___skipAllowInlineStyleCheck = IPC::ReadParam<bool>(aReader);
    if (!maybe___skipAllowInlineStyleCheck) {
        aReader->FatalError("Error deserializing 'skipAllowInlineStyleCheck' (bool) member of 'CSPInfo'");
        return {};

    }
    auto& _skipAllowInlineStyleCheck = *maybe___skipAllowInlineStyleCheck;
    // Sentinel = 'skipAllowInlineStyleCheck'
    if ((!((aReader)->ReadSentinel(2204240389)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'skipAllowInlineStyleCheck' (bool) member of 'CSPInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_policyInfos),
            std::move(_requestPrincipalInfo),
            std::move(_selfURISpec),
            std::move(_referrer),
            ::uint64_t{0},
            std::move(_requireTrustedTypesForDirectiveState),
            std::move(_skipAllowInlineStyleCheck)};
    if ((!((aReader)->ReadBytesInto((&((result__)->innerWindowID())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint64_t");
        return {};
    }
    // Sentinel = 'innerWindowID'
    if ((!((aReader)->ReadSentinel(625870114)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IntegrityPolicyEntry|
//
namespace mozilla {
namespace ipc {
auto IntegrityPolicyEntry::operator==(const IntegrityPolicyEntry& _o) const -> bool
{
    if ((!((sources()) == ((_o).sources())))) {
        return false;
    }
    if ((!((destinations()) == ((_o).destinations())))) {
        return false;
    }
    if ((!((endpoints()) == ((_o).endpoints())))) {
        return false;
    }
    return true;
}

auto IntegrityPolicyEntry::operator!=(const IntegrityPolicyEntry& _o) const -> bool
{
    return (!(operator==(_o)));
}

} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::IntegrityPolicyEntry>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).sources());
    // Sentinel = 'sources'
    (aWriter)->WriteSentinel(205325061);
    IPC::WriteParam(aWriter, (aVar).destinations());
    // Sentinel = 'destinations'
    (aWriter)->WriteSentinel(548996374);
    IPC::WriteParam(aWriter, (aVar).endpoints());
    // Sentinel = 'endpoints'
    (aWriter)->WriteSentinel(316015573);
}

auto ParamTraits<::mozilla::ipc::IntegrityPolicyEntry>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___sources = IPC::ReadParam<::mozilla::dom::IntegrityPolicy::Sources>(aReader);
    if (!maybe___sources) {
        aReader->FatalError("Error deserializing 'sources' (Sources) member of 'IntegrityPolicyEntry'");
        return {};

    }
    auto& _sources = *maybe___sources;
    // Sentinel = 'sources'
    if ((!((aReader)->ReadSentinel(205325061)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'sources' (Sources) member of 'IntegrityPolicyEntry'");
        return {};
    }
    auto maybe___destinations = IPC::ReadParam<::mozilla::dom::IntegrityPolicy::Destinations>(aReader);
    if (!maybe___destinations) {
        aReader->FatalError("Error deserializing 'destinations' (Destinations) member of 'IntegrityPolicyEntry'");
        return {};

    }
    auto& _destinations = *maybe___destinations;
    // Sentinel = 'destinations'
    if ((!((aReader)->ReadSentinel(548996374)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'destinations' (Destinations) member of 'IntegrityPolicyEntry'");
        return {};
    }
    auto maybe___endpoints = IPC::ReadParam<nsTArray<::nsCString>>(aReader);
    if (!maybe___endpoints) {
        aReader->FatalError("Error deserializing 'endpoints' (nsCString[]) member of 'IntegrityPolicyEntry'");
        return {};

    }
    auto& _endpoints = *maybe___endpoints;
    // Sentinel = 'endpoints'
    if ((!((aReader)->ReadSentinel(316015573)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'endpoints' (nsCString[]) member of 'IntegrityPolicyEntry'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_sources),
            std::move(_destinations),
            std::move(_endpoints)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IntegrityPolicyArgs|
//
namespace mozilla {
namespace ipc {
auto IntegrityPolicyArgs::operator==(const IntegrityPolicyArgs& _o) const -> bool
{
    if ((!((enforcement()) == ((_o).enforcement())))) {
        return false;
    }
    if ((!((reportOnly()) == ((_o).reportOnly())))) {
        return false;
    }
    return true;
}

auto IntegrityPolicyArgs::operator!=(const IntegrityPolicyArgs& _o) const -> bool
{
    return (!(operator==(_o)));
}

} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::IntegrityPolicyArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).enforcement());
    // Sentinel = 'enforcement'
    (aWriter)->WriteSentinel(458753175);
    IPC::WriteParam(aWriter, (aVar).reportOnly());
    // Sentinel = 'reportOnly'
    (aWriter)->WriteSentinel(391840831);
}

auto ParamTraits<::mozilla::ipc::IntegrityPolicyArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___enforcement = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::IntegrityPolicyEntry>>(aReader);
    if (!maybe___enforcement) {
        aReader->FatalError("Error deserializing 'enforcement' (IntegrityPolicyEntry?) member of 'IntegrityPolicyArgs'");
        return {};

    }
    auto& _enforcement = *maybe___enforcement;
    // Sentinel = 'enforcement'
    if ((!((aReader)->ReadSentinel(458753175)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'enforcement' (IntegrityPolicyEntry?) member of 'IntegrityPolicyArgs'");
        return {};
    }
    auto maybe___reportOnly = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::IntegrityPolicyEntry>>(aReader);
    if (!maybe___reportOnly) {
        aReader->FatalError("Error deserializing 'reportOnly' (IntegrityPolicyEntry?) member of 'IntegrityPolicyArgs'");
        return {};

    }
    auto& _reportOnly = *maybe___reportOnly;
    // Sentinel = 'reportOnly'
    if ((!((aReader)->ReadSentinel(391840831)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'reportOnly' (IntegrityPolicyEntry?) member of 'IntegrityPolicyArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_enforcement),
            std::move(_reportOnly)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct PolicyContainerArgs|
//
namespace mozilla {
namespace ipc {
auto PolicyContainerArgs::operator==(const PolicyContainerArgs& _o) const -> bool
{
    if ((!((csp()) == ((_o).csp())))) {
        return false;
    }
    if ((!((integrityPolicy()) == ((_o).integrityPolicy())))) {
        return false;
    }
    return true;
}

auto PolicyContainerArgs::operator!=(const PolicyContainerArgs& _o) const -> bool
{
    return (!(operator==(_o)));
}

} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::PolicyContainerArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).csp());
    // Sentinel = 'csp'
    (aWriter)->WriteSentinel(42074439);
    IPC::WriteParam(aWriter, (aVar).integrityPolicy());
    // Sentinel = 'integrityPolicy'
    (aWriter)->WriteSentinel(848299600);
}

auto ParamTraits<::mozilla::ipc::PolicyContainerArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___csp = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::CSPInfo>>(aReader);
    if (!maybe___csp) {
        aReader->FatalError("Error deserializing 'csp' (CSPInfo?) member of 'PolicyContainerArgs'");
        return {};

    }
    auto& _csp = *maybe___csp;
    // Sentinel = 'csp'
    if ((!((aReader)->ReadSentinel(42074439)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'csp' (CSPInfo?) member of 'PolicyContainerArgs'");
        return {};
    }
    auto maybe___integrityPolicy = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::IntegrityPolicyArgs>>(aReader);
    if (!maybe___integrityPolicy) {
        aReader->FatalError("Error deserializing 'integrityPolicy' (IntegrityPolicyArgs?) member of 'PolicyContainerArgs'");
        return {};

    }
    auto& _integrityPolicy = *maybe___integrityPolicy;
    // Sentinel = 'integrityPolicy'
    if ((!((aReader)->ReadSentinel(848299600)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'integrityPolicy' (IntegrityPolicyArgs?) member of 'PolicyContainerArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_csp),
            std::move(_integrityPolicy)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct WebTransportHash|
//
namespace mozilla {
namespace ipc {
auto WebTransportHash::operator==(const WebTransportHash& _o) const -> bool
{
    if ((!((algorithm()) == ((_o).algorithm())))) {
        return false;
    }
    if ((!((value()) == ((_o).value())))) {
        return false;
    }
    return true;
}

auto WebTransportHash::operator!=(const WebTransportHash& _o) const -> bool
{
    return (!(operator==(_o)));
}

} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::WebTransportHash>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).algorithm());
    // Sentinel = 'algorithm'
    (aWriter)->WriteSentinel(313787336);
    IPC::WriteParam(aWriter, (aVar).value());
    // Sentinel = 'value'
    (aWriter)->WriteSentinel(107610654);
}

auto ParamTraits<::mozilla::ipc::WebTransportHash>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___algorithm = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___algorithm) {
        aReader->FatalError("Error deserializing 'algorithm' (nsCString) member of 'WebTransportHash'");
        return {};

    }
    auto& _algorithm = *maybe___algorithm;
    // Sentinel = 'algorithm'
    if ((!((aReader)->ReadSentinel(313787336)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'algorithm' (nsCString) member of 'WebTransportHash'");
        return {};
    }
    auto maybe___value = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___value) {
        aReader->FatalError("Error deserializing 'value' (uint8_t[]) member of 'WebTransportHash'");
        return {};

    }
    auto& _value = *maybe___value;
    // Sentinel = 'value'
    if ((!((aReader)->ReadSentinel(107610654)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'value' (uint8_t[]) member of 'WebTransportHash'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_algorithm),
            std::move(_value)};
    return result__;
}

} // namespace IPC
