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


#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/ipc/URIParams.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 SimpleURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla

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

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

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct DefaultURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla

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

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

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StandardURLSegment|
//
namespace mozilla {
namespace ipc {
auto StandardURLSegment::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(StandardURLSegment, length_) - offsetof(StandardURLSegment, position_)) == 4,
        "Bad assumptions about field layout!");
}

} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::StandardURLSegment>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    (aWriter)->WriteBytes((&((aVar).position())), 8);
    // Sentinel = 'position | length'
    (aWriter)->WriteSentinel(1030424244);
}

auto ParamTraits<::mozilla::ipc::StandardURLSegment>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::uint32_t{0},
            ::int32_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->position())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'position | length'
    if ((!((aReader)->ReadSentinel(1030424244)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StandardURLParams|
//
namespace mozilla {
namespace ipc {
auto StandardURLParams::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(StandardURLParams, defaultPort_) - offsetof(StandardURLParams, urlType_)) == 8,
        "Bad assumptions about field layout!");
}

} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::StandardURLParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).spec());
    // Sentinel = 'spec'
    (aWriter)->WriteSentinel(72155564);
    IPC::WriteParam(aWriter, (aVar).scheme());
    // Sentinel = 'scheme'
    (aWriter)->WriteSentinel(146080374);
    IPC::WriteParam(aWriter, (aVar).authority());
    // Sentinel = 'authority'
    (aWriter)->WriteSentinel(323290090);
    IPC::WriteParam(aWriter, (aVar).username());
    // Sentinel = 'username'
    (aWriter)->WriteSentinel(260506465);
    IPC::WriteParam(aWriter, (aVar).password());
    // Sentinel = 'password'
    (aWriter)->WriteSentinel(261161844);
    IPC::WriteParam(aWriter, (aVar).host());
    // Sentinel = 'host'
    (aWriter)->WriteSentinel(72024511);
    IPC::WriteParam(aWriter, (aVar).path());
    // Sentinel = 'path'
    (aWriter)->WriteSentinel(70713774);
    IPC::WriteParam(aWriter, (aVar).filePath());
    // Sentinel = 'filePath'
    (aWriter)->WriteSentinel(239797038);
    IPC::WriteParam(aWriter, (aVar).directory());
    // Sentinel = 'directory'
    (aWriter)->WriteSentinel(314180566);
    IPC::WriteParam(aWriter, (aVar).baseName());
    // Sentinel = 'baseName'
    (aWriter)->WriteSentinel(235143965);
    IPC::WriteParam(aWriter, (aVar).extension());
    // Sentinel = 'extension'
    (aWriter)->WriteSentinel(324600798);
    IPC::WriteParam(aWriter, (aVar).query());
    // Sentinel = 'query'
    (aWriter)->WriteSentinel(110756407);
    IPC::WriteParam(aWriter, (aVar).ref());
    // Sentinel = 'ref'
    (aWriter)->WriteSentinel(42533182);
    IPC::WriteParam(aWriter, (aVar).supportsFileURL());
    // Sentinel = 'supportsFileURL'
    (aWriter)->WriteSentinel(856032772);
    IPC::WriteParam(aWriter, (aVar).isSubstituting());
    // Sentinel = 'isSubstituting'
    (aWriter)->WriteSentinel(742065650);
    (aWriter)->WriteBytes((&((aVar).urlType())), 12);
    // Sentinel = 'urlType | port | defaultPort'
    (aWriter)->WriteSentinel(2589395645);
}

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

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

    }
    auto& _scheme = *maybe___scheme;
    // Sentinel = 'scheme'
    if ((!((aReader)->ReadSentinel(146080374)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scheme' (StandardURLSegment) member of 'StandardURLParams'");
        return {};
    }
    auto maybe___authority = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
    if (!maybe___authority) {
        aReader->FatalError("Error deserializing 'authority' (StandardURLSegment) member of 'StandardURLParams'");
        return {};

    }
    auto& _authority = *maybe___authority;
    // Sentinel = 'authority'
    if ((!((aReader)->ReadSentinel(323290090)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'authority' (StandardURLSegment) member of 'StandardURLParams'");
        return {};
    }
    auto maybe___username = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
    if (!maybe___username) {
        aReader->FatalError("Error deserializing 'username' (StandardURLSegment) member of 'StandardURLParams'");
        return {};

    }
    auto& _username = *maybe___username;
    // Sentinel = 'username'
    if ((!((aReader)->ReadSentinel(260506465)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'username' (StandardURLSegment) member of 'StandardURLParams'");
        return {};
    }
    auto maybe___password = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
    if (!maybe___password) {
        aReader->FatalError("Error deserializing 'password' (StandardURLSegment) member of 'StandardURLParams'");
        return {};

    }
    auto& _password = *maybe___password;
    // Sentinel = 'password'
    if ((!((aReader)->ReadSentinel(261161844)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'password' (StandardURLSegment) member of 'StandardURLParams'");
        return {};
    }
    auto maybe___host = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
    if (!maybe___host) {
        aReader->FatalError("Error deserializing 'host' (StandardURLSegment) member of 'StandardURLParams'");
        return {};

    }
    auto& _host = *maybe___host;
    // Sentinel = 'host'
    if ((!((aReader)->ReadSentinel(72024511)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'host' (StandardURLSegment) member of 'StandardURLParams'");
        return {};
    }
    auto maybe___path = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
    if (!maybe___path) {
        aReader->FatalError("Error deserializing 'path' (StandardURLSegment) member of 'StandardURLParams'");
        return {};

    }
    auto& _path = *maybe___path;
    // Sentinel = 'path'
    if ((!((aReader)->ReadSentinel(70713774)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'path' (StandardURLSegment) member of 'StandardURLParams'");
        return {};
    }
    auto maybe___filePath = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
    if (!maybe___filePath) {
        aReader->FatalError("Error deserializing 'filePath' (StandardURLSegment) member of 'StandardURLParams'");
        return {};

    }
    auto& _filePath = *maybe___filePath;
    // Sentinel = 'filePath'
    if ((!((aReader)->ReadSentinel(239797038)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'filePath' (StandardURLSegment) member of 'StandardURLParams'");
        return {};
    }
    auto maybe___directory = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
    if (!maybe___directory) {
        aReader->FatalError("Error deserializing 'directory' (StandardURLSegment) member of 'StandardURLParams'");
        return {};

    }
    auto& _directory = *maybe___directory;
    // Sentinel = 'directory'
    if ((!((aReader)->ReadSentinel(314180566)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'directory' (StandardURLSegment) member of 'StandardURLParams'");
        return {};
    }
    auto maybe___baseName = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
    if (!maybe___baseName) {
        aReader->FatalError("Error deserializing 'baseName' (StandardURLSegment) member of 'StandardURLParams'");
        return {};

    }
    auto& _baseName = *maybe___baseName;
    // Sentinel = 'baseName'
    if ((!((aReader)->ReadSentinel(235143965)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'baseName' (StandardURLSegment) member of 'StandardURLParams'");
        return {};
    }
    auto maybe___extension = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
    if (!maybe___extension) {
        aReader->FatalError("Error deserializing 'extension' (StandardURLSegment) member of 'StandardURLParams'");
        return {};

    }
    auto& _extension = *maybe___extension;
    // Sentinel = 'extension'
    if ((!((aReader)->ReadSentinel(324600798)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'extension' (StandardURLSegment) member of 'StandardURLParams'");
        return {};
    }
    auto maybe___query = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
    if (!maybe___query) {
        aReader->FatalError("Error deserializing 'query' (StandardURLSegment) member of 'StandardURLParams'");
        return {};

    }
    auto& _query = *maybe___query;
    // Sentinel = 'query'
    if ((!((aReader)->ReadSentinel(110756407)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'query' (StandardURLSegment) member of 'StandardURLParams'");
        return {};
    }
    auto maybe___ref = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
    if (!maybe___ref) {
        aReader->FatalError("Error deserializing 'ref' (StandardURLSegment) member of 'StandardURLParams'");
        return {};

    }
    auto& _ref = *maybe___ref;
    // Sentinel = 'ref'
    if ((!((aReader)->ReadSentinel(42533182)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ref' (StandardURLSegment) member of 'StandardURLParams'");
        return {};
    }
    auto maybe___supportsFileURL = IPC::ReadParam<bool>(aReader);
    if (!maybe___supportsFileURL) {
        aReader->FatalError("Error deserializing 'supportsFileURL' (bool) member of 'StandardURLParams'");
        return {};

    }
    auto& _supportsFileURL = *maybe___supportsFileURL;
    // Sentinel = 'supportsFileURL'
    if ((!((aReader)->ReadSentinel(856032772)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'supportsFileURL' (bool) member of 'StandardURLParams'");
        return {};
    }
    auto maybe___isSubstituting = IPC::ReadParam<bool>(aReader);
    if (!maybe___isSubstituting) {
        aReader->FatalError("Error deserializing 'isSubstituting' (bool) member of 'StandardURLParams'");
        return {};

    }
    auto& _isSubstituting = *maybe___isSubstituting;
    // Sentinel = 'isSubstituting'
    if ((!((aReader)->ReadSentinel(742065650)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isSubstituting' (bool) member of 'StandardURLParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::uint32_t{0},
            ::int32_t{0},
            ::int32_t{0},
            std::move(_spec),
            std::move(_scheme),
            std::move(_authority),
            std::move(_username),
            std::move(_password),
            std::move(_host),
            std::move(_path),
            std::move(_filePath),
            std::move(_directory),
            std::move(_baseName),
            std::move(_extension),
            std::move(_query),
            std::move(_ref),
            std::move(_supportsFileURL),
            std::move(_isSubstituting)};
    if ((!((aReader)->ReadBytesInto((&((result__)->urlType())), 12)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'urlType | port | defaultPort'
    if ((!((aReader)->ReadSentinel(2589395645)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct JARURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::JARURIParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).jarFile());
    // Sentinel = 'jarFile'
    (aWriter)->WriteSentinel(184353470);
    IPC::WriteParam(aWriter, (aVar).jarEntry());
    // Sentinel = 'jarEntry'
    (aWriter)->WriteSentinel(242549584);
    IPC::WriteParam(aWriter, (aVar).charset());
    // Sentinel = 'charset'
    (aWriter)->WriteSentinel(191890155);
}

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

    }
    auto& _jarFile = *maybe___jarFile;
    // Sentinel = 'jarFile'
    if ((!((aReader)->ReadSentinel(184353470)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'jarFile' (URIParams) member of 'JARURIParams'");
        return {};
    }
    auto maybe___jarEntry = IPC::ReadParam<::mozilla::ipc::URIParams>(aReader);
    if (!maybe___jarEntry) {
        aReader->FatalError("Error deserializing 'jarEntry' (URIParams) member of 'JARURIParams'");
        return {};

    }
    auto& _jarEntry = *maybe___jarEntry;
    // Sentinel = 'jarEntry'
    if ((!((aReader)->ReadSentinel(242549584)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'jarEntry' (URIParams) member of 'JARURIParams'");
        return {};
    }
    auto maybe___charset = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___charset) {
        aReader->FatalError("Error deserializing 'charset' (nsCString) member of 'JARURIParams'");
        return {};

    }
    auto& _charset = *maybe___charset;
    // Sentinel = 'charset'
    if ((!((aReader)->ReadSentinel(191890155)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'charset' (nsCString) member of 'JARURIParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_jarFile),
            std::move(_jarEntry),
            std::move(_charset)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IconURIParams|
//
namespace mozilla {
namespace ipc {
auto IconURIParams::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(IconURIParams, iconScale_) - offsetof(IconURIParams, size_)) == 4,
        "Bad assumptions about field layout!");
}

} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::IconURIParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).uri());
    // Sentinel = 'uri'
    (aWriter)->WriteSentinel(45023569);
    IPC::WriteParam(aWriter, (aVar).contentType());
    // Sentinel = 'contentType'
    (aWriter)->WriteSentinel(465241246);
    IPC::WriteParam(aWriter, (aVar).fileName());
    // Sentinel = 'fileName'
    (aWriter)->WriteSentinel(238158626);
    IPC::WriteParam(aWriter, (aVar).stockIcon());
    // Sentinel = 'stockIcon'
    (aWriter)->WriteSentinel(314508206);
    IPC::WriteParam(aWriter, (aVar).iconDark());
    // Sentinel = 'iconDark'
    (aWriter)->WriteSentinel(239534892);
    (aWriter)->WriteBytes((&((aVar).size())), 8);
    // Sentinel = 'size | iconScale'
    (aWriter)->WriteSentinel(859375113);
}

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

    }
    auto& _uri = *maybe___uri;
    // Sentinel = 'uri'
    if ((!((aReader)->ReadSentinel(45023569)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'uri' (URIParams?) member of 'IconURIParams'");
        return {};
    }
    auto maybe___contentType = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___contentType) {
        aReader->FatalError("Error deserializing 'contentType' (nsCString) member of 'IconURIParams'");
        return {};

    }
    auto& _contentType = *maybe___contentType;
    // Sentinel = 'contentType'
    if ((!((aReader)->ReadSentinel(465241246)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'contentType' (nsCString) member of 'IconURIParams'");
        return {};
    }
    auto maybe___fileName = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___fileName) {
        aReader->FatalError("Error deserializing 'fileName' (nsCString) member of 'IconURIParams'");
        return {};

    }
    auto& _fileName = *maybe___fileName;
    // Sentinel = 'fileName'
    if ((!((aReader)->ReadSentinel(238158626)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fileName' (nsCString) member of 'IconURIParams'");
        return {};
    }
    auto maybe___stockIcon = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___stockIcon) {
        aReader->FatalError("Error deserializing 'stockIcon' (nsCString) member of 'IconURIParams'");
        return {};

    }
    auto& _stockIcon = *maybe___stockIcon;
    // Sentinel = 'stockIcon'
    if ((!((aReader)->ReadSentinel(314508206)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'stockIcon' (nsCString) member of 'IconURIParams'");
        return {};
    }
    auto maybe___iconDark = IPC::ReadParam<mozilla::Maybe<bool>>(aReader);
    if (!maybe___iconDark) {
        aReader->FatalError("Error deserializing 'iconDark' (bool?) member of 'IconURIParams'");
        return {};

    }
    auto& _iconDark = *maybe___iconDark;
    // Sentinel = 'iconDark'
    if ((!((aReader)->ReadSentinel(239534892)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'iconDark' (bool?) member of 'IconURIParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_uri),
            ::uint32_t{0},
            std::move(_contentType),
            std::move(_fileName),
            std::move(_stockIcon),
            ::uint32_t{0},
            std::move(_iconDark)};
    if ((!((aReader)->ReadBytesInto((&((result__)->size())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'size | iconScale'
    if ((!((aReader)->ReadSentinel(859375113)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct HostObjectURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::HostObjectURIParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).simpleParams());
    // Sentinel = 'simpleParams'
    (aWriter)->WriteSentinel(541394159);
    IPC::WriteParam(aWriter, (aVar).revoked());
    // Sentinel = 'revoked'
    (aWriter)->WriteSentinel(201065201);
}

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

    }
    auto& _simpleParams = *maybe___simpleParams;
    // Sentinel = 'simpleParams'
    if ((!((aReader)->ReadSentinel(541394159)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'HostObjectURIParams'");
        return {};
    }
    auto maybe___revoked = IPC::ReadParam<bool>(aReader);
    if (!maybe___revoked) {
        aReader->FatalError("Error deserializing 'revoked' (bool) member of 'HostObjectURIParams'");
        return {};

    }
    auto& _revoked = *maybe___revoked;
    // Sentinel = 'revoked'
    if ((!((aReader)->ReadSentinel(201065201)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'revoked' (bool) member of 'HostObjectURIParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_simpleParams),
            std::move(_revoked)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union URIParams|
//
namespace mozilla {
namespace ipc {
auto URIParams::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TSimpleURIParams:
        {
            (ptr_SimpleURIParams())->~SimpleURIParams__tdef();
            break;
        }
    case TStandardURLParams:
        {
            (ptr_StandardURLParams())->~StandardURLParams__tdef();
            break;
        }
    case TJARURIParams:
        {
            delete ptr_JARURIParams();
            break;
        }
    case TIconURIParams:
        {
            delete ptr_IconURIParams();
            break;
        }
    case TJSURIParams:
        {
            delete ptr_JSURIParams();
            break;
        }
    case TSimpleNestedURIParams:
        {
            delete ptr_SimpleNestedURIParams();
            break;
        }
    case THostObjectURIParams:
        {
            (ptr_HostObjectURIParams())->~HostObjectURIParams__tdef();
            break;
        }
    case TDefaultURIParams:
        {
            (ptr_DefaultURIParams())->~DefaultURIParams__tdef();
            break;
        }
    case TNestedAboutURIParams:
        {
            delete ptr_NestedAboutURIParams();
            break;
        }
    case TSubstitutingJARURIParams:
        {
            delete ptr_SubstitutingJARURIParams();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT URIParams::URIParams(const SimpleURIParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams(aOther);
    mType = TSimpleURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(SimpleURIParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams(std::move(aOther));
    mType = TSimpleURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(const StandardURLParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams(aOther);
    mType = TStandardURLParams;
}

MOZ_IMPLICIT URIParams::URIParams(StandardURLParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams(std::move(aOther));
    mType = TStandardURLParams;
}

MOZ_IMPLICIT URIParams::URIParams(const JARURIParams& aOther)
{
    ptr_JARURIParams() = new JARURIParams(aOther);
    mType = TJARURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(JARURIParams&& aOther)
{
    ptr_JARURIParams() = new JARURIParams(std::move(aOther));
    mType = TJARURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(const IconURIParams& aOther)
{
    ptr_IconURIParams() = new IconURIParams(aOther);
    mType = TIconURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(IconURIParams&& aOther)
{
    ptr_IconURIParams() = new IconURIParams(std::move(aOther));
    mType = TIconURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(const JSURIParams& aOther)
{
    ptr_JSURIParams() = new JSURIParams(aOther);
    mType = TJSURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(JSURIParams&& aOther)
{
    ptr_JSURIParams() = new JSURIParams(std::move(aOther));
    mType = TJSURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(const SimpleNestedURIParams& aOther)
{
    ptr_SimpleNestedURIParams() = new SimpleNestedURIParams(aOther);
    mType = TSimpleNestedURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(SimpleNestedURIParams&& aOther)
{
    ptr_SimpleNestedURIParams() = new SimpleNestedURIParams(std::move(aOther));
    mType = TSimpleNestedURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(const HostObjectURIParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams(aOther);
    mType = THostObjectURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(HostObjectURIParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams(std::move(aOther));
    mType = THostObjectURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(const DefaultURIParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams(aOther);
    mType = TDefaultURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(DefaultURIParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams(std::move(aOther));
    mType = TDefaultURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(const NestedAboutURIParams& aOther)
{
    ptr_NestedAboutURIParams() = new NestedAboutURIParams(aOther);
    mType = TNestedAboutURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(NestedAboutURIParams&& aOther)
{
    ptr_NestedAboutURIParams() = new NestedAboutURIParams(std::move(aOther));
    mType = TNestedAboutURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(const SubstitutingJARURIParams& aOther)
{
    ptr_SubstitutingJARURIParams() = new SubstitutingJARURIParams(aOther);
    mType = TSubstitutingJARURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(SubstitutingJARURIParams&& aOther)
{
    ptr_SubstitutingJARURIParams() = new SubstitutingJARURIParams(std::move(aOther));
    mType = TSubstitutingJARURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(const URIParams& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TSimpleURIParams:
        {
            new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams((aOther).get_SimpleURIParams());
            break;
        }
    case TStandardURLParams:
        {
            new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams((aOther).get_StandardURLParams());
            break;
        }
    case TJARURIParams:
        {
            ptr_JARURIParams() = new JARURIParams((aOther).get_JARURIParams());
            break;
        }
    case TIconURIParams:
        {
            ptr_IconURIParams() = new IconURIParams((aOther).get_IconURIParams());
            break;
        }
    case TJSURIParams:
        {
            ptr_JSURIParams() = new JSURIParams((aOther).get_JSURIParams());
            break;
        }
    case TSimpleNestedURIParams:
        {
            ptr_SimpleNestedURIParams() = new SimpleNestedURIParams((aOther).get_SimpleNestedURIParams());
            break;
        }
    case THostObjectURIParams:
        {
            new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams((aOther).get_HostObjectURIParams());
            break;
        }
    case TDefaultURIParams:
        {
            new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams((aOther).get_DefaultURIParams());
            break;
        }
    case TNestedAboutURIParams:
        {
            ptr_NestedAboutURIParams() = new NestedAboutURIParams((aOther).get_NestedAboutURIParams());
            break;
        }
    case TSubstitutingJARURIParams:
        {
            ptr_SubstitutingJARURIParams() = new SubstitutingJARURIParams((aOther).get_SubstitutingJARURIParams());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT URIParams::URIParams(URIParams&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TSimpleURIParams:
        {
            new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams(std::move((aOther).get_SimpleURIParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStandardURLParams:
        {
            new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams(std::move((aOther).get_StandardURLParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TJARURIParams:
        {
            ptr_JARURIParams() = (aOther).ptr_JARURIParams();
            break;
        }
    case TIconURIParams:
        {
            ptr_IconURIParams() = (aOther).ptr_IconURIParams();
            break;
        }
    case TJSURIParams:
        {
            ptr_JSURIParams() = (aOther).ptr_JSURIParams();
            break;
        }
    case TSimpleNestedURIParams:
        {
            ptr_SimpleNestedURIParams() = (aOther).ptr_SimpleNestedURIParams();
            break;
        }
    case THostObjectURIParams:
        {
            new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams(std::move((aOther).get_HostObjectURIParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TDefaultURIParams:
        {
            new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams(std::move((aOther).get_DefaultURIParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TNestedAboutURIParams:
        {
            ptr_NestedAboutURIParams() = (aOther).ptr_NestedAboutURIParams();
            break;
        }
    case TSubstitutingJARURIParams:
        {
            ptr_SubstitutingJARURIParams() = (aOther).ptr_SubstitutingJARURIParams();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto URIParams::operator=(const SimpleURIParams& aRhs) -> URIParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams(aRhs);
    mType = TSimpleURIParams;
    return (*(this));
}

auto URIParams::operator=(SimpleURIParams&& aRhs) -> URIParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams(std::move(aRhs));
    mType = TSimpleURIParams;
    return (*(this));
}

auto URIParams::operator=(const StandardURLParams& aRhs) -> URIParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams(aRhs);
    mType = TStandardURLParams;
    return (*(this));
}

auto URIParams::operator=(StandardURLParams&& aRhs) -> URIParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams(std::move(aRhs));
    mType = TStandardURLParams;
    return (*(this));
}

auto URIParams::operator=(const JARURIParams& aRhs) -> URIParams&
{
    MaybeDestroy();
    ptr_JARURIParams() = new JARURIParams(aRhs);
    mType = TJARURIParams;
    return (*(this));
}

auto URIParams::operator=(JARURIParams&& aRhs) -> URIParams&
{
    MaybeDestroy();
    ptr_JARURIParams() = new JARURIParams(std::move(aRhs));
    mType = TJARURIParams;
    return (*(this));
}

auto URIParams::operator=(const IconURIParams& aRhs) -> URIParams&
{
    MaybeDestroy();
    ptr_IconURIParams() = new IconURIParams(aRhs);
    mType = TIconURIParams;
    return (*(this));
}

auto URIParams::operator=(IconURIParams&& aRhs) -> URIParams&
{
    MaybeDestroy();
    ptr_IconURIParams() = new IconURIParams(std::move(aRhs));
    mType = TIconURIParams;
    return (*(this));
}

auto URIParams::operator=(const JSURIParams& aRhs) -> URIParams&
{
    MaybeDestroy();
    ptr_JSURIParams() = new JSURIParams(aRhs);
    mType = TJSURIParams;
    return (*(this));
}

auto URIParams::operator=(JSURIParams&& aRhs) -> URIParams&
{
    MaybeDestroy();
    ptr_JSURIParams() = new JSURIParams(std::move(aRhs));
    mType = TJSURIParams;
    return (*(this));
}

auto URIParams::operator=(const SimpleNestedURIParams& aRhs) -> URIParams&
{
    MaybeDestroy();
    ptr_SimpleNestedURIParams() = new SimpleNestedURIParams(aRhs);
    mType = TSimpleNestedURIParams;
    return (*(this));
}

auto URIParams::operator=(SimpleNestedURIParams&& aRhs) -> URIParams&
{
    MaybeDestroy();
    ptr_SimpleNestedURIParams() = new SimpleNestedURIParams(std::move(aRhs));
    mType = TSimpleNestedURIParams;
    return (*(this));
}

auto URIParams::operator=(const HostObjectURIParams& aRhs) -> URIParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams(aRhs);
    mType = THostObjectURIParams;
    return (*(this));
}

auto URIParams::operator=(HostObjectURIParams&& aRhs) -> URIParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams(std::move(aRhs));
    mType = THostObjectURIParams;
    return (*(this));
}

auto URIParams::operator=(const DefaultURIParams& aRhs) -> URIParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams(aRhs);
    mType = TDefaultURIParams;
    return (*(this));
}

auto URIParams::operator=(DefaultURIParams&& aRhs) -> URIParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams(std::move(aRhs));
    mType = TDefaultURIParams;
    return (*(this));
}

auto URIParams::operator=(const NestedAboutURIParams& aRhs) -> URIParams&
{
    MaybeDestroy();
    ptr_NestedAboutURIParams() = new NestedAboutURIParams(aRhs);
    mType = TNestedAboutURIParams;
    return (*(this));
}

auto URIParams::operator=(NestedAboutURIParams&& aRhs) -> URIParams&
{
    MaybeDestroy();
    ptr_NestedAboutURIParams() = new NestedAboutURIParams(std::move(aRhs));
    mType = TNestedAboutURIParams;
    return (*(this));
}

auto URIParams::operator=(const SubstitutingJARURIParams& aRhs) -> URIParams&
{
    MaybeDestroy();
    ptr_SubstitutingJARURIParams() = new SubstitutingJARURIParams(aRhs);
    mType = TSubstitutingJARURIParams;
    return (*(this));
}

auto URIParams::operator=(SubstitutingJARURIParams&& aRhs) -> URIParams&
{
    MaybeDestroy();
    ptr_SubstitutingJARURIParams() = new SubstitutingJARURIParams(std::move(aRhs));
    mType = TSubstitutingJARURIParams;
    return (*(this));
}

auto URIParams::operator=(const URIParams& aRhs) -> URIParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TSimpleURIParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams((aRhs).get_SimpleURIParams());
            break;
        }
    case TStandardURLParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams((aRhs).get_StandardURLParams());
            break;
        }
    case TJARURIParams:
        {
            MaybeDestroy();
            ptr_JARURIParams() = new JARURIParams((aRhs).get_JARURIParams());
            break;
        }
    case TIconURIParams:
        {
            MaybeDestroy();
            ptr_IconURIParams() = new IconURIParams((aRhs).get_IconURIParams());
            break;
        }
    case TJSURIParams:
        {
            MaybeDestroy();
            ptr_JSURIParams() = new JSURIParams((aRhs).get_JSURIParams());
            break;
        }
    case TSimpleNestedURIParams:
        {
            MaybeDestroy();
            ptr_SimpleNestedURIParams() = new SimpleNestedURIParams((aRhs).get_SimpleNestedURIParams());
            break;
        }
    case THostObjectURIParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams((aRhs).get_HostObjectURIParams());
            break;
        }
    case TDefaultURIParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams((aRhs).get_DefaultURIParams());
            break;
        }
    case TNestedAboutURIParams:
        {
            MaybeDestroy();
            ptr_NestedAboutURIParams() = new NestedAboutURIParams((aRhs).get_NestedAboutURIParams());
            break;
        }
    case TSubstitutingJARURIParams:
        {
            MaybeDestroy();
            ptr_SubstitutingJARURIParams() = new SubstitutingJARURIParams((aRhs).get_SubstitutingJARURIParams());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto URIParams::operator=(URIParams&& aRhs) -> URIParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TSimpleURIParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams(std::move((aRhs).get_SimpleURIParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStandardURLParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams(std::move((aRhs).get_StandardURLParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TJARURIParams:
        {
            MaybeDestroy();
            ptr_JARURIParams() = (aRhs).ptr_JARURIParams();
            break;
        }
    case TIconURIParams:
        {
            MaybeDestroy();
            ptr_IconURIParams() = (aRhs).ptr_IconURIParams();
            break;
        }
    case TJSURIParams:
        {
            MaybeDestroy();
            ptr_JSURIParams() = (aRhs).ptr_JSURIParams();
            break;
        }
    case TSimpleNestedURIParams:
        {
            MaybeDestroy();
            ptr_SimpleNestedURIParams() = (aRhs).ptr_SimpleNestedURIParams();
            break;
        }
    case THostObjectURIParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams(std::move((aRhs).get_HostObjectURIParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TDefaultURIParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams(std::move((aRhs).get_DefaultURIParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TNestedAboutURIParams:
        {
            MaybeDestroy();
            ptr_NestedAboutURIParams() = (aRhs).ptr_NestedAboutURIParams();
            break;
        }
    case TSubstitutingJARURIParams:
        {
            MaybeDestroy();
            ptr_SubstitutingJARURIParams() = (aRhs).ptr_SubstitutingJARURIParams();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace ipc
} // namespace mozilla

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

    switch (type) {
    case union__::TSimpleURIParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_SimpleURIParams());
            // Sentinel = 'TSimpleURIParams'
            (aWriter)->WriteSentinel(852690451);
            return;
        }
    case union__::TStandardURLParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_StandardURLParams());
            // Sentinel = 'TStandardURLParams'
            (aWriter)->WriteSentinel(1081870045);
            return;
        }
    case union__::TJARURIParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_JARURIParams());
            // Sentinel = 'TJARURIParams'
            (aWriter)->WriteSentinel(491848838);
            return;
        }
    case union__::TIconURIParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_IconURIParams());
            // Sentinel = 'TIconURIParams'
            (aWriter)->WriteSentinel(630785330);
            return;
        }
    case union__::TJSURIParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_JSURIParams());
            // Sentinel = 'TJSURIParams'
            (aWriter)->WriteSentinel(435225670);
            return;
        }
    case union__::TSimpleNestedURIParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_SimpleNestedURIParams());
            // Sentinel = 'TSimpleNestedURIParams'
            (aWriter)->WriteSentinel(1626015862);
            return;
        }
    case union__::THostObjectURIParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_HostObjectURIParams());
            // Sentinel = 'THostObjectURIParams'
            (aWriter)->WriteSentinel(1327105950);
            return;
        }
    case union__::TDefaultURIParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_DefaultURIParams());
            // Sentinel = 'TDefaultURIParams'
            (aWriter)->WriteSentinel(948045422);
            return;
        }
    case union__::TNestedAboutURIParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_NestedAboutURIParams());
            // Sentinel = 'TNestedAboutURIParams'
            (aWriter)->WriteSentinel(1465518087);
            return;
        }
    case union__::TSubstitutingJARURIParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_SubstitutingJARURIParams());
            // Sentinel = 'TSubstitutingJARURIParams'
            (aWriter)->WriteSentinel(2128677275);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union URIParams");
            return;
        }
    }
}

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

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

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

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TSimpleURIParams'
            if ((!((aReader)->ReadSentinel(852690451)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSimpleURIParams of union URIParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStandardURLParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::StandardURLParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStandardURLParams of union URIParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStandardURLParams'
            if ((!((aReader)->ReadSentinel(1081870045)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStandardURLParams of union URIParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TJARURIParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::JARURIParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TJARURIParams of union URIParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TJARURIParams'
            if ((!((aReader)->ReadSentinel(491848838)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TJARURIParams of union URIParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIconURIParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::IconURIParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIconURIParams of union URIParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIconURIParams'
            if ((!((aReader)->ReadSentinel(630785330)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIconURIParams of union URIParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TJSURIParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::JSURIParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TJSURIParams of union URIParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TJSURIParams'
            if ((!((aReader)->ReadSentinel(435225670)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TJSURIParams of union URIParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TSimpleNestedURIParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::SimpleNestedURIParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TSimpleNestedURIParams of union URIParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TSimpleNestedURIParams'
            if ((!((aReader)->ReadSentinel(1626015862)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSimpleNestedURIParams of union URIParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::THostObjectURIParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::HostObjectURIParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant THostObjectURIParams of union URIParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'THostObjectURIParams'
            if ((!((aReader)->ReadSentinel(1327105950)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant THostObjectURIParams of union URIParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TDefaultURIParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::DefaultURIParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TDefaultURIParams of union URIParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TDefaultURIParams'
            if ((!((aReader)->ReadSentinel(948045422)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TDefaultURIParams of union URIParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TNestedAboutURIParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::NestedAboutURIParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TNestedAboutURIParams of union URIParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TNestedAboutURIParams'
            if ((!((aReader)->ReadSentinel(1465518087)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TNestedAboutURIParams of union URIParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TSubstitutingJARURIParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::SubstitutingJARURIParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TSubstitutingJARURIParams of union URIParams");
                return {};

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct JSURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::JSURIParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).simpleParams());
    // Sentinel = 'simpleParams'
    (aWriter)->WriteSentinel(541394159);
    IPC::WriteParam(aWriter, (aVar).baseURI());
    // Sentinel = 'baseURI'
    (aWriter)->WriteSentinel(179962508);
}

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

    }
    auto& _simpleParams = *maybe___simpleParams;
    // Sentinel = 'simpleParams'
    if ((!((aReader)->ReadSentinel(541394159)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'JSURIParams'");
        return {};
    }
    auto maybe___baseURI = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::URIParams>>(aReader);
    if (!maybe___baseURI) {
        aReader->FatalError("Error deserializing 'baseURI' (URIParams?) member of 'JSURIParams'");
        return {};

    }
    auto& _baseURI = *maybe___baseURI;
    // Sentinel = 'baseURI'
    if ((!((aReader)->ReadSentinel(179962508)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'baseURI' (URIParams?) member of 'JSURIParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_simpleParams),
            std::move(_baseURI)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SimpleNestedURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::SimpleNestedURIParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).simpleParams());
    // Sentinel = 'simpleParams'
    (aWriter)->WriteSentinel(541394159);
    IPC::WriteParam(aWriter, (aVar).innerURI());
    // Sentinel = 'innerURI'
    (aWriter)->WriteSentinel(244515597);
}

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

    }
    auto& _simpleParams = *maybe___simpleParams;
    // Sentinel = 'simpleParams'
    if ((!((aReader)->ReadSentinel(541394159)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'SimpleNestedURIParams'");
        return {};
    }
    auto maybe___innerURI = IPC::ReadParam<::mozilla::ipc::URIParams>(aReader);
    if (!maybe___innerURI) {
        aReader->FatalError("Error deserializing 'innerURI' (URIParams) member of 'SimpleNestedURIParams'");
        return {};

    }
    auto& _innerURI = *maybe___innerURI;
    // Sentinel = 'innerURI'
    if ((!((aReader)->ReadSentinel(244515597)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'innerURI' (URIParams) member of 'SimpleNestedURIParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_simpleParams),
            std::move(_innerURI)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct NestedAboutURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::NestedAboutURIParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).nestedParams());
    // Sentinel = 'nestedParams'
    (aWriter)->WriteSentinel(536741096);
    IPC::WriteParam(aWriter, (aVar).baseURI());
    // Sentinel = 'baseURI'
    (aWriter)->WriteSentinel(179962508);
}

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

    }
    auto& _nestedParams = *maybe___nestedParams;
    // Sentinel = 'nestedParams'
    if ((!((aReader)->ReadSentinel(536741096)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'nestedParams' (SimpleNestedURIParams) member of 'NestedAboutURIParams'");
        return {};
    }
    auto maybe___baseURI = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::URIParams>>(aReader);
    if (!maybe___baseURI) {
        aReader->FatalError("Error deserializing 'baseURI' (URIParams?) member of 'NestedAboutURIParams'");
        return {};

    }
    auto& _baseURI = *maybe___baseURI;
    // Sentinel = 'baseURI'
    if ((!((aReader)->ReadSentinel(179962508)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'baseURI' (URIParams?) member of 'NestedAboutURIParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_nestedParams),
            std::move(_baseURI)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SubstitutingJARURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::ipc::SubstitutingJARURIParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).source());
    // Sentinel = 'source'
    (aWriter)->WriteSentinel(154665618);
    IPC::WriteParam(aWriter, (aVar).resolved());
    // Sentinel = 'resolved'
    (aWriter)->WriteSentinel(259523429);
}

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

    }
    auto& _source = *maybe___source;
    // Sentinel = 'source'
    if ((!((aReader)->ReadSentinel(154665618)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'source' (URIParams) member of 'SubstitutingJARURIParams'");
        return {};
    }
    auto maybe___resolved = IPC::ReadParam<::mozilla::ipc::JARURIParams>(aReader);
    if (!maybe___resolved) {
        aReader->FatalError("Error deserializing 'resolved' (JARURIParams) member of 'SubstitutingJARURIParams'");
        return {};

    }
    auto& _resolved = *maybe___resolved;
    // Sentinel = 'resolved'
    if ((!((aReader)->ReadSentinel(259523429)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'resolved' (JARURIParams) member of 'SubstitutingJARURIParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_source),
            std::move(_resolved)};
    return result__;
}

} // namespace IPC
