/work/obj-fuzz/ipc/ipdl/URIParams.cpp

Source (jump to first uncovered line)
//
// Automatically generated by ipdlc.
// Edit at your own risk
//


#include "mozilla/ipc/URIParams.h"


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

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::SimpleURIParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).scheme());
    // Sentinel = 'scheme'
    (aMsg)->WriteSentinel(3619238715);
    WriteIPDLParam(aMsg, aActor, (aVar).path());
    // Sentinel = 'path'
    (aMsg)->WriteSentinel(913629401);
    WriteIPDLParam(aMsg, aActor, (aVar).ref());
    // Sentinel = 'ref'
    (aMsg)->WriteSentinel(2626476732);
    WriteIPDLParam(aMsg, aActor, (aVar).query());
    // Sentinel = 'query'
    (aMsg)->WriteSentinel(4249802777);
}

auto IPDLParamTraits<mozilla::ipc::SimpleURIParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->scheme())))))) {
        (aActor)->FatalError("Error deserializing 'scheme' (nsCString) member of 'SimpleURIParams'");
        return false;
    }
    // Sentinel = 'scheme'
    if ((!((aMsg)->ReadSentinel(aIter, 3619238715)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scheme' (nsCString) member of 'SimpleURIParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->path())))))) {
        (aActor)->FatalError("Error deserializing 'path' (nsCString) member of 'SimpleURIParams'");
        return false;
    }
    // Sentinel = 'path'
    if ((!((aMsg)->ReadSentinel(aIter, 913629401)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'path' (nsCString) member of 'SimpleURIParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->ref())))))) {
        (aActor)->FatalError("Error deserializing 'ref' (nsCString) member of 'SimpleURIParams'");
        return false;
    }
    // Sentinel = 'ref'
    if ((!((aMsg)->ReadSentinel(aIter, 2626476732)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ref' (nsCString) member of 'SimpleURIParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->query())))))) {
        (aActor)->FatalError("Error deserializing 'query' (nsCString) member of 'SimpleURIParams'");
        return false;
    }
    // Sentinel = 'query'
    if ((!((aMsg)->ReadSentinel(aIter, 4249802777)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'query' (nsCString) member of 'SimpleURIParams'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::StandardURLSegment>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).position());
    // Sentinel = 'position'
    (aMsg)->WriteSentinel(50847225);
    WriteIPDLParam(aMsg, aActor, (aVar).length());
    // Sentinel = 'length'
    (aMsg)->WriteSentinel(1726618354);
}

auto IPDLParamTraits<mozilla::ipc::StandardURLSegment>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->position())))))) {
        (aActor)->FatalError("Error deserializing 'position' (uint32_t) member of 'StandardURLSegment'");
        return false;
    }
    // Sentinel = 'position'
    if ((!((aMsg)->ReadSentinel(aIter, 50847225)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'position' (uint32_t) member of 'StandardURLSegment'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->length())))))) {
        (aActor)->FatalError("Error deserializing 'length' (int32_t) member of 'StandardURLSegment'");
        return false;
    }
    // Sentinel = 'length'
    if ((!((aMsg)->ReadSentinel(aIter, 1726618354)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'length' (int32_t) member of 'StandardURLSegment'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StandardURLParams|
//
namespace mozilla {
namespace ipc {
auto StandardURLParams::operator==(const StandardURLParams& _o) const -> bool
{
    if ((!((urlType()) == ((_o).urlType())))) {
        return false;
    }
    if ((!((port()) == ((_o).port())))) {
        return false;
    }
    if ((!((defaultPort()) == ((_o).defaultPort())))) {
        return false;
    }
    if ((!((spec()) == ((_o).spec())))) {
        return false;
    }
    if ((!((scheme()) == ((_o).scheme())))) {
        return false;
    }
    if ((!((authority()) == ((_o).authority())))) {
        return false;
    }
    if ((!((username()) == ((_o).username())))) {
        return false;
    }
    if ((!((password()) == ((_o).password())))) {
        return false;
    }
    if ((!((host()) == ((_o).host())))) {
        return false;
    }
    if ((!((path()) == ((_o).path())))) {
        return false;
    }
    if ((!((filePath()) == ((_o).filePath())))) {
        return false;
    }
    if ((!((directory()) == ((_o).directory())))) {
        return false;
    }
    if ((!((baseName()) == ((_o).baseName())))) {
        return false;
    }
    if ((!((extension()) == ((_o).extension())))) {
        return false;
    }
    if ((!((query()) == ((_o).query())))) {
        return false;
    }
    if ((!((ref()) == ((_o).ref())))) {
        return false;
    }
    if ((!((supportsFileURL()) == ((_o).supportsFileURL())))) {
        return false;
    }
    return true;
}

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::StandardURLParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).urlType());
    // Sentinel = 'urlType'
    (aMsg)->WriteSentinel(4149428228);
    WriteIPDLParam(aMsg, aActor, (aVar).port());
    // Sentinel = 'port'
    (aMsg)->WriteSentinel(3633211549);
    WriteIPDLParam(aMsg, aActor, (aVar).defaultPort());
    // Sentinel = 'defaultPort'
    (aMsg)->WriteSentinel(599318897);
    WriteIPDLParam(aMsg, aActor, (aVar).spec());
    // Sentinel = 'spec'
    (aMsg)->WriteSentinel(1630740541);
    WriteIPDLParam(aMsg, aActor, (aVar).scheme());
    // Sentinel = 'scheme'
    (aMsg)->WriteSentinel(3619238715);
    WriteIPDLParam(aMsg, aActor, (aVar).authority());
    // Sentinel = 'authority'
    (aMsg)->WriteSentinel(1669684878);
    WriteIPDLParam(aMsg, aActor, (aVar).username());
    // Sentinel = 'username'
    (aMsg)->WriteSentinel(689225024);
    WriteIPDLParam(aMsg, aActor, (aVar).password());
    // Sentinel = 'password'
    (aMsg)->WriteSentinel(2527534683);
    WriteIPDLParam(aMsg, aActor, (aVar).host());
    // Sentinel = 'host'
    (aMsg)->WriteSentinel(4070301394);
    WriteIPDLParam(aMsg, aActor, (aVar).path());
    // Sentinel = 'path'
    (aMsg)->WriteSentinel(913629401);
    WriteIPDLParam(aMsg, aActor, (aVar).filePath());
    // Sentinel = 'filePath'
    (aMsg)->WriteSentinel(4122896455);
    WriteIPDLParam(aMsg, aActor, (aVar).directory());
    // Sentinel = 'directory'
    (aMsg)->WriteSentinel(1201172472);
    WriteIPDLParam(aMsg, aActor, (aVar).baseName());
    // Sentinel = 'baseName'
    (aMsg)->WriteSentinel(2448877418);
    WriteIPDLParam(aMsg, aActor, (aVar).extension());
    // Sentinel = 'extension'
    (aMsg)->WriteSentinel(3211853542);
    WriteIPDLParam(aMsg, aActor, (aVar).query());
    // Sentinel = 'query'
    (aMsg)->WriteSentinel(4249802777);
    WriteIPDLParam(aMsg, aActor, (aVar).ref());
    // Sentinel = 'ref'
    (aMsg)->WriteSentinel(2626476732);
    WriteIPDLParam(aMsg, aActor, (aVar).supportsFileURL());
    // Sentinel = 'supportsFileURL'
    (aMsg)->WriteSentinel(1871785710);
}

auto IPDLParamTraits<mozilla::ipc::StandardURLParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->urlType())))))) {
        (aActor)->FatalError("Error deserializing 'urlType' (uint32_t) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'urlType'
    if ((!((aMsg)->ReadSentinel(aIter, 4149428228)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'urlType' (uint32_t) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->port())))))) {
        (aActor)->FatalError("Error deserializing 'port' (int32_t) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'port'
    if ((!((aMsg)->ReadSentinel(aIter, 3633211549)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'port' (int32_t) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->defaultPort())))))) {
        (aActor)->FatalError("Error deserializing 'defaultPort' (int32_t) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'defaultPort'
    if ((!((aMsg)->ReadSentinel(aIter, 599318897)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'defaultPort' (int32_t) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->spec())))))) {
        (aActor)->FatalError("Error deserializing 'spec' (nsCString) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'spec'
    if ((!((aMsg)->ReadSentinel(aIter, 1630740541)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'spec' (nsCString) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->scheme())))))) {
        (aActor)->FatalError("Error deserializing 'scheme' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'scheme'
    if ((!((aMsg)->ReadSentinel(aIter, 3619238715)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scheme' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->authority())))))) {
        (aActor)->FatalError("Error deserializing 'authority' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'authority'
    if ((!((aMsg)->ReadSentinel(aIter, 1669684878)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'authority' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->username())))))) {
        (aActor)->FatalError("Error deserializing 'username' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'username'
    if ((!((aMsg)->ReadSentinel(aIter, 689225024)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'username' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->password())))))) {
        (aActor)->FatalError("Error deserializing 'password' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'password'
    if ((!((aMsg)->ReadSentinel(aIter, 2527534683)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'password' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->host())))))) {
        (aActor)->FatalError("Error deserializing 'host' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'host'
    if ((!((aMsg)->ReadSentinel(aIter, 4070301394)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'host' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->path())))))) {
        (aActor)->FatalError("Error deserializing 'path' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'path'
    if ((!((aMsg)->ReadSentinel(aIter, 913629401)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'path' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->filePath())))))) {
        (aActor)->FatalError("Error deserializing 'filePath' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'filePath'
    if ((!((aMsg)->ReadSentinel(aIter, 4122896455)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'filePath' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->directory())))))) {
        (aActor)->FatalError("Error deserializing 'directory' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'directory'
    if ((!((aMsg)->ReadSentinel(aIter, 1201172472)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'directory' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->baseName())))))) {
        (aActor)->FatalError("Error deserializing 'baseName' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'baseName'
    if ((!((aMsg)->ReadSentinel(aIter, 2448877418)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'baseName' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->extension())))))) {
        (aActor)->FatalError("Error deserializing 'extension' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'extension'
    if ((!((aMsg)->ReadSentinel(aIter, 3211853542)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'extension' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->query())))))) {
        (aActor)->FatalError("Error deserializing 'query' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'query'
    if ((!((aMsg)->ReadSentinel(aIter, 4249802777)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'query' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->ref())))))) {
        (aActor)->FatalError("Error deserializing 'ref' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'ref'
    if ((!((aMsg)->ReadSentinel(aIter, 2626476732)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ref' (StandardURLSegment) member of 'StandardURLParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->supportsFileURL())))))) {
        (aActor)->FatalError("Error deserializing 'supportsFileURL' (bool) member of 'StandardURLParams'");
        return false;
    }
    // Sentinel = 'supportsFileURL'
    if ((!((aMsg)->ReadSentinel(aIter, 1871785710)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'supportsFileURL' (bool) member of 'StandardURLParams'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::JARURIParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).jarFile());
    // Sentinel = 'jarFile'
    (aMsg)->WriteSentinel(1572070078);
    WriteIPDLParam(aMsg, aActor, (aVar).jarEntry());
    // Sentinel = 'jarEntry'
    (aMsg)->WriteSentinel(941016033);
    WriteIPDLParam(aMsg, aActor, (aVar).charset());
    // Sentinel = 'charset'
    (aMsg)->WriteSentinel(1551550891);
}

auto IPDLParamTraits<mozilla::ipc::JARURIParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->jarFile())))))) {
        (aActor)->FatalError("Error deserializing 'jarFile' (URIParams) member of 'JARURIParams'");
        return false;
    }
    // Sentinel = 'jarFile'
    if ((!((aMsg)->ReadSentinel(aIter, 1572070078)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'jarFile' (URIParams) member of 'JARURIParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->jarEntry())))))) {
        (aActor)->FatalError("Error deserializing 'jarEntry' (URIParams) member of 'JARURIParams'");
        return false;
    }
    // Sentinel = 'jarEntry'
    if ((!((aMsg)->ReadSentinel(aIter, 941016033)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'jarEntry' (URIParams) member of 'JARURIParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->charset())))))) {
        (aActor)->FatalError("Error deserializing 'charset' (nsCString) member of 'JARURIParams'");
        return false;
    }
    // Sentinel = 'charset'
    if ((!((aMsg)->ReadSentinel(aIter, 1551550891)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'charset' (nsCString) member of 'JARURIParams'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IconURIParams|
//
namespace mozilla {
namespace ipc {
auto IconURIParams::operator==(const IconURIParams& _o) const -> bool
{
    if ((!((uri()) == ((_o).uri())))) {
        return false;
    }
    if ((!((size()) == ((_o).size())))) {
        return false;
    }
    if ((!((contentType()) == ((_o).contentType())))) {
        return false;
    }
    if ((!((fileName()) == ((_o).fileName())))) {
        return false;
    }
    if ((!((stockIcon()) == ((_o).stockIcon())))) {
        return false;
    }
    if ((!((iconSize()) == ((_o).iconSize())))) {
        return false;
    }
    if ((!((iconState()) == ((_o).iconState())))) {
        return false;
    }
    return true;
}

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::IconURIParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).uri());
    // Sentinel = 'uri'
    (aMsg)->WriteSentinel(1453210605);
    WriteIPDLParam(aMsg, aActor, (aVar).size());
    // Sentinel = 'size'
    (aMsg)->WriteSentinel(931048223);
    WriteIPDLParam(aMsg, aActor, (aVar).contentType());
    // Sentinel = 'contentType'
    (aMsg)->WriteSentinel(2092571716);
    WriteIPDLParam(aMsg, aActor, (aVar).fileName());
    // Sentinel = 'fileName'
    (aMsg)->WriteSentinel(3833449039);
    WriteIPDLParam(aMsg, aActor, (aVar).stockIcon());
    // Sentinel = 'stockIcon'
    (aMsg)->WriteSentinel(3601770784);
    WriteIPDLParam(aMsg, aActor, (aVar).iconSize());
    // Sentinel = 'iconSize'
    (aMsg)->WriteSentinel(2585310920);
    WriteIPDLParam(aMsg, aActor, (aVar).iconState());
    // Sentinel = 'iconState'
    (aMsg)->WriteSentinel(3444306207);
}

auto IPDLParamTraits<mozilla::ipc::IconURIParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->uri())))))) {
        (aActor)->FatalError("Error deserializing 'uri' (OptionalURIParams) member of 'IconURIParams'");
        return false;
    }
    // Sentinel = 'uri'
    if ((!((aMsg)->ReadSentinel(aIter, 1453210605)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'uri' (OptionalURIParams) member of 'IconURIParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->size())))))) {
        (aActor)->FatalError("Error deserializing 'size' (uint32_t) member of 'IconURIParams'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((aMsg)->ReadSentinel(aIter, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (uint32_t) member of 'IconURIParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->contentType())))))) {
        (aActor)->FatalError("Error deserializing 'contentType' (nsCString) member of 'IconURIParams'");
        return false;
    }
    // Sentinel = 'contentType'
    if ((!((aMsg)->ReadSentinel(aIter, 2092571716)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'contentType' (nsCString) member of 'IconURIParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->fileName())))))) {
        (aActor)->FatalError("Error deserializing 'fileName' (nsCString) member of 'IconURIParams'");
        return false;
    }
    // Sentinel = 'fileName'
    if ((!((aMsg)->ReadSentinel(aIter, 3833449039)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fileName' (nsCString) member of 'IconURIParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->stockIcon())))))) {
        (aActor)->FatalError("Error deserializing 'stockIcon' (nsCString) member of 'IconURIParams'");
        return false;
    }
    // Sentinel = 'stockIcon'
    if ((!((aMsg)->ReadSentinel(aIter, 3601770784)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'stockIcon' (nsCString) member of 'IconURIParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->iconSize())))))) {
        (aActor)->FatalError("Error deserializing 'iconSize' (int32_t) member of 'IconURIParams'");
        return false;
    }
    // Sentinel = 'iconSize'
    if ((!((aMsg)->ReadSentinel(aIter, 2585310920)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'iconSize' (int32_t) member of 'IconURIParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->iconState())))))) {
        (aActor)->FatalError("Error deserializing 'iconState' (int32_t) member of 'IconURIParams'");
        return false;
    }
    // Sentinel = 'iconState'
    if ((!((aMsg)->ReadSentinel(aIter, 3444306207)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'iconState' (int32_t) member of 'IconURIParams'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::NullPrincipalURIParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
}

auto IPDLParamTraits<mozilla::ipc::NullPrincipalURIParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::HostObjectURIParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).simpleParams());
    // Sentinel = 'simpleParams'
    (aMsg)->WriteSentinel(3404291700);
    WriteIPDLParam(aMsg, aActor, (aVar).revoked());
    // Sentinel = 'revoked'
    (aMsg)->WriteSentinel(2893307109);
}

auto IPDLParamTraits<mozilla::ipc::HostObjectURIParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->simpleParams())))))) {
        (aActor)->FatalError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'HostObjectURIParams'");
        return false;
    }
    // Sentinel = 'simpleParams'
    if ((!((aMsg)->ReadSentinel(aIter, 3404291700)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'HostObjectURIParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->revoked())))))) {
        (aActor)->FatalError("Error deserializing 'revoked' (bool) member of 'HostObjectURIParams'");
        return false;
    }
    // Sentinel = 'revoked'
    if ((!((aMsg)->ReadSentinel(aIter, 2893307109)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'revoked' (bool) member of 'HostObjectURIParams'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union URIParams|
//
namespace mozilla {
namespace ipc {
auto URIParams::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    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 TNullPrincipalURIParams:
        {
            (ptr_NullPrincipalURIParams())->~NullPrincipalURIParams__tdef();
            break;
        }
    case TJSURIParams:
        {
            delete ptr_JSURIParams();
            break;
        }
    case TSimpleNestedURIParams:
        {
            delete ptr_SimpleNestedURIParams();
            break;
        }
    case THostObjectURIParams:
        {
            (ptr_HostObjectURIParams())->~HostObjectURIParams__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

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 NullPrincipalURIParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_NullPrincipalURIParams()) NullPrincipalURIParams(aOther);
    mType = TNullPrincipalURIParams;
}

MOZ_IMPLICIT URIParams::URIParams(NullPrincipalURIParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_NullPrincipalURIParams()) NullPrincipalURIParams(std::move(aOther));
    mType = TNullPrincipalURIParams;
}

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 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 TNullPrincipalURIParams:
        {
            new (mozilla::KnownNotNull, ptr_NullPrincipalURIParams()) NullPrincipalURIParams((aOther).get_NullPrincipalURIParams());
            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 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()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TStandardURLParams:
        {
            new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams(std::move((aOther).get_StandardURLParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TJARURIParams:
        {
            ptr_JARURIParams() = (aOther).ptr_JARURIParams();
            break;
        }
    case TIconURIParams:
        {
            ptr_IconURIParams() = (aOther).ptr_IconURIParams();
            break;
        }
    case TNullPrincipalURIParams:
        {
            new (mozilla::KnownNotNull, ptr_NullPrincipalURIParams()) NullPrincipalURIParams(std::move((aOther).get_NullPrincipalURIParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            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()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

URIParams::~URIParams()
{
    static_cast<void>(MaybeDestroy(T__None));
}

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

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

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

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

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

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

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

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

auto URIParams::operator=(const NullPrincipalURIParams& aRhs) -> URIParams&
{
    if (MaybeDestroy(TNullPrincipalURIParams)) {
        new (mozilla::KnownNotNull, ptr_NullPrincipalURIParams()) NullPrincipalURIParams;
    }
    (*(ptr_NullPrincipalURIParams())) = aRhs;
    mType = TNullPrincipalURIParams;
    return (*(this));
}

auto URIParams::operator=(NullPrincipalURIParams&& aRhs) -> URIParams&
{
    if (MaybeDestroy(TNullPrincipalURIParams)) {
        new (mozilla::KnownNotNull, ptr_NullPrincipalURIParams()) NullPrincipalURIParams;
    }
    (*(ptr_NullPrincipalURIParams())) = std::move(aRhs);
    mType = TNullPrincipalURIParams;
    return (*(this));
}

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

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

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

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

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

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

auto URIParams::operator=(const URIParams& aRhs) -> URIParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TSimpleURIParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams;
            }
            (*(ptr_SimpleURIParams())) = (aRhs).get_SimpleURIParams();
            break;
        }
    case TStandardURLParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams;
            }
            (*(ptr_StandardURLParams())) = (aRhs).get_StandardURLParams();
            break;
        }
    case TJARURIParams:
        {
            if (MaybeDestroy(t)) {
                ptr_JARURIParams() = new JARURIParams;
            }
            (*(ptr_JARURIParams())) = (aRhs).get_JARURIParams();
            break;
        }
    case TIconURIParams:
        {
            if (MaybeDestroy(t)) {
                ptr_IconURIParams() = new IconURIParams;
            }
            (*(ptr_IconURIParams())) = (aRhs).get_IconURIParams();
            break;
        }
    case TNullPrincipalURIParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_NullPrincipalURIParams()) NullPrincipalURIParams;
            }
            (*(ptr_NullPrincipalURIParams())) = (aRhs).get_NullPrincipalURIParams();
            break;
        }
    case TJSURIParams:
        {
            if (MaybeDestroy(t)) {
                ptr_JSURIParams() = new JSURIParams;
            }
            (*(ptr_JSURIParams())) = (aRhs).get_JSURIParams();
            break;
        }
    case TSimpleNestedURIParams:
        {
            if (MaybeDestroy(t)) {
                ptr_SimpleNestedURIParams() = new SimpleNestedURIParams;
            }
            (*(ptr_SimpleNestedURIParams())) = (aRhs).get_SimpleNestedURIParams();
            break;
        }
    case THostObjectURIParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams;
            }
            (*(ptr_HostObjectURIParams())) = (aRhs).get_HostObjectURIParams();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            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:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams;
            }
            (*(ptr_SimpleURIParams())) = std::move((aRhs).get_SimpleURIParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TStandardURLParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams;
            }
            (*(ptr_StandardURLParams())) = std::move((aRhs).get_StandardURLParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TJARURIParams:
        {
            static_cast<void>(MaybeDestroy(T__None));
            ptr_JARURIParams() = (aRhs).ptr_JARURIParams();
            break;
        }
    case TIconURIParams:
        {
            static_cast<void>(MaybeDestroy(T__None));
            ptr_IconURIParams() = (aRhs).ptr_IconURIParams();
            break;
        }
    case TNullPrincipalURIParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_NullPrincipalURIParams()) NullPrincipalURIParams;
            }
            (*(ptr_NullPrincipalURIParams())) = std::move((aRhs).get_NullPrincipalURIParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TJSURIParams:
        {
            static_cast<void>(MaybeDestroy(T__None));
            ptr_JSURIParams() = (aRhs).ptr_JSURIParams();
            break;
        }
    case TSimpleNestedURIParams:
        {
            static_cast<void>(MaybeDestroy(T__None));
            ptr_SimpleNestedURIParams() = (aRhs).ptr_SimpleNestedURIParams();
            break;
        }
    case THostObjectURIParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams;
            }
            (*(ptr_HostObjectURIParams())) = std::move((aRhs).get_HostObjectURIParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto URIParams::operator==(const SimpleURIParams& aRhs) const -> bool
{
    return (get_SimpleURIParams()) == (aRhs);
}

auto URIParams::operator==(const StandardURLParams& aRhs) const -> bool
{
    return (get_StandardURLParams()) == (aRhs);
}

auto URIParams::operator==(const JARURIParams& aRhs) const -> bool
{
    return (get_JARURIParams()) == (aRhs);
}

auto URIParams::operator==(const IconURIParams& aRhs) const -> bool
{
    return (get_IconURIParams()) == (aRhs);
}

auto URIParams::operator==(const NullPrincipalURIParams& aRhs) const -> bool
{
    return (get_NullPrincipalURIParams()) == (aRhs);
}

auto URIParams::operator==(const JSURIParams& aRhs) const -> bool
{
    return (get_JSURIParams()) == (aRhs);
}

auto URIParams::operator==(const SimpleNestedURIParams& aRhs) const -> bool
{
    return (get_SimpleNestedURIParams()) == (aRhs);
}

auto URIParams::operator==(const HostObjectURIParams& aRhs) const -> bool
{
    return (get_HostObjectURIParams()) == (aRhs);
}

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

    switch (type()) {
    case TSimpleURIParams:
        {
            return (get_SimpleURIParams()) == ((aRhs).get_SimpleURIParams());
        }
    case TStandardURLParams:
        {
            return (get_StandardURLParams()) == ((aRhs).get_StandardURLParams());
        }
    case TJARURIParams:
        {
            return (get_JARURIParams()) == ((aRhs).get_JARURIParams());
        }
    case TIconURIParams:
        {
            return (get_IconURIParams()) == ((aRhs).get_IconURIParams());
        }
    case TNullPrincipalURIParams:
        {
            return (get_NullPrincipalURIParams()) == ((aRhs).get_NullPrincipalURIParams());
        }
    case TJSURIParams:
        {
            return (get_JSURIParams()) == ((aRhs).get_JSURIParams());
        }
    case TSimpleNestedURIParams:
        {
            return (get_SimpleNestedURIParams()) == ((aRhs).get_SimpleNestedURIParams());
        }
    case THostObjectURIParams:
        {
            return (get_HostObjectURIParams()) == ((aRhs).get_HostObjectURIParams());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto URIParams::get(SimpleURIParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_SimpleURIParams();
}

auto URIParams::get(StandardURLParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_StandardURLParams();
}

auto URIParams::get(JARURIParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_JARURIParams();
}

auto URIParams::get(IconURIParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_IconURIParams();
}

auto URIParams::get(NullPrincipalURIParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_NullPrincipalURIParams();
}

auto URIParams::get(JSURIParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_JSURIParams();
}

auto URIParams::get(SimpleNestedURIParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_SimpleNestedURIParams();
}

auto URIParams::get(HostObjectURIParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_HostObjectURIParams();
}

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::URIParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    typedef mozilla::ipc::URIParams union__;
    int type;
    type = (aVar).type();
    WriteIPDLParam(aMsg, aActor, type);
    // Sentinel = 'URIParams'
    (aMsg)->WriteSentinel(1039516337);

    switch (type) {
    case union__::TSimpleURIParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SimpleURIParams());
            // Sentinel = 'TSimpleURIParams'
            (aMsg)->WriteSentinel(4028607586);
            return;
        }
    case union__::TStandardURLParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_StandardURLParams());
            // Sentinel = 'TStandardURLParams'
            (aMsg)->WriteSentinel(248174578);
            return;
        }
    case union__::TJARURIParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_JARURIParams());
            // Sentinel = 'TJARURIParams'
            (aMsg)->WriteSentinel(3404434792);
            return;
        }
    case union__::TIconURIParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_IconURIParams());
            // Sentinel = 'TIconURIParams'
            (aMsg)->WriteSentinel(1824279023);
            return;
        }
    case union__::TNullPrincipalURIParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_NullPrincipalURIParams());
            // Sentinel = 'TNullPrincipalURIParams'
            (aMsg)->WriteSentinel(216801182);
            return;
        }
    case union__::TJSURIParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_JSURIParams());
            // Sentinel = 'TJSURIParams'
            (aMsg)->WriteSentinel(32222119);
            return;
        }
    case union__::TSimpleNestedURIParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SimpleNestedURIParams());
            // Sentinel = 'TSimpleNestedURIParams'
            (aMsg)->WriteSentinel(3192238307);
            return;
        }
    case union__::THostObjectURIParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_HostObjectURIParams());
            // Sentinel = 'THostObjectURIParams'
            (aMsg)->WriteSentinel(1307971301);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

auto IPDLParamTraits<mozilla::ipc::URIParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    typedef mozilla::ipc::URIParams union__;
    int type;
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&(type)))))) {
        (aActor)->FatalError("Error deserializing type of union URIParams");
        return false;
    }
    // Sentinel = 'URIParams'
    if ((!((aMsg)->ReadSentinel(aIter, 1039516337)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union URIParams");
        return false;
    }

    switch (type) {
    case union__::TSimpleURIParams:
        {
            mozilla::ipc::SimpleURIParams tmp = mozilla::ipc::SimpleURIParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SimpleURIParams())))))) {
                (aActor)->FatalError("Error deserializing variant TSimpleURIParams of union URIParams");
                return false;
            }
            // Sentinel = 'TSimpleURIParams'
            if ((!((aMsg)->ReadSentinel(aIter, 4028607586)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSimpleURIParams of union URIParams");
                return false;
            }
            return true;
        }
    case union__::TStandardURLParams:
        {
            mozilla::ipc::StandardURLParams tmp = mozilla::ipc::StandardURLParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_StandardURLParams())))))) {
                (aActor)->FatalError("Error deserializing variant TStandardURLParams of union URIParams");
                return false;
            }
            // Sentinel = 'TStandardURLParams'
            if ((!((aMsg)->ReadSentinel(aIter, 248174578)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStandardURLParams of union URIParams");
                return false;
            }
            return true;
        }
    case union__::TJARURIParams:
        {
            mozilla::ipc::JARURIParams tmp = mozilla::ipc::JARURIParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_JARURIParams())))))) {
                (aActor)->FatalError("Error deserializing variant TJARURIParams of union URIParams");
                return false;
            }
            // Sentinel = 'TJARURIParams'
            if ((!((aMsg)->ReadSentinel(aIter, 3404434792)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TJARURIParams of union URIParams");
                return false;
            }
            return true;
        }
    case union__::TIconURIParams:
        {
            mozilla::ipc::IconURIParams tmp = mozilla::ipc::IconURIParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_IconURIParams())))))) {
                (aActor)->FatalError("Error deserializing variant TIconURIParams of union URIParams");
                return false;
            }
            // Sentinel = 'TIconURIParams'
            if ((!((aMsg)->ReadSentinel(aIter, 1824279023)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIconURIParams of union URIParams");
                return false;
            }
            return true;
        }
    case union__::TNullPrincipalURIParams:
        {
            mozilla::ipc::NullPrincipalURIParams tmp = mozilla::ipc::NullPrincipalURIParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_NullPrincipalURIParams())))))) {
                (aActor)->FatalError("Error deserializing variant TNullPrincipalURIParams of union URIParams");
                return false;
            }
            // Sentinel = 'TNullPrincipalURIParams'
            if ((!((aMsg)->ReadSentinel(aIter, 216801182)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TNullPrincipalURIParams of union URIParams");
                return false;
            }
            return true;
        }
    case union__::TJSURIParams:
        {
            mozilla::ipc::JSURIParams tmp = mozilla::ipc::JSURIParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_JSURIParams())))))) {
                (aActor)->FatalError("Error deserializing variant TJSURIParams of union URIParams");
                return false;
            }
            // Sentinel = 'TJSURIParams'
            if ((!((aMsg)->ReadSentinel(aIter, 32222119)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TJSURIParams of union URIParams");
                return false;
            }
            return true;
        }
    case union__::TSimpleNestedURIParams:
        {
            mozilla::ipc::SimpleNestedURIParams tmp = mozilla::ipc::SimpleNestedURIParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SimpleNestedURIParams())))))) {
                (aActor)->FatalError("Error deserializing variant TSimpleNestedURIParams of union URIParams");
                return false;
            }
            // Sentinel = 'TSimpleNestedURIParams'
            if ((!((aMsg)->ReadSentinel(aIter, 3192238307)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSimpleNestedURIParams of union URIParams");
                return false;
            }
            return true;
        }
    case union__::THostObjectURIParams:
        {
            mozilla::ipc::HostObjectURIParams tmp = mozilla::ipc::HostObjectURIParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_HostObjectURIParams())))))) {
                (aActor)->FatalError("Error deserializing variant THostObjectURIParams of union URIParams");
                return false;
            }
            // Sentinel = 'THostObjectURIParams'
            if ((!((aMsg)->ReadSentinel(aIter, 1307971301)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant THostObjectURIParams of union URIParams");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union OptionalURIParams|
//
namespace mozilla {
namespace ipc {
auto OptionalURIParams::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case Tvoid_t:
        {
            (ptr_void_t())->~void_t__tdef();
            break;
        }
    case TURIParams:
        {
            delete ptr_URIParams();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT OptionalURIParams::OptionalURIParams(const void_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
    mType = Tvoid_t;
}

MOZ_IMPLICIT OptionalURIParams::OptionalURIParams(void_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move(aOther));
    mType = Tvoid_t;
}

MOZ_IMPLICIT OptionalURIParams::OptionalURIParams(const URIParams& aOther)
{
    ptr_URIParams() = new URIParams(aOther);
    mType = TURIParams;
}

MOZ_IMPLICIT OptionalURIParams::OptionalURIParams(URIParams&& aOther)
{
    ptr_URIParams() = new URIParams(std::move(aOther));
    mType = TURIParams;
}

MOZ_IMPLICIT OptionalURIParams::OptionalURIParams(const OptionalURIParams& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
            break;
        }
    case TURIParams:
        {
            ptr_URIParams() = new URIParams((aOther).get_URIParams());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT OptionalURIParams::OptionalURIParams(OptionalURIParams&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move((aOther).get_void_t()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TURIParams:
        {
            ptr_URIParams() = (aOther).ptr_URIParams();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

OptionalURIParams::~OptionalURIParams()
{
    static_cast<void>(MaybeDestroy(T__None));
}

auto OptionalURIParams::operator=(const void_t& aRhs) -> OptionalURIParams&
{
    if (MaybeDestroy(Tvoid_t)) {
        new (mozilla::KnownNotNull, ptr_void_t()) void_t;
    }
    (*(ptr_void_t())) = aRhs;
    mType = Tvoid_t;
    return (*(this));
}

auto OptionalURIParams::operator=(void_t&& aRhs) -> OptionalURIParams&
{
    if (MaybeDestroy(Tvoid_t)) {
        new (mozilla::KnownNotNull, ptr_void_t()) void_t;
    }
    (*(ptr_void_t())) = std::move(aRhs);
    mType = Tvoid_t;
    return (*(this));
}

auto OptionalURIParams::operator=(const URIParams& aRhs) -> OptionalURIParams&
{
    if (MaybeDestroy(TURIParams)) {
        ptr_URIParams() = new URIParams;
    }
    (*(ptr_URIParams())) = aRhs;
    mType = TURIParams;
    return (*(this));
}

auto OptionalURIParams::operator=(URIParams&& aRhs) -> OptionalURIParams&
{
    if (MaybeDestroy(TURIParams)) {
        ptr_URIParams() = new URIParams;
    }
    (*(ptr_URIParams())) = std::move(aRhs);
    mType = TURIParams;
    return (*(this));
}

auto OptionalURIParams::operator=(const OptionalURIParams& aRhs) -> OptionalURIParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tvoid_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_void_t()) void_t;
            }
            (*(ptr_void_t())) = (aRhs).get_void_t();
            break;
        }
    case TURIParams:
        {
            if (MaybeDestroy(t)) {
                ptr_URIParams() = new URIParams;
            }
            (*(ptr_URIParams())) = (aRhs).get_URIParams();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto OptionalURIParams::operator=(OptionalURIParams&& aRhs) -> OptionalURIParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tvoid_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_void_t()) void_t;
            }
            (*(ptr_void_t())) = std::move((aRhs).get_void_t());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TURIParams:
        {
            static_cast<void>(MaybeDestroy(T__None));
            ptr_URIParams() = (aRhs).ptr_URIParams();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto OptionalURIParams::operator==(const void_t& aRhs) const -> bool
{
    return (get_void_t()) == (aRhs);
}

auto OptionalURIParams::operator==(const URIParams& aRhs) const -> bool
{
    return (get_URIParams()) == (aRhs);
}

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

    switch (type()) {
    case Tvoid_t:
        {
            return (get_void_t()) == ((aRhs).get_void_t());
        }
    case TURIParams:
        {
            return (get_URIParams()) == ((aRhs).get_URIParams());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto OptionalURIParams::get(void_t* aOutValue) const -> void
{
    (*(aOutValue)) = get_void_t();
}

auto OptionalURIParams::get(URIParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_URIParams();
}

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::OptionalURIParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    typedef mozilla::ipc::OptionalURIParams union__;
    int type;
    type = (aVar).type();
    WriteIPDLParam(aMsg, aActor, type);
    // Sentinel = 'OptionalURIParams'
    (aMsg)->WriteSentinel(1977079525);

    switch (type) {
    case union__::Tvoid_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_void_t());
            // Sentinel = 'Tvoid_t'
            (aMsg)->WriteSentinel(3041273328);
            return;
        }
    case union__::TURIParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_URIParams());
            // Sentinel = 'TURIParams'
            (aMsg)->WriteSentinel(1132652062);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

auto IPDLParamTraits<mozilla::ipc::OptionalURIParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    typedef mozilla::ipc::OptionalURIParams union__;
    int type;
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&(type)))))) {
        (aActor)->FatalError("Error deserializing type of union OptionalURIParams");
        return false;
    }
    // Sentinel = 'OptionalURIParams'
    if ((!((aMsg)->ReadSentinel(aIter, 1977079525)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union OptionalURIParams");
        return false;
    }

    switch (type) {
    case union__::Tvoid_t:
        {
            mozilla::void_t tmp = mozilla::void_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_void_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tvoid_t of union OptionalURIParams");
                return false;
            }
            // Sentinel = 'Tvoid_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3041273328)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tvoid_t of union OptionalURIParams");
                return false;
            }
            return true;
        }
    case union__::TURIParams:
        {
            mozilla::ipc::URIParams tmp = mozilla::ipc::URIParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_URIParams())))))) {
                (aActor)->FatalError("Error deserializing variant TURIParams of union OptionalURIParams");
                return false;
            }
            // Sentinel = 'TURIParams'
            if ((!((aMsg)->ReadSentinel(aIter, 1132652062)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TURIParams of union OptionalURIParams");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::JSURIParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).simpleParams());
    // Sentinel = 'simpleParams'
    (aMsg)->WriteSentinel(3404291700);
    WriteIPDLParam(aMsg, aActor, (aVar).baseURI());
    // Sentinel = 'baseURI'
    (aMsg)->WriteSentinel(1836705256);
}

auto IPDLParamTraits<mozilla::ipc::JSURIParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->simpleParams())))))) {
        (aActor)->FatalError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'JSURIParams'");
        return false;
    }
    // Sentinel = 'simpleParams'
    if ((!((aMsg)->ReadSentinel(aIter, 3404291700)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'JSURIParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->baseURI())))))) {
        (aActor)->FatalError("Error deserializing 'baseURI' (OptionalURIParams) member of 'JSURIParams'");
        return false;
    }
    // Sentinel = 'baseURI'
    if ((!((aMsg)->ReadSentinel(aIter, 1836705256)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'baseURI' (OptionalURIParams) member of 'JSURIParams'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::SimpleNestedURIParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).simpleParams());
    // Sentinel = 'simpleParams'
    (aMsg)->WriteSentinel(3404291700);
    WriteIPDLParam(aMsg, aActor, (aVar).innerURI());
    // Sentinel = 'innerURI'
    (aMsg)->WriteSentinel(2573245334);
}

auto IPDLParamTraits<mozilla::ipc::SimpleNestedURIParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->simpleParams())))))) {
        (aActor)->FatalError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'SimpleNestedURIParams'");
        return false;
    }
    // Sentinel = 'simpleParams'
    if ((!((aMsg)->ReadSentinel(aIter, 3404291700)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'SimpleNestedURIParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->innerURI())))))) {
        (aActor)->FatalError("Error deserializing 'innerURI' (URIParams) member of 'SimpleNestedURIParams'");
        return false;
    }
    // Sentinel = 'innerURI'
    if ((!((aMsg)->ReadSentinel(aIter, 2573245334)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'innerURI' (URIParams) member of 'SimpleNestedURIParams'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53