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

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


#include "mozilla/layers/WebRenderMessageUtils.h"
#include "mozilla/layers/PTextureParent.h"
#include "mozilla/layers/PTextureChild.h"
#include "mozilla/layers/WebRenderMessages.h"


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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::RefCountedShmem>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).buffer());
    // Sentinel = 'buffer'
    (aMsg)->WriteSentinel(4093250504);
}

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

} // namespace ipc
} // namespace mozilla

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

MOZ_IMPLICIT OptionalTransform::OptionalTransform(const Matrix4x4& aOther)
{
    new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4(aOther);
    mType = TMatrix4x4;
}

MOZ_IMPLICIT OptionalTransform::OptionalTransform(Matrix4x4&& aOther)
{
    new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4(std::move(aOther));
    mType = TMatrix4x4;
}

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

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

MOZ_IMPLICIT OptionalTransform::OptionalTransform(const OptionalTransform& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TMatrix4x4:
        {
            new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4((aOther).get_Matrix4x4());
            break;
        }
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT OptionalTransform::OptionalTransform(OptionalTransform&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TMatrix4x4:
        {
            new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4(std::move((aOther).get_Matrix4x4()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    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 T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto OptionalTransform::operator=(const Matrix4x4& aRhs) -> OptionalTransform&
{
    if (MaybeDestroy(TMatrix4x4)) {
        new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4;
    }
    (*(ptr_Matrix4x4())) = aRhs;
    mType = TMatrix4x4;
    return (*(this));
}

auto OptionalTransform::operator=(Matrix4x4&& aRhs) -> OptionalTransform&
{
    if (MaybeDestroy(TMatrix4x4)) {
        new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4;
    }
    (*(ptr_Matrix4x4())) = std::move(aRhs);
    mType = TMatrix4x4;
    return (*(this));
}

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

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

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

auto OptionalTransform::operator=(OptionalTransform&& aRhs) -> OptionalTransform&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TMatrix4x4:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4;
            }
            (*(ptr_Matrix4x4())) = std::move((aRhs).get_Matrix4x4());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    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 T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto OptionalTransform::operator==(const Matrix4x4& aRhs) const -> bool
{
    return (get_Matrix4x4()) == (aRhs);
}

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

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

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

auto OptionalTransform::get(Matrix4x4* aOutValue) const -> void
{
    (*(aOutValue)) = get_Matrix4x4();
}

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

} // namespace layers
} // namespace mozilla

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

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

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

    switch (type) {
    case union__::TMatrix4x4:
        {
            mozilla::gfx::Matrix4x4 tmp = mozilla::gfx::Matrix4x4();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_Matrix4x4())))))) {
                (aActor)->FatalError("Error deserializing variant TMatrix4x4 of union OptionalTransform");
                return false;
            }
            // Sentinel = 'TMatrix4x4'
            if ((!((aMsg)->ReadSentinel(aIter, 1886581935)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TMatrix4x4 of union OptionalTransform");
                return false;
            }
            return true;
        }
    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 OptionalTransform");
                return false;
            }
            // Sentinel = 'Tvoid_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3041273328)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tvoid_t of union OptionalTransform");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

MOZ_IMPLICIT OptionalOpacity::OptionalOpacity(const float& aOther)
{
    new (mozilla::KnownNotNull, ptr_float()) float(aOther);
    mType = Tfloat;
}

MOZ_IMPLICIT OptionalOpacity::OptionalOpacity(float&& aOther)
{
    new (mozilla::KnownNotNull, ptr_float()) float(std::move(aOther));
    mType = Tfloat;
}

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

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

MOZ_IMPLICIT OptionalOpacity::OptionalOpacity(const OptionalOpacity& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tfloat:
        {
            new (mozilla::KnownNotNull, ptr_float()) float((aOther).get_float());
            break;
        }
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT OptionalOpacity::OptionalOpacity(OptionalOpacity&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tfloat:
        {
            new (mozilla::KnownNotNull, ptr_float()) float(std::move((aOther).get_float()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    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 T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto OptionalOpacity::operator=(const float& aRhs) -> OptionalOpacity&
{
    if (MaybeDestroy(Tfloat)) {
        new (mozilla::KnownNotNull, ptr_float()) float;
    }
    (*(ptr_float())) = aRhs;
    mType = Tfloat;
    return (*(this));
}

auto OptionalOpacity::operator=(float&& aRhs) -> OptionalOpacity&
{
    if (MaybeDestroy(Tfloat)) {
        new (mozilla::KnownNotNull, ptr_float()) float;
    }
    (*(ptr_float())) = std::move(aRhs);
    mType = Tfloat;
    return (*(this));
}

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

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

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

auto OptionalOpacity::operator=(OptionalOpacity&& aRhs) -> OptionalOpacity&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tfloat:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_float()) float;
            }
            (*(ptr_float())) = std::move((aRhs).get_float());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    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 T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto OptionalOpacity::operator==(const float& aRhs) const -> bool
{
    return (get_float()) == (aRhs);
}

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

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

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

auto OptionalOpacity::get(float* aOutValue) const -> void
{
    (*(aOutValue)) = get_float();
}

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

} // namespace layers
} // namespace mozilla

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

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

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

    switch (type) {
    case union__::Tfloat:
        {
            float tmp = float();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_float())))))) {
                (aActor)->FatalError("Error deserializing variant Tfloat of union OptionalOpacity");
                return false;
            }
            // Sentinel = 'Tfloat'
            if ((!((aMsg)->ReadSentinel(aIter, 2693237468)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tfloat of union OptionalOpacity");
                return false;
            }
            return true;
        }
    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 OptionalOpacity");
                return false;
            }
            // Sentinel = 'Tvoid_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3041273328)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tvoid_t of union OptionalOpacity");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpAddExternalImage>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).externalImageId());
    // Sentinel = 'externalImageId'
    (aMsg)->WriteSentinel(2839682692);
    WriteIPDLParam(aMsg, aActor, (aVar).key());
    // Sentinel = 'key'
    (aMsg)->WriteSentinel(35142870);
}

auto IPDLParamTraits<mozilla::layers::OpAddExternalImage>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->externalImageId())))))) {
        (aActor)->FatalError("Error deserializing 'externalImageId' (ExternalImageId) member of 'OpAddExternalImage'");
        return false;
    }
    // Sentinel = 'externalImageId'
    if ((!((aMsg)->ReadSentinel(aIter, 2839682692)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'externalImageId' (ExternalImageId) member of 'OpAddExternalImage'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->key())))))) {
        (aActor)->FatalError("Error deserializing 'key' (ImageKey) member of 'OpAddExternalImage'");
        return false;
    }
    // Sentinel = 'key'
    if ((!((aMsg)->ReadSentinel(aIter, 35142870)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'key' (ImageKey) member of 'OpAddExternalImage'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpPushExternalImageForTexture|
//
namespace mozilla {
namespace layers {
auto OpPushExternalImageForTexture::operator==(const OpPushExternalImageForTexture& _o) const -> bool
{
    if ((!((externalImageId()) == ((_o).externalImageId())))) {
        return false;
    }
    if ((!((key()) == ((_o).key())))) {
        return false;
    }
    if ((!((textureParent()) == ((_o).textureParent())))) {
        return false;
    }
    if ((!((textureChild()) == ((_o).textureChild())))) {
        return false;
    }
    if ((!((isUpdate()) == ((_o).isUpdate())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpPushExternalImageForTexture>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).externalImageId());
    // Sentinel = 'externalImageId'
    (aMsg)->WriteSentinel(2839682692);
    WriteIPDLParam(aMsg, aActor, (aVar).key());
    // Sentinel = 'key'
    (aMsg)->WriteSentinel(35142870);
    if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
        MOZ_RELEASE_ASSERT((aVar).textureParent(), "NULL actor value passed to non-nullable param");
        WriteIPDLParam(aMsg, aActor, (aVar).textureParent());
        // Sentinel = 'texture'
        (aMsg)->WriteSentinel(3654462510);
    }
    if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
        MOZ_RELEASE_ASSERT((aVar).textureChild(), "NULL actor value passed to non-nullable param");
        WriteIPDLParam(aMsg, aActor, (aVar).textureChild());
        // Sentinel = 'texture'
        (aMsg)->WriteSentinel(3654462510);
    }
    WriteIPDLParam(aMsg, aActor, (aVar).isUpdate());
    // Sentinel = 'isUpdate'
    (aMsg)->WriteSentinel(3349116411);
}

auto IPDLParamTraits<mozilla::layers::OpPushExternalImageForTexture>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->externalImageId())))))) {
        (aActor)->FatalError("Error deserializing 'externalImageId' (ExternalImageId) member of 'OpPushExternalImageForTexture'");
        return false;
    }
    // Sentinel = 'externalImageId'
    if ((!((aMsg)->ReadSentinel(aIter, 2839682692)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'externalImageId' (ExternalImageId) member of 'OpPushExternalImageForTexture'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->key())))))) {
        (aActor)->FatalError("Error deserializing 'key' (ImageKey) member of 'OpPushExternalImageForTexture'");
        return false;
    }
    // Sentinel = 'key'
    if ((!((aMsg)->ReadSentinel(aIter, 35142870)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'key' (ImageKey) member of 'OpPushExternalImageForTexture'");
        return false;
    }
    if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
        if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->textureParent())))))) {
            (aActor)->FatalError("Error deserializing 'textureParent' (PTexture) member of 'OpPushExternalImageForTexture'");
            return false;
        }
        if ((!((*((&((aVar)->textureParent()))))))) {
            (aActor)->FatalError("Error deserializing 'textureParent' (PTexture) member of 'OpPushExternalImageForTexture'");
            return false;
        }
        // Sentinel = 'texture'
        if ((!((aMsg)->ReadSentinel(aIter, 3654462510)))) {
            mozilla::ipc::SentinelReadError("Error deserializing 'textureParent' (PTexture) member of 'OpPushExternalImageForTexture'");
            return false;
        }
    }
    if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
        if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->textureChild())))))) {
            (aActor)->FatalError("Error deserializing 'textureChild' (PTexture) member of 'OpPushExternalImageForTexture'");
            return false;
        }
        if ((!((*((&((aVar)->textureChild()))))))) {
            (aActor)->FatalError("Error deserializing 'textureChild' (PTexture) member of 'OpPushExternalImageForTexture'");
            return false;
        }
        // Sentinel = 'texture'
        if ((!((aMsg)->ReadSentinel(aIter, 3654462510)))) {
            mozilla::ipc::SentinelReadError("Error deserializing 'textureChild' (PTexture) member of 'OpPushExternalImageForTexture'");
            return false;
        }
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->isUpdate())))))) {
        (aActor)->FatalError("Error deserializing 'isUpdate' (bool) member of 'OpPushExternalImageForTexture'");
        return false;
    }
    // Sentinel = 'isUpdate'
    if ((!((aMsg)->ReadSentinel(aIter, 3349116411)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isUpdate' (bool) member of 'OpPushExternalImageForTexture'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpAddCompositorAnimations>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).data());
    // Sentinel = 'data'
    (aMsg)->WriteSentinel(843352540);
}

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpAddPipelineIdForCompositable|
//
namespace mozilla {
namespace layers {
auto OpAddPipelineIdForCompositable::operator==(const OpAddPipelineIdForCompositable& _o) const -> bool
{
    if ((!((pipelineId()) == ((_o).pipelineId())))) {
        return false;
    }
    if ((!((handle()) == ((_o).handle())))) {
        return false;
    }
    if ((!((isAsync()) == ((_o).isAsync())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpAddPipelineIdForCompositable>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).pipelineId());
    // Sentinel = 'pipelineId'
    (aMsg)->WriteSentinel(4067092043);
    WriteIPDLParam(aMsg, aActor, (aVar).handle());
    // Sentinel = 'handle'
    (aMsg)->WriteSentinel(453975108);
    WriteIPDLParam(aMsg, aActor, (aVar).isAsync());
    // Sentinel = 'isAsync'
    (aMsg)->WriteSentinel(643016499);
}

auto IPDLParamTraits<mozilla::layers::OpAddPipelineIdForCompositable>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->pipelineId())))))) {
        (aActor)->FatalError("Error deserializing 'pipelineId' (PipelineId) member of 'OpAddPipelineIdForCompositable'");
        return false;
    }
    // Sentinel = 'pipelineId'
    if ((!((aMsg)->ReadSentinel(aIter, 4067092043)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'pipelineId' (PipelineId) member of 'OpAddPipelineIdForCompositable'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->handle())))))) {
        (aActor)->FatalError("Error deserializing 'handle' (CompositableHandle) member of 'OpAddPipelineIdForCompositable'");
        return false;
    }
    // Sentinel = 'handle'
    if ((!((aMsg)->ReadSentinel(aIter, 453975108)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handle' (CompositableHandle) member of 'OpAddPipelineIdForCompositable'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->isAsync())))))) {
        (aActor)->FatalError("Error deserializing 'isAsync' (bool) member of 'OpAddPipelineIdForCompositable'");
        return false;
    }
    // Sentinel = 'isAsync'
    if ((!((aMsg)->ReadSentinel(aIter, 643016499)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isAsync' (bool) member of 'OpAddPipelineIdForCompositable'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpRemovePipelineIdForCompositable>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).pipelineId());
    // Sentinel = 'pipelineId'
    (aMsg)->WriteSentinel(4067092043);
}

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpRemoveExternalImageId>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).externalImageId());
    // Sentinel = 'externalImageId'
    (aMsg)->WriteSentinel(2839682692);
}

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpReleaseTextureOfImage>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).key());
    // Sentinel = 'key'
    (aMsg)->WriteSentinel(35142870);
}

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpUpdateAsyncImagePipeline|
//
namespace mozilla {
namespace layers {
auto OpUpdateAsyncImagePipeline::operator==(const OpUpdateAsyncImagePipeline& _o) const -> bool
{
    if ((!((pipelineId()) == ((_o).pipelineId())))) {
        return false;
    }
    if ((!((scBounds()) == ((_o).scBounds())))) {
        return false;
    }
    if ((!((scTransform()) == ((_o).scTransform())))) {
        return false;
    }
    if ((!((scaleToSize()) == ((_o).scaleToSize())))) {
        return false;
    }
    if ((!((filter()) == ((_o).filter())))) {
        return false;
    }
    if ((!((mixBlendMode()) == ((_o).mixBlendMode())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpUpdateAsyncImagePipeline>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).pipelineId());
    // Sentinel = 'pipelineId'
    (aMsg)->WriteSentinel(4067092043);
    WriteIPDLParam(aMsg, aActor, (aVar).scBounds());
    // Sentinel = 'scBounds'
    (aMsg)->WriteSentinel(448805933);
    WriteIPDLParam(aMsg, aActor, (aVar).scTransform());
    // Sentinel = 'scTransform'
    (aMsg)->WriteSentinel(1345782441);
    WriteIPDLParam(aMsg, aActor, (aVar).scaleToSize());
    // Sentinel = 'scaleToSize'
    (aMsg)->WriteSentinel(1078440273);
    WriteIPDLParam(aMsg, aActor, (aVar).filter());
    // Sentinel = 'filter'
    (aMsg)->WriteSentinel(2236769008);
    WriteIPDLParam(aMsg, aActor, (aVar).mixBlendMode());
    // Sentinel = 'mixBlendMode'
    (aMsg)->WriteSentinel(1158101226);
}

auto IPDLParamTraits<mozilla::layers::OpUpdateAsyncImagePipeline>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->pipelineId())))))) {
        (aActor)->FatalError("Error deserializing 'pipelineId' (PipelineId) member of 'OpUpdateAsyncImagePipeline'");
        return false;
    }
    // Sentinel = 'pipelineId'
    if ((!((aMsg)->ReadSentinel(aIter, 4067092043)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'pipelineId' (PipelineId) member of 'OpUpdateAsyncImagePipeline'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->scBounds())))))) {
        (aActor)->FatalError("Error deserializing 'scBounds' (LayoutDeviceRect) member of 'OpUpdateAsyncImagePipeline'");
        return false;
    }
    // Sentinel = 'scBounds'
    if ((!((aMsg)->ReadSentinel(aIter, 448805933)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scBounds' (LayoutDeviceRect) member of 'OpUpdateAsyncImagePipeline'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->scTransform())))))) {
        (aActor)->FatalError("Error deserializing 'scTransform' (Matrix4x4) member of 'OpUpdateAsyncImagePipeline'");
        return false;
    }
    // Sentinel = 'scTransform'
    if ((!((aMsg)->ReadSentinel(aIter, 1345782441)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scTransform' (Matrix4x4) member of 'OpUpdateAsyncImagePipeline'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->scaleToSize())))))) {
        (aActor)->FatalError("Error deserializing 'scaleToSize' (MaybeIntSize) member of 'OpUpdateAsyncImagePipeline'");
        return false;
    }
    // Sentinel = 'scaleToSize'
    if ((!((aMsg)->ReadSentinel(aIter, 1078440273)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scaleToSize' (MaybeIntSize) member of 'OpUpdateAsyncImagePipeline'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->filter())))))) {
        (aActor)->FatalError("Error deserializing 'filter' (ImageRendering) member of 'OpUpdateAsyncImagePipeline'");
        return false;
    }
    // Sentinel = 'filter'
    if ((!((aMsg)->ReadSentinel(aIter, 2236769008)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'filter' (ImageRendering) member of 'OpUpdateAsyncImagePipeline'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->mixBlendMode())))))) {
        (aActor)->FatalError("Error deserializing 'mixBlendMode' (MixBlendMode) member of 'OpUpdateAsyncImagePipeline'");
        return false;
    }
    // Sentinel = 'mixBlendMode'
    if ((!((aMsg)->ReadSentinel(aIter, 1158101226)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'mixBlendMode' (MixBlendMode) member of 'OpUpdateAsyncImagePipeline'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpUpdatedAsyncImagePipeline>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).pipelineId());
    // Sentinel = 'pipelineId'
    (aMsg)->WriteSentinel(4067092043);
}

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union WebRenderParentCommand|
//
namespace mozilla {
namespace layers {
auto WebRenderParentCommand::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TOpAddPipelineIdForCompositable:
        {
            (ptr_OpAddPipelineIdForCompositable())->~OpAddPipelineIdForCompositable__tdef();
            break;
        }
    case TOpRemovePipelineIdForCompositable:
        {
            (ptr_OpRemovePipelineIdForCompositable())->~OpRemovePipelineIdForCompositable__tdef();
            break;
        }
    case TOpRemoveExternalImageId:
        {
            (ptr_OpRemoveExternalImageId())->~OpRemoveExternalImageId__tdef();
            break;
        }
    case TOpReleaseTextureOfImage:
        {
            (ptr_OpReleaseTextureOfImage())->~OpReleaseTextureOfImage__tdef();
            break;
        }
    case TOpUpdateAsyncImagePipeline:
        {
            (ptr_OpUpdateAsyncImagePipeline())->~OpUpdateAsyncImagePipeline__tdef();
            break;
        }
    case TOpUpdatedAsyncImagePipeline:
        {
            (ptr_OpUpdatedAsyncImagePipeline())->~OpUpdatedAsyncImagePipeline__tdef();
            break;
        }
    case TCompositableOperation:
        {
            (ptr_CompositableOperation())->~CompositableOperation__tdef();
            break;
        }
    case TOpAddCompositorAnimations:
        {
            (ptr_OpAddCompositorAnimations())->~OpAddCompositorAnimations__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(const OpAddPipelineIdForCompositable& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddPipelineIdForCompositable()) OpAddPipelineIdForCompositable(aOther);
    mType = TOpAddPipelineIdForCompositable;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(OpAddPipelineIdForCompositable&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddPipelineIdForCompositable()) OpAddPipelineIdForCompositable(std::move(aOther));
    mType = TOpAddPipelineIdForCompositable;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(const OpRemovePipelineIdForCompositable& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpRemovePipelineIdForCompositable()) OpRemovePipelineIdForCompositable(aOther);
    mType = TOpRemovePipelineIdForCompositable;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(OpRemovePipelineIdForCompositable&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpRemovePipelineIdForCompositable()) OpRemovePipelineIdForCompositable(std::move(aOther));
    mType = TOpRemovePipelineIdForCompositable;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(const OpRemoveExternalImageId& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpRemoveExternalImageId()) OpRemoveExternalImageId(aOther);
    mType = TOpRemoveExternalImageId;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(OpRemoveExternalImageId&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpRemoveExternalImageId()) OpRemoveExternalImageId(std::move(aOther));
    mType = TOpRemoveExternalImageId;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(const OpReleaseTextureOfImage& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpReleaseTextureOfImage()) OpReleaseTextureOfImage(aOther);
    mType = TOpReleaseTextureOfImage;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(OpReleaseTextureOfImage&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpReleaseTextureOfImage()) OpReleaseTextureOfImage(std::move(aOther));
    mType = TOpReleaseTextureOfImage;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(const OpUpdateAsyncImagePipeline& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUpdateAsyncImagePipeline()) OpUpdateAsyncImagePipeline(aOther);
    mType = TOpUpdateAsyncImagePipeline;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(OpUpdateAsyncImagePipeline&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUpdateAsyncImagePipeline()) OpUpdateAsyncImagePipeline(std::move(aOther));
    mType = TOpUpdateAsyncImagePipeline;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(const OpUpdatedAsyncImagePipeline& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUpdatedAsyncImagePipeline()) OpUpdatedAsyncImagePipeline(aOther);
    mType = TOpUpdatedAsyncImagePipeline;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(OpUpdatedAsyncImagePipeline&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUpdatedAsyncImagePipeline()) OpUpdatedAsyncImagePipeline(std::move(aOther));
    mType = TOpUpdatedAsyncImagePipeline;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(const CompositableOperation& aOther)
{
    new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation(aOther);
    mType = TCompositableOperation;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(CompositableOperation&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation(std::move(aOther));
    mType = TCompositableOperation;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(const OpAddCompositorAnimations& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddCompositorAnimations()) OpAddCompositorAnimations(aOther);
    mType = TOpAddCompositorAnimations;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(OpAddCompositorAnimations&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddCompositorAnimations()) OpAddCompositorAnimations(std::move(aOther));
    mType = TOpAddCompositorAnimations;
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(const WebRenderParentCommand& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TOpAddPipelineIdForCompositable:
        {
            new (mozilla::KnownNotNull, ptr_OpAddPipelineIdForCompositable()) OpAddPipelineIdForCompositable((aOther).get_OpAddPipelineIdForCompositable());
            break;
        }
    case TOpRemovePipelineIdForCompositable:
        {
            new (mozilla::KnownNotNull, ptr_OpRemovePipelineIdForCompositable()) OpRemovePipelineIdForCompositable((aOther).get_OpRemovePipelineIdForCompositable());
            break;
        }
    case TOpRemoveExternalImageId:
        {
            new (mozilla::KnownNotNull, ptr_OpRemoveExternalImageId()) OpRemoveExternalImageId((aOther).get_OpRemoveExternalImageId());
            break;
        }
    case TOpReleaseTextureOfImage:
        {
            new (mozilla::KnownNotNull, ptr_OpReleaseTextureOfImage()) OpReleaseTextureOfImage((aOther).get_OpReleaseTextureOfImage());
            break;
        }
    case TOpUpdateAsyncImagePipeline:
        {
            new (mozilla::KnownNotNull, ptr_OpUpdateAsyncImagePipeline()) OpUpdateAsyncImagePipeline((aOther).get_OpUpdateAsyncImagePipeline());
            break;
        }
    case TOpUpdatedAsyncImagePipeline:
        {
            new (mozilla::KnownNotNull, ptr_OpUpdatedAsyncImagePipeline()) OpUpdatedAsyncImagePipeline((aOther).get_OpUpdatedAsyncImagePipeline());
            break;
        }
    case TCompositableOperation:
        {
            new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation((aOther).get_CompositableOperation());
            break;
        }
    case TOpAddCompositorAnimations:
        {
            new (mozilla::KnownNotNull, ptr_OpAddCompositorAnimations()) OpAddCompositorAnimations((aOther).get_OpAddCompositorAnimations());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(WebRenderParentCommand&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TOpAddPipelineIdForCompositable:
        {
            new (mozilla::KnownNotNull, ptr_OpAddPipelineIdForCompositable()) OpAddPipelineIdForCompositable(std::move((aOther).get_OpAddPipelineIdForCompositable()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpRemovePipelineIdForCompositable:
        {
            new (mozilla::KnownNotNull, ptr_OpRemovePipelineIdForCompositable()) OpRemovePipelineIdForCompositable(std::move((aOther).get_OpRemovePipelineIdForCompositable()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpRemoveExternalImageId:
        {
            new (mozilla::KnownNotNull, ptr_OpRemoveExternalImageId()) OpRemoveExternalImageId(std::move((aOther).get_OpRemoveExternalImageId()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpReleaseTextureOfImage:
        {
            new (mozilla::KnownNotNull, ptr_OpReleaseTextureOfImage()) OpReleaseTextureOfImage(std::move((aOther).get_OpReleaseTextureOfImage()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpUpdateAsyncImagePipeline:
        {
            new (mozilla::KnownNotNull, ptr_OpUpdateAsyncImagePipeline()) OpUpdateAsyncImagePipeline(std::move((aOther).get_OpUpdateAsyncImagePipeline()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpUpdatedAsyncImagePipeline:
        {
            new (mozilla::KnownNotNull, ptr_OpUpdatedAsyncImagePipeline()) OpUpdatedAsyncImagePipeline(std::move((aOther).get_OpUpdatedAsyncImagePipeline()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TCompositableOperation:
        {
            new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation(std::move((aOther).get_CompositableOperation()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpAddCompositorAnimations:
        {
            new (mozilla::KnownNotNull, ptr_OpAddCompositorAnimations()) OpAddCompositorAnimations(std::move((aOther).get_OpAddCompositorAnimations()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto WebRenderParentCommand::operator=(const OpAddPipelineIdForCompositable& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TOpAddPipelineIdForCompositable)) {
        new (mozilla::KnownNotNull, ptr_OpAddPipelineIdForCompositable()) OpAddPipelineIdForCompositable;
    }
    (*(ptr_OpAddPipelineIdForCompositable())) = aRhs;
    mType = TOpAddPipelineIdForCompositable;
    return (*(this));
}

auto WebRenderParentCommand::operator=(OpAddPipelineIdForCompositable&& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TOpAddPipelineIdForCompositable)) {
        new (mozilla::KnownNotNull, ptr_OpAddPipelineIdForCompositable()) OpAddPipelineIdForCompositable;
    }
    (*(ptr_OpAddPipelineIdForCompositable())) = std::move(aRhs);
    mType = TOpAddPipelineIdForCompositable;
    return (*(this));
}

auto WebRenderParentCommand::operator=(const OpRemovePipelineIdForCompositable& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TOpRemovePipelineIdForCompositable)) {
        new (mozilla::KnownNotNull, ptr_OpRemovePipelineIdForCompositable()) OpRemovePipelineIdForCompositable;
    }
    (*(ptr_OpRemovePipelineIdForCompositable())) = aRhs;
    mType = TOpRemovePipelineIdForCompositable;
    return (*(this));
}

auto WebRenderParentCommand::operator=(OpRemovePipelineIdForCompositable&& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TOpRemovePipelineIdForCompositable)) {
        new (mozilla::KnownNotNull, ptr_OpRemovePipelineIdForCompositable()) OpRemovePipelineIdForCompositable;
    }
    (*(ptr_OpRemovePipelineIdForCompositable())) = std::move(aRhs);
    mType = TOpRemovePipelineIdForCompositable;
    return (*(this));
}

auto WebRenderParentCommand::operator=(const OpRemoveExternalImageId& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TOpRemoveExternalImageId)) {
        new (mozilla::KnownNotNull, ptr_OpRemoveExternalImageId()) OpRemoveExternalImageId;
    }
    (*(ptr_OpRemoveExternalImageId())) = aRhs;
    mType = TOpRemoveExternalImageId;
    return (*(this));
}

auto WebRenderParentCommand::operator=(OpRemoveExternalImageId&& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TOpRemoveExternalImageId)) {
        new (mozilla::KnownNotNull, ptr_OpRemoveExternalImageId()) OpRemoveExternalImageId;
    }
    (*(ptr_OpRemoveExternalImageId())) = std::move(aRhs);
    mType = TOpRemoveExternalImageId;
    return (*(this));
}

auto WebRenderParentCommand::operator=(const OpReleaseTextureOfImage& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TOpReleaseTextureOfImage)) {
        new (mozilla::KnownNotNull, ptr_OpReleaseTextureOfImage()) OpReleaseTextureOfImage;
    }
    (*(ptr_OpReleaseTextureOfImage())) = aRhs;
    mType = TOpReleaseTextureOfImage;
    return (*(this));
}

auto WebRenderParentCommand::operator=(OpReleaseTextureOfImage&& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TOpReleaseTextureOfImage)) {
        new (mozilla::KnownNotNull, ptr_OpReleaseTextureOfImage()) OpReleaseTextureOfImage;
    }
    (*(ptr_OpReleaseTextureOfImage())) = std::move(aRhs);
    mType = TOpReleaseTextureOfImage;
    return (*(this));
}

auto WebRenderParentCommand::operator=(const OpUpdateAsyncImagePipeline& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TOpUpdateAsyncImagePipeline)) {
        new (mozilla::KnownNotNull, ptr_OpUpdateAsyncImagePipeline()) OpUpdateAsyncImagePipeline;
    }
    (*(ptr_OpUpdateAsyncImagePipeline())) = aRhs;
    mType = TOpUpdateAsyncImagePipeline;
    return (*(this));
}

auto WebRenderParentCommand::operator=(OpUpdateAsyncImagePipeline&& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TOpUpdateAsyncImagePipeline)) {
        new (mozilla::KnownNotNull, ptr_OpUpdateAsyncImagePipeline()) OpUpdateAsyncImagePipeline;
    }
    (*(ptr_OpUpdateAsyncImagePipeline())) = std::move(aRhs);
    mType = TOpUpdateAsyncImagePipeline;
    return (*(this));
}

auto WebRenderParentCommand::operator=(const OpUpdatedAsyncImagePipeline& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TOpUpdatedAsyncImagePipeline)) {
        new (mozilla::KnownNotNull, ptr_OpUpdatedAsyncImagePipeline()) OpUpdatedAsyncImagePipeline;
    }
    (*(ptr_OpUpdatedAsyncImagePipeline())) = aRhs;
    mType = TOpUpdatedAsyncImagePipeline;
    return (*(this));
}

auto WebRenderParentCommand::operator=(OpUpdatedAsyncImagePipeline&& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TOpUpdatedAsyncImagePipeline)) {
        new (mozilla::KnownNotNull, ptr_OpUpdatedAsyncImagePipeline()) OpUpdatedAsyncImagePipeline;
    }
    (*(ptr_OpUpdatedAsyncImagePipeline())) = std::move(aRhs);
    mType = TOpUpdatedAsyncImagePipeline;
    return (*(this));
}

auto WebRenderParentCommand::operator=(const CompositableOperation& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TCompositableOperation)) {
        new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation;
    }
    (*(ptr_CompositableOperation())) = aRhs;
    mType = TCompositableOperation;
    return (*(this));
}

auto WebRenderParentCommand::operator=(CompositableOperation&& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TCompositableOperation)) {
        new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation;
    }
    (*(ptr_CompositableOperation())) = std::move(aRhs);
    mType = TCompositableOperation;
    return (*(this));
}

auto WebRenderParentCommand::operator=(const OpAddCompositorAnimations& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TOpAddCompositorAnimations)) {
        new (mozilla::KnownNotNull, ptr_OpAddCompositorAnimations()) OpAddCompositorAnimations;
    }
    (*(ptr_OpAddCompositorAnimations())) = aRhs;
    mType = TOpAddCompositorAnimations;
    return (*(this));
}

auto WebRenderParentCommand::operator=(OpAddCompositorAnimations&& aRhs) -> WebRenderParentCommand&
{
    if (MaybeDestroy(TOpAddCompositorAnimations)) {
        new (mozilla::KnownNotNull, ptr_OpAddCompositorAnimations()) OpAddCompositorAnimations;
    }
    (*(ptr_OpAddCompositorAnimations())) = std::move(aRhs);
    mType = TOpAddCompositorAnimations;
    return (*(this));
}

auto WebRenderParentCommand::operator=(const WebRenderParentCommand& aRhs) -> WebRenderParentCommand&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TOpAddPipelineIdForCompositable:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddPipelineIdForCompositable()) OpAddPipelineIdForCompositable;
            }
            (*(ptr_OpAddPipelineIdForCompositable())) = (aRhs).get_OpAddPipelineIdForCompositable();
            break;
        }
    case TOpRemovePipelineIdForCompositable:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpRemovePipelineIdForCompositable()) OpRemovePipelineIdForCompositable;
            }
            (*(ptr_OpRemovePipelineIdForCompositable())) = (aRhs).get_OpRemovePipelineIdForCompositable();
            break;
        }
    case TOpRemoveExternalImageId:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpRemoveExternalImageId()) OpRemoveExternalImageId;
            }
            (*(ptr_OpRemoveExternalImageId())) = (aRhs).get_OpRemoveExternalImageId();
            break;
        }
    case TOpReleaseTextureOfImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpReleaseTextureOfImage()) OpReleaseTextureOfImage;
            }
            (*(ptr_OpReleaseTextureOfImage())) = (aRhs).get_OpReleaseTextureOfImage();
            break;
        }
    case TOpUpdateAsyncImagePipeline:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUpdateAsyncImagePipeline()) OpUpdateAsyncImagePipeline;
            }
            (*(ptr_OpUpdateAsyncImagePipeline())) = (aRhs).get_OpUpdateAsyncImagePipeline();
            break;
        }
    case TOpUpdatedAsyncImagePipeline:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUpdatedAsyncImagePipeline()) OpUpdatedAsyncImagePipeline;
            }
            (*(ptr_OpUpdatedAsyncImagePipeline())) = (aRhs).get_OpUpdatedAsyncImagePipeline();
            break;
        }
    case TCompositableOperation:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation;
            }
            (*(ptr_CompositableOperation())) = (aRhs).get_CompositableOperation();
            break;
        }
    case TOpAddCompositorAnimations:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddCompositorAnimations()) OpAddCompositorAnimations;
            }
            (*(ptr_OpAddCompositorAnimations())) = (aRhs).get_OpAddCompositorAnimations();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto WebRenderParentCommand::operator=(WebRenderParentCommand&& aRhs) -> WebRenderParentCommand&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TOpAddPipelineIdForCompositable:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddPipelineIdForCompositable()) OpAddPipelineIdForCompositable;
            }
            (*(ptr_OpAddPipelineIdForCompositable())) = std::move((aRhs).get_OpAddPipelineIdForCompositable());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpRemovePipelineIdForCompositable:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpRemovePipelineIdForCompositable()) OpRemovePipelineIdForCompositable;
            }
            (*(ptr_OpRemovePipelineIdForCompositable())) = std::move((aRhs).get_OpRemovePipelineIdForCompositable());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpRemoveExternalImageId:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpRemoveExternalImageId()) OpRemoveExternalImageId;
            }
            (*(ptr_OpRemoveExternalImageId())) = std::move((aRhs).get_OpRemoveExternalImageId());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpReleaseTextureOfImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpReleaseTextureOfImage()) OpReleaseTextureOfImage;
            }
            (*(ptr_OpReleaseTextureOfImage())) = std::move((aRhs).get_OpReleaseTextureOfImage());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpUpdateAsyncImagePipeline:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUpdateAsyncImagePipeline()) OpUpdateAsyncImagePipeline;
            }
            (*(ptr_OpUpdateAsyncImagePipeline())) = std::move((aRhs).get_OpUpdateAsyncImagePipeline());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpUpdatedAsyncImagePipeline:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUpdatedAsyncImagePipeline()) OpUpdatedAsyncImagePipeline;
            }
            (*(ptr_OpUpdatedAsyncImagePipeline())) = std::move((aRhs).get_OpUpdatedAsyncImagePipeline());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TCompositableOperation:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation;
            }
            (*(ptr_CompositableOperation())) = std::move((aRhs).get_CompositableOperation());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpAddCompositorAnimations:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddCompositorAnimations()) OpAddCompositorAnimations;
            }
            (*(ptr_OpAddCompositorAnimations())) = std::move((aRhs).get_OpAddCompositorAnimations());
            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 WebRenderParentCommand::operator==(const OpAddPipelineIdForCompositable& aRhs) const -> bool
{
    return (get_OpAddPipelineIdForCompositable()) == (aRhs);
}

auto WebRenderParentCommand::operator==(const OpRemovePipelineIdForCompositable& aRhs) const -> bool
{
    return (get_OpRemovePipelineIdForCompositable()) == (aRhs);
}

auto WebRenderParentCommand::operator==(const OpRemoveExternalImageId& aRhs) const -> bool
{
    return (get_OpRemoveExternalImageId()) == (aRhs);
}

auto WebRenderParentCommand::operator==(const OpReleaseTextureOfImage& aRhs) const -> bool
{
    return (get_OpReleaseTextureOfImage()) == (aRhs);
}

auto WebRenderParentCommand::operator==(const OpUpdateAsyncImagePipeline& aRhs) const -> bool
{
    return (get_OpUpdateAsyncImagePipeline()) == (aRhs);
}

auto WebRenderParentCommand::operator==(const OpUpdatedAsyncImagePipeline& aRhs) const -> bool
{
    return (get_OpUpdatedAsyncImagePipeline()) == (aRhs);
}

auto WebRenderParentCommand::operator==(const CompositableOperation& aRhs) const -> bool
{
    return (get_CompositableOperation()) == (aRhs);
}

auto WebRenderParentCommand::operator==(const OpAddCompositorAnimations& aRhs) const -> bool
{
    return (get_OpAddCompositorAnimations()) == (aRhs);
}

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

    switch (type()) {
    case TOpAddPipelineIdForCompositable:
        {
            return (get_OpAddPipelineIdForCompositable()) == ((aRhs).get_OpAddPipelineIdForCompositable());
        }
    case TOpRemovePipelineIdForCompositable:
        {
            return (get_OpRemovePipelineIdForCompositable()) == ((aRhs).get_OpRemovePipelineIdForCompositable());
        }
    case TOpRemoveExternalImageId:
        {
            return (get_OpRemoveExternalImageId()) == ((aRhs).get_OpRemoveExternalImageId());
        }
    case TOpReleaseTextureOfImage:
        {
            return (get_OpReleaseTextureOfImage()) == ((aRhs).get_OpReleaseTextureOfImage());
        }
    case TOpUpdateAsyncImagePipeline:
        {
            return (get_OpUpdateAsyncImagePipeline()) == ((aRhs).get_OpUpdateAsyncImagePipeline());
        }
    case TOpUpdatedAsyncImagePipeline:
        {
            return (get_OpUpdatedAsyncImagePipeline()) == ((aRhs).get_OpUpdatedAsyncImagePipeline());
        }
    case TCompositableOperation:
        {
            return (get_CompositableOperation()) == ((aRhs).get_CompositableOperation());
        }
    case TOpAddCompositorAnimations:
        {
            return (get_OpAddCompositorAnimations()) == ((aRhs).get_OpAddCompositorAnimations());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto WebRenderParentCommand::get(OpAddPipelineIdForCompositable* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpAddPipelineIdForCompositable();
}

auto WebRenderParentCommand::get(OpRemovePipelineIdForCompositable* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpRemovePipelineIdForCompositable();
}

auto WebRenderParentCommand::get(OpRemoveExternalImageId* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpRemoveExternalImageId();
}

auto WebRenderParentCommand::get(OpReleaseTextureOfImage* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpReleaseTextureOfImage();
}

auto WebRenderParentCommand::get(OpUpdateAsyncImagePipeline* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpUpdateAsyncImagePipeline();
}

auto WebRenderParentCommand::get(OpUpdatedAsyncImagePipeline* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpUpdatedAsyncImagePipeline();
}

auto WebRenderParentCommand::get(CompositableOperation* aOutValue) const -> void
{
    (*(aOutValue)) = get_CompositableOperation();
}

auto WebRenderParentCommand::get(OpAddCompositorAnimations* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpAddCompositorAnimations();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TOpAddPipelineIdForCompositable:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpAddPipelineIdForCompositable());
            // Sentinel = 'TOpAddPipelineIdForCompositable'
            (aMsg)->WriteSentinel(3833046203);
            return;
        }
    case union__::TOpRemovePipelineIdForCompositable:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpRemovePipelineIdForCompositable());
            // Sentinel = 'TOpRemovePipelineIdForCompositable'
            (aMsg)->WriteSentinel(1161823003);
            return;
        }
    case union__::TOpRemoveExternalImageId:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpRemoveExternalImageId());
            // Sentinel = 'TOpRemoveExternalImageId'
            (aMsg)->WriteSentinel(3998496540);
            return;
        }
    case union__::TOpReleaseTextureOfImage:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpReleaseTextureOfImage());
            // Sentinel = 'TOpReleaseTextureOfImage'
            (aMsg)->WriteSentinel(1527510721);
            return;
        }
    case union__::TOpUpdateAsyncImagePipeline:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpUpdateAsyncImagePipeline());
            // Sentinel = 'TOpUpdateAsyncImagePipeline'
            (aMsg)->WriteSentinel(2512870980);
            return;
        }
    case union__::TOpUpdatedAsyncImagePipeline:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpUpdatedAsyncImagePipeline());
            // Sentinel = 'TOpUpdatedAsyncImagePipeline'
            (aMsg)->WriteSentinel(456827427);
            return;
        }
    case union__::TCompositableOperation:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_CompositableOperation());
            // Sentinel = 'TCompositableOperation'
            (aMsg)->WriteSentinel(1903999853);
            return;
        }
    case union__::TOpAddCompositorAnimations:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpAddCompositorAnimations());
            // Sentinel = 'TOpAddCompositorAnimations'
            (aMsg)->WriteSentinel(3387367374);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TOpAddPipelineIdForCompositable:
        {
            mozilla::layers::OpAddPipelineIdForCompositable tmp = mozilla::layers::OpAddPipelineIdForCompositable();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpAddPipelineIdForCompositable())))))) {
                (aActor)->FatalError("Error deserializing variant TOpAddPipelineIdForCompositable of union WebRenderParentCommand");
                return false;
            }
            // Sentinel = 'TOpAddPipelineIdForCompositable'
            if ((!((aMsg)->ReadSentinel(aIter, 3833046203)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpAddPipelineIdForCompositable of union WebRenderParentCommand");
                return false;
            }
            return true;
        }
    case union__::TOpRemovePipelineIdForCompositable:
        {
            mozilla::layers::OpRemovePipelineIdForCompositable tmp = mozilla::layers::OpRemovePipelineIdForCompositable();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpRemovePipelineIdForCompositable())))))) {
                (aActor)->FatalError("Error deserializing variant TOpRemovePipelineIdForCompositable of union WebRenderParentCommand");
                return false;
            }
            // Sentinel = 'TOpRemovePipelineIdForCompositable'
            if ((!((aMsg)->ReadSentinel(aIter, 1161823003)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpRemovePipelineIdForCompositable of union WebRenderParentCommand");
                return false;
            }
            return true;
        }
    case union__::TOpRemoveExternalImageId:
        {
            mozilla::layers::OpRemoveExternalImageId tmp = mozilla::layers::OpRemoveExternalImageId();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpRemoveExternalImageId())))))) {
                (aActor)->FatalError("Error deserializing variant TOpRemoveExternalImageId of union WebRenderParentCommand");
                return false;
            }
            // Sentinel = 'TOpRemoveExternalImageId'
            if ((!((aMsg)->ReadSentinel(aIter, 3998496540)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpRemoveExternalImageId of union WebRenderParentCommand");
                return false;
            }
            return true;
        }
    case union__::TOpReleaseTextureOfImage:
        {
            mozilla::layers::OpReleaseTextureOfImage tmp = mozilla::layers::OpReleaseTextureOfImage();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpReleaseTextureOfImage())))))) {
                (aActor)->FatalError("Error deserializing variant TOpReleaseTextureOfImage of union WebRenderParentCommand");
                return false;
            }
            // Sentinel = 'TOpReleaseTextureOfImage'
            if ((!((aMsg)->ReadSentinel(aIter, 1527510721)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpReleaseTextureOfImage of union WebRenderParentCommand");
                return false;
            }
            return true;
        }
    case union__::TOpUpdateAsyncImagePipeline:
        {
            mozilla::layers::OpUpdateAsyncImagePipeline tmp = mozilla::layers::OpUpdateAsyncImagePipeline();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpUpdateAsyncImagePipeline())))))) {
                (aActor)->FatalError("Error deserializing variant TOpUpdateAsyncImagePipeline of union WebRenderParentCommand");
                return false;
            }
            // Sentinel = 'TOpUpdateAsyncImagePipeline'
            if ((!((aMsg)->ReadSentinel(aIter, 2512870980)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpUpdateAsyncImagePipeline of union WebRenderParentCommand");
                return false;
            }
            return true;
        }
    case union__::TOpUpdatedAsyncImagePipeline:
        {
            mozilla::layers::OpUpdatedAsyncImagePipeline tmp = mozilla::layers::OpUpdatedAsyncImagePipeline();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpUpdatedAsyncImagePipeline())))))) {
                (aActor)->FatalError("Error deserializing variant TOpUpdatedAsyncImagePipeline of union WebRenderParentCommand");
                return false;
            }
            // Sentinel = 'TOpUpdatedAsyncImagePipeline'
            if ((!((aMsg)->ReadSentinel(aIter, 456827427)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpUpdatedAsyncImagePipeline of union WebRenderParentCommand");
                return false;
            }
            return true;
        }
    case union__::TCompositableOperation:
        {
            mozilla::layers::CompositableOperation tmp = mozilla::layers::CompositableOperation();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_CompositableOperation())))))) {
                (aActor)->FatalError("Error deserializing variant TCompositableOperation of union WebRenderParentCommand");
                return false;
            }
            // Sentinel = 'TCompositableOperation'
            if ((!((aMsg)->ReadSentinel(aIter, 1903999853)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCompositableOperation of union WebRenderParentCommand");
                return false;
            }
            return true;
        }
    case union__::TOpAddCompositorAnimations:
        {
            mozilla::layers::OpAddCompositorAnimations tmp = mozilla::layers::OpAddCompositorAnimations();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpAddCompositorAnimations())))))) {
                (aActor)->FatalError("Error deserializing variant TOpAddCompositorAnimations of union WebRenderParentCommand");
                return false;
            }
            // Sentinel = 'TOpAddCompositorAnimations'
            if ((!((aMsg)->ReadSentinel(aIter, 3387367374)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpAddCompositorAnimations of union WebRenderParentCommand");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpAddImage|
//
namespace mozilla {
namespace layers {
auto OpAddImage::operator==(const OpAddImage& _o) const -> bool
{
    if ((!((descriptor()) == ((_o).descriptor())))) {
        return false;
    }
    if ((!((bytes()) == ((_o).bytes())))) {
        return false;
    }
    if ((!((tiling()) == ((_o).tiling())))) {
        return false;
    }
    if ((!((key()) == ((_o).key())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpAddImage>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).descriptor());
    // Sentinel = 'descriptor'
    (aMsg)->WriteSentinel(2435877233);
    WriteIPDLParam(aMsg, aActor, (aVar).bytes());
    // Sentinel = 'bytes'
    (aMsg)->WriteSentinel(836113516);
    WriteIPDLParam(aMsg, aActor, (aVar).tiling());
    // Sentinel = 'tiling'
    (aMsg)->WriteSentinel(2471974811);
    WriteIPDLParam(aMsg, aActor, (aVar).key());
    // Sentinel = 'key'
    (aMsg)->WriteSentinel(35142870);
}

auto IPDLParamTraits<mozilla::layers::OpAddImage>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->descriptor())))))) {
        (aActor)->FatalError("Error deserializing 'descriptor' (ImageDescriptor) member of 'OpAddImage'");
        return false;
    }
    // Sentinel = 'descriptor'
    if ((!((aMsg)->ReadSentinel(aIter, 2435877233)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'descriptor' (ImageDescriptor) member of 'OpAddImage'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->bytes())))))) {
        (aActor)->FatalError("Error deserializing 'bytes' (OffsetRange) member of 'OpAddImage'");
        return false;
    }
    // Sentinel = 'bytes'
    if ((!((aMsg)->ReadSentinel(aIter, 836113516)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bytes' (OffsetRange) member of 'OpAddImage'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->tiling())))))) {
        (aActor)->FatalError("Error deserializing 'tiling' (uint16_t) member of 'OpAddImage'");
        return false;
    }
    // Sentinel = 'tiling'
    if ((!((aMsg)->ReadSentinel(aIter, 2471974811)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'tiling' (uint16_t) member of 'OpAddImage'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->key())))))) {
        (aActor)->FatalError("Error deserializing 'key' (ImageKey) member of 'OpAddImage'");
        return false;
    }
    // Sentinel = 'key'
    if ((!((aMsg)->ReadSentinel(aIter, 35142870)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'key' (ImageKey) member of 'OpAddImage'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpAddBlobImage|
//
namespace mozilla {
namespace layers {
auto OpAddBlobImage::operator==(const OpAddBlobImage& _o) const -> bool
{
    if ((!((descriptor()) == ((_o).descriptor())))) {
        return false;
    }
    if ((!((bytes()) == ((_o).bytes())))) {
        return false;
    }
    if ((!((tiling()) == ((_o).tiling())))) {
        return false;
    }
    if ((!((key()) == ((_o).key())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpAddBlobImage>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).descriptor());
    // Sentinel = 'descriptor'
    (aMsg)->WriteSentinel(2435877233);
    WriteIPDLParam(aMsg, aActor, (aVar).bytes());
    // Sentinel = 'bytes'
    (aMsg)->WriteSentinel(836113516);
    WriteIPDLParam(aMsg, aActor, (aVar).tiling());
    // Sentinel = 'tiling'
    (aMsg)->WriteSentinel(2471974811);
    WriteIPDLParam(aMsg, aActor, (aVar).key());
    // Sentinel = 'key'
    (aMsg)->WriteSentinel(35142870);
}

auto IPDLParamTraits<mozilla::layers::OpAddBlobImage>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->descriptor())))))) {
        (aActor)->FatalError("Error deserializing 'descriptor' (ImageDescriptor) member of 'OpAddBlobImage'");
        return false;
    }
    // Sentinel = 'descriptor'
    if ((!((aMsg)->ReadSentinel(aIter, 2435877233)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'descriptor' (ImageDescriptor) member of 'OpAddBlobImage'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->bytes())))))) {
        (aActor)->FatalError("Error deserializing 'bytes' (OffsetRange) member of 'OpAddBlobImage'");
        return false;
    }
    // Sentinel = 'bytes'
    if ((!((aMsg)->ReadSentinel(aIter, 836113516)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bytes' (OffsetRange) member of 'OpAddBlobImage'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->tiling())))))) {
        (aActor)->FatalError("Error deserializing 'tiling' (uint16_t) member of 'OpAddBlobImage'");
        return false;
    }
    // Sentinel = 'tiling'
    if ((!((aMsg)->ReadSentinel(aIter, 2471974811)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'tiling' (uint16_t) member of 'OpAddBlobImage'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->key())))))) {
        (aActor)->FatalError("Error deserializing 'key' (ImageKey) member of 'OpAddBlobImage'");
        return false;
    }
    // Sentinel = 'key'
    if ((!((aMsg)->ReadSentinel(aIter, 35142870)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'key' (ImageKey) member of 'OpAddBlobImage'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpUpdateImage|
//
namespace mozilla {
namespace layers {
auto OpUpdateImage::operator==(const OpUpdateImage& _o) const -> bool
{
    if ((!((descriptor()) == ((_o).descriptor())))) {
        return false;
    }
    if ((!((bytes()) == ((_o).bytes())))) {
        return false;
    }
    if ((!((key()) == ((_o).key())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpUpdateImage>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).descriptor());
    // Sentinel = 'descriptor'
    (aMsg)->WriteSentinel(2435877233);
    WriteIPDLParam(aMsg, aActor, (aVar).bytes());
    // Sentinel = 'bytes'
    (aMsg)->WriteSentinel(836113516);
    WriteIPDLParam(aMsg, aActor, (aVar).key());
    // Sentinel = 'key'
    (aMsg)->WriteSentinel(35142870);
}

auto IPDLParamTraits<mozilla::layers::OpUpdateImage>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->descriptor())))))) {
        (aActor)->FatalError("Error deserializing 'descriptor' (ImageDescriptor) member of 'OpUpdateImage'");
        return false;
    }
    // Sentinel = 'descriptor'
    if ((!((aMsg)->ReadSentinel(aIter, 2435877233)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'descriptor' (ImageDescriptor) member of 'OpUpdateImage'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->bytes())))))) {
        (aActor)->FatalError("Error deserializing 'bytes' (OffsetRange) member of 'OpUpdateImage'");
        return false;
    }
    // Sentinel = 'bytes'
    if ((!((aMsg)->ReadSentinel(aIter, 836113516)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bytes' (OffsetRange) member of 'OpUpdateImage'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->key())))))) {
        (aActor)->FatalError("Error deserializing 'key' (ImageKey) member of 'OpUpdateImage'");
        return false;
    }
    // Sentinel = 'key'
    if ((!((aMsg)->ReadSentinel(aIter, 35142870)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'key' (ImageKey) member of 'OpUpdateImage'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpUpdateBlobImage|
//
namespace mozilla {
namespace layers {
auto OpUpdateBlobImage::operator==(const OpUpdateBlobImage& _o) const -> bool
{
    if ((!((descriptor()) == ((_o).descriptor())))) {
        return false;
    }
    if ((!((bytes()) == ((_o).bytes())))) {
        return false;
    }
    if ((!((key()) == ((_o).key())))) {
        return false;
    }
    if ((!((dirtyRect()) == ((_o).dirtyRect())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpUpdateBlobImage>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).descriptor());
    // Sentinel = 'descriptor'
    (aMsg)->WriteSentinel(2435877233);
    WriteIPDLParam(aMsg, aActor, (aVar).bytes());
    // Sentinel = 'bytes'
    (aMsg)->WriteSentinel(836113516);
    WriteIPDLParam(aMsg, aActor, (aVar).key());
    // Sentinel = 'key'
    (aMsg)->WriteSentinel(35142870);
    WriteIPDLParam(aMsg, aActor, (aVar).dirtyRect());
    // Sentinel = 'dirtyRect'
    (aMsg)->WriteSentinel(1726016483);
}

auto IPDLParamTraits<mozilla::layers::OpUpdateBlobImage>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->descriptor())))))) {
        (aActor)->FatalError("Error deserializing 'descriptor' (ImageDescriptor) member of 'OpUpdateBlobImage'");
        return false;
    }
    // Sentinel = 'descriptor'
    if ((!((aMsg)->ReadSentinel(aIter, 2435877233)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'descriptor' (ImageDescriptor) member of 'OpUpdateBlobImage'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->bytes())))))) {
        (aActor)->FatalError("Error deserializing 'bytes' (OffsetRange) member of 'OpUpdateBlobImage'");
        return false;
    }
    // Sentinel = 'bytes'
    if ((!((aMsg)->ReadSentinel(aIter, 836113516)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bytes' (OffsetRange) member of 'OpUpdateBlobImage'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->key())))))) {
        (aActor)->FatalError("Error deserializing 'key' (ImageKey) member of 'OpUpdateBlobImage'");
        return false;
    }
    // Sentinel = 'key'
    if ((!((aMsg)->ReadSentinel(aIter, 35142870)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'key' (ImageKey) member of 'OpUpdateBlobImage'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->dirtyRect())))))) {
        (aActor)->FatalError("Error deserializing 'dirtyRect' (ImageIntRect) member of 'OpUpdateBlobImage'");
        return false;
    }
    // Sentinel = 'dirtyRect'
    if ((!((aMsg)->ReadSentinel(aIter, 1726016483)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'dirtyRect' (ImageIntRect) member of 'OpUpdateBlobImage'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpSetImageVisibleArea>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).area());
    // Sentinel = 'area'
    (aMsg)->WriteSentinel(2825760551);
    WriteIPDLParam(aMsg, aActor, (aVar).key());
    // Sentinel = 'key'
    (aMsg)->WriteSentinel(35142870);
}

auto IPDLParamTraits<mozilla::layers::OpSetImageVisibleArea>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->area())))))) {
        (aActor)->FatalError("Error deserializing 'area' (Rect) member of 'OpSetImageVisibleArea'");
        return false;
    }
    // Sentinel = 'area'
    if ((!((aMsg)->ReadSentinel(aIter, 2825760551)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'area' (Rect) member of 'OpSetImageVisibleArea'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->key())))))) {
        (aActor)->FatalError("Error deserializing 'key' (ImageKey) member of 'OpSetImageVisibleArea'");
        return false;
    }
    // Sentinel = 'key'
    if ((!((aMsg)->ReadSentinel(aIter, 35142870)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'key' (ImageKey) member of 'OpSetImageVisibleArea'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpUpdateExternalImage|
//
namespace mozilla {
namespace layers {
auto OpUpdateExternalImage::operator==(const OpUpdateExternalImage& _o) const -> bool
{
    if ((!((externalImageId()) == ((_o).externalImageId())))) {
        return false;
    }
    if ((!((key()) == ((_o).key())))) {
        return false;
    }
    if ((!((dirtyRect()) == ((_o).dirtyRect())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpUpdateExternalImage>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).externalImageId());
    // Sentinel = 'externalImageId'
    (aMsg)->WriteSentinel(2839682692);
    WriteIPDLParam(aMsg, aActor, (aVar).key());
    // Sentinel = 'key'
    (aMsg)->WriteSentinel(35142870);
    WriteIPDLParam(aMsg, aActor, (aVar).dirtyRect());
    // Sentinel = 'dirtyRect'
    (aMsg)->WriteSentinel(1726016483);
}

auto IPDLParamTraits<mozilla::layers::OpUpdateExternalImage>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->externalImageId())))))) {
        (aActor)->FatalError("Error deserializing 'externalImageId' (ExternalImageId) member of 'OpUpdateExternalImage'");
        return false;
    }
    // Sentinel = 'externalImageId'
    if ((!((aMsg)->ReadSentinel(aIter, 2839682692)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'externalImageId' (ExternalImageId) member of 'OpUpdateExternalImage'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->key())))))) {
        (aActor)->FatalError("Error deserializing 'key' (ImageKey) member of 'OpUpdateExternalImage'");
        return false;
    }
    // Sentinel = 'key'
    if ((!((aMsg)->ReadSentinel(aIter, 35142870)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'key' (ImageKey) member of 'OpUpdateExternalImage'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->dirtyRect())))))) {
        (aActor)->FatalError("Error deserializing 'dirtyRect' (ImageIntRect) member of 'OpUpdateExternalImage'");
        return false;
    }
    // Sentinel = 'dirtyRect'
    if ((!((aMsg)->ReadSentinel(aIter, 1726016483)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'dirtyRect' (ImageIntRect) member of 'OpUpdateExternalImage'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpDeleteImage>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).key());
    // Sentinel = 'key'
    (aMsg)->WriteSentinel(35142870);
}

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpAddRawFont|
//
namespace mozilla {
namespace layers {
auto OpAddRawFont::operator==(const OpAddRawFont& _o) const -> bool
{
    if ((!((bytes()) == ((_o).bytes())))) {
        return false;
    }
    if ((!((fontIndex()) == ((_o).fontIndex())))) {
        return false;
    }
    if ((!((key()) == ((_o).key())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpAddRawFont>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).bytes());
    // Sentinel = 'bytes'
    (aMsg)->WriteSentinel(836113516);
    WriteIPDLParam(aMsg, aActor, (aVar).fontIndex());
    // Sentinel = 'fontIndex'
    (aMsg)->WriteSentinel(403185800);
    WriteIPDLParam(aMsg, aActor, (aVar).key());
    // Sentinel = 'key'
    (aMsg)->WriteSentinel(35142870);
}

auto IPDLParamTraits<mozilla::layers::OpAddRawFont>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->bytes())))))) {
        (aActor)->FatalError("Error deserializing 'bytes' (OffsetRange) member of 'OpAddRawFont'");
        return false;
    }
    // Sentinel = 'bytes'
    if ((!((aMsg)->ReadSentinel(aIter, 836113516)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bytes' (OffsetRange) member of 'OpAddRawFont'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->fontIndex())))))) {
        (aActor)->FatalError("Error deserializing 'fontIndex' (uint32_t) member of 'OpAddRawFont'");
        return false;
    }
    // Sentinel = 'fontIndex'
    if ((!((aMsg)->ReadSentinel(aIter, 403185800)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fontIndex' (uint32_t) member of 'OpAddRawFont'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->key())))))) {
        (aActor)->FatalError("Error deserializing 'key' (FontKey) member of 'OpAddRawFont'");
        return false;
    }
    // Sentinel = 'key'
    if ((!((aMsg)->ReadSentinel(aIter, 35142870)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'key' (FontKey) member of 'OpAddRawFont'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpAddFontDescriptor|
//
namespace mozilla {
namespace layers {
auto OpAddFontDescriptor::operator==(const OpAddFontDescriptor& _o) const -> bool
{
    if ((!((bytes()) == ((_o).bytes())))) {
        return false;
    }
    if ((!((fontIndex()) == ((_o).fontIndex())))) {
        return false;
    }
    if ((!((key()) == ((_o).key())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpAddFontDescriptor>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).bytes());
    // Sentinel = 'bytes'
    (aMsg)->WriteSentinel(836113516);
    WriteIPDLParam(aMsg, aActor, (aVar).fontIndex());
    // Sentinel = 'fontIndex'
    (aMsg)->WriteSentinel(403185800);
    WriteIPDLParam(aMsg, aActor, (aVar).key());
    // Sentinel = 'key'
    (aMsg)->WriteSentinel(35142870);
}

auto IPDLParamTraits<mozilla::layers::OpAddFontDescriptor>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->bytes())))))) {
        (aActor)->FatalError("Error deserializing 'bytes' (OffsetRange) member of 'OpAddFontDescriptor'");
        return false;
    }
    // Sentinel = 'bytes'
    if ((!((aMsg)->ReadSentinel(aIter, 836113516)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bytes' (OffsetRange) member of 'OpAddFontDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->fontIndex())))))) {
        (aActor)->FatalError("Error deserializing 'fontIndex' (uint32_t) member of 'OpAddFontDescriptor'");
        return false;
    }
    // Sentinel = 'fontIndex'
    if ((!((aMsg)->ReadSentinel(aIter, 403185800)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fontIndex' (uint32_t) member of 'OpAddFontDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->key())))))) {
        (aActor)->FatalError("Error deserializing 'key' (FontKey) member of 'OpAddFontDescriptor'");
        return false;
    }
    // Sentinel = 'key'
    if ((!((aMsg)->ReadSentinel(aIter, 35142870)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'key' (FontKey) member of 'OpAddFontDescriptor'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpDeleteFont>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).key());
    // Sentinel = 'key'
    (aMsg)->WriteSentinel(35142870);
}

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpAddFontInstance|
//
namespace mozilla {
namespace layers {
auto OpAddFontInstance::operator==(const OpAddFontInstance& _o) const -> bool
{
    if ((!((options()) == ((_o).options())))) {
        return false;
    }
    if ((!((platformOptions()) == ((_o).platformOptions())))) {
        return false;
    }
    if ((!((variations()) == ((_o).variations())))) {
        return false;
    }
    if ((!((instanceKey()) == ((_o).instanceKey())))) {
        return false;
    }
    if ((!((fontKey()) == ((_o).fontKey())))) {
        return false;
    }
    if ((!((glyphSize()) == ((_o).glyphSize())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpAddFontInstance>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).options());
    // Sentinel = 'options'
    (aMsg)->WriteSentinel(33222909);
    WriteIPDLParam(aMsg, aActor, (aVar).platformOptions());
    // Sentinel = 'platformOptions'
    (aMsg)->WriteSentinel(2782091946);
    WriteIPDLParam(aMsg, aActor, (aVar).variations());
    // Sentinel = 'variations'
    (aMsg)->WriteSentinel(246079340);
    WriteIPDLParam(aMsg, aActor, (aVar).instanceKey());
    // Sentinel = 'instanceKey'
    (aMsg)->WriteSentinel(430968381);
    WriteIPDLParam(aMsg, aActor, (aVar).fontKey());
    // Sentinel = 'fontKey'
    (aMsg)->WriteSentinel(727843339);
    WriteIPDLParam(aMsg, aActor, (aVar).glyphSize());
    // Sentinel = 'glyphSize'
    (aMsg)->WriteSentinel(2169533804);
}

auto IPDLParamTraits<mozilla::layers::OpAddFontInstance>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->options())))))) {
        (aActor)->FatalError("Error deserializing 'options' (MaybeFontInstanceOptions) member of 'OpAddFontInstance'");
        return false;
    }
    // Sentinel = 'options'
    if ((!((aMsg)->ReadSentinel(aIter, 33222909)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'options' (MaybeFontInstanceOptions) member of 'OpAddFontInstance'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->platformOptions())))))) {
        (aActor)->FatalError("Error deserializing 'platformOptions' (MaybeFontInstancePlatformOptions) member of 'OpAddFontInstance'");
        return false;
    }
    // Sentinel = 'platformOptions'
    if ((!((aMsg)->ReadSentinel(aIter, 2782091946)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'platformOptions' (MaybeFontInstancePlatformOptions) member of 'OpAddFontInstance'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->variations())))))) {
        (aActor)->FatalError("Error deserializing 'variations' (OffsetRange) member of 'OpAddFontInstance'");
        return false;
    }
    // Sentinel = 'variations'
    if ((!((aMsg)->ReadSentinel(aIter, 246079340)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'variations' (OffsetRange) member of 'OpAddFontInstance'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->instanceKey())))))) {
        (aActor)->FatalError("Error deserializing 'instanceKey' (FontInstanceKey) member of 'OpAddFontInstance'");
        return false;
    }
    // Sentinel = 'instanceKey'
    if ((!((aMsg)->ReadSentinel(aIter, 430968381)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'instanceKey' (FontInstanceKey) member of 'OpAddFontInstance'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->fontKey())))))) {
        (aActor)->FatalError("Error deserializing 'fontKey' (FontKey) member of 'OpAddFontInstance'");
        return false;
    }
    // Sentinel = 'fontKey'
    if ((!((aMsg)->ReadSentinel(aIter, 727843339)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fontKey' (FontKey) member of 'OpAddFontInstance'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->glyphSize())))))) {
        (aActor)->FatalError("Error deserializing 'glyphSize' (float) member of 'OpAddFontInstance'");
        return false;
    }
    // Sentinel = 'glyphSize'
    if ((!((aMsg)->ReadSentinel(aIter, 2169533804)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'glyphSize' (float) member of 'OpAddFontInstance'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpDeleteFontInstance>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).key());
    // Sentinel = 'key'
    (aMsg)->WriteSentinel(35142870);
}

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union OpUpdateResource|
//
namespace mozilla {
namespace layers {
auto OpUpdateResource::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TOpAddImage:
        {
            (ptr_OpAddImage())->~OpAddImage__tdef();
            break;
        }
    case TOpAddBlobImage:
        {
            (ptr_OpAddBlobImage())->~OpAddBlobImage__tdef();
            break;
        }
    case TOpUpdateImage:
        {
            (ptr_OpUpdateImage())->~OpUpdateImage__tdef();
            break;
        }
    case TOpUpdateBlobImage:
        {
            (ptr_OpUpdateBlobImage())->~OpUpdateBlobImage__tdef();
            break;
        }
    case TOpSetImageVisibleArea:
        {
            (ptr_OpSetImageVisibleArea())->~OpSetImageVisibleArea__tdef();
            break;
        }
    case TOpDeleteImage:
        {
            (ptr_OpDeleteImage())->~OpDeleteImage__tdef();
            break;
        }
    case TOpAddRawFont:
        {
            (ptr_OpAddRawFont())->~OpAddRawFont__tdef();
            break;
        }
    case TOpAddFontDescriptor:
        {
            (ptr_OpAddFontDescriptor())->~OpAddFontDescriptor__tdef();
            break;
        }
    case TOpDeleteFont:
        {
            (ptr_OpDeleteFont())->~OpDeleteFont__tdef();
            break;
        }
    case TOpAddFontInstance:
        {
            (ptr_OpAddFontInstance())->~OpAddFontInstance__tdef();
            break;
        }
    case TOpDeleteFontInstance:
        {
            (ptr_OpDeleteFontInstance())->~OpDeleteFontInstance__tdef();
            break;
        }
    case TOpAddExternalImage:
        {
            (ptr_OpAddExternalImage())->~OpAddExternalImage__tdef();
            break;
        }
    case TOpPushExternalImageForTexture:
        {
            (ptr_OpPushExternalImageForTexture())->~OpPushExternalImageForTexture__tdef();
            break;
        }
    case TOpUpdateExternalImage:
        {
            (ptr_OpUpdateExternalImage())->~OpUpdateExternalImage__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpAddImage& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddImage()) OpAddImage(aOther);
    mType = TOpAddImage;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpAddImage&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddImage()) OpAddImage(std::move(aOther));
    mType = TOpAddImage;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpAddBlobImage& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddBlobImage()) OpAddBlobImage(aOther);
    mType = TOpAddBlobImage;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpAddBlobImage&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddBlobImage()) OpAddBlobImage(std::move(aOther));
    mType = TOpAddBlobImage;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpUpdateImage& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUpdateImage()) OpUpdateImage(aOther);
    mType = TOpUpdateImage;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpUpdateImage&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUpdateImage()) OpUpdateImage(std::move(aOther));
    mType = TOpUpdateImage;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpUpdateBlobImage& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUpdateBlobImage()) OpUpdateBlobImage(aOther);
    mType = TOpUpdateBlobImage;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpUpdateBlobImage&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUpdateBlobImage()) OpUpdateBlobImage(std::move(aOther));
    mType = TOpUpdateBlobImage;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpSetImageVisibleArea& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpSetImageVisibleArea()) OpSetImageVisibleArea(aOther);
    mType = TOpSetImageVisibleArea;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpSetImageVisibleArea&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpSetImageVisibleArea()) OpSetImageVisibleArea(std::move(aOther));
    mType = TOpSetImageVisibleArea;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpDeleteImage& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpDeleteImage()) OpDeleteImage(aOther);
    mType = TOpDeleteImage;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpDeleteImage&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpDeleteImage()) OpDeleteImage(std::move(aOther));
    mType = TOpDeleteImage;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpAddRawFont& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddRawFont()) OpAddRawFont(aOther);
    mType = TOpAddRawFont;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpAddRawFont&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddRawFont()) OpAddRawFont(std::move(aOther));
    mType = TOpAddRawFont;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpAddFontDescriptor& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddFontDescriptor()) OpAddFontDescriptor(aOther);
    mType = TOpAddFontDescriptor;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpAddFontDescriptor&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddFontDescriptor()) OpAddFontDescriptor(std::move(aOther));
    mType = TOpAddFontDescriptor;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpDeleteFont& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpDeleteFont()) OpDeleteFont(aOther);
    mType = TOpDeleteFont;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpDeleteFont&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpDeleteFont()) OpDeleteFont(std::move(aOther));
    mType = TOpDeleteFont;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpAddFontInstance& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddFontInstance()) OpAddFontInstance(aOther);
    mType = TOpAddFontInstance;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpAddFontInstance&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddFontInstance()) OpAddFontInstance(std::move(aOther));
    mType = TOpAddFontInstance;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpDeleteFontInstance& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpDeleteFontInstance()) OpDeleteFontInstance(aOther);
    mType = TOpDeleteFontInstance;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpDeleteFontInstance&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpDeleteFontInstance()) OpDeleteFontInstance(std::move(aOther));
    mType = TOpDeleteFontInstance;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpAddExternalImage& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddExternalImage()) OpAddExternalImage(aOther);
    mType = TOpAddExternalImage;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpAddExternalImage&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAddExternalImage()) OpAddExternalImage(std::move(aOther));
    mType = TOpAddExternalImage;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpPushExternalImageForTexture& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpPushExternalImageForTexture()) OpPushExternalImageForTexture(aOther);
    mType = TOpPushExternalImageForTexture;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpPushExternalImageForTexture&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpPushExternalImageForTexture()) OpPushExternalImageForTexture(std::move(aOther));
    mType = TOpPushExternalImageForTexture;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpUpdateExternalImage& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUpdateExternalImage()) OpUpdateExternalImage(aOther);
    mType = TOpUpdateExternalImage;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpUpdateExternalImage&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUpdateExternalImage()) OpUpdateExternalImage(std::move(aOther));
    mType = TOpUpdateExternalImage;
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(const OpUpdateResource& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TOpAddImage:
        {
            new (mozilla::KnownNotNull, ptr_OpAddImage()) OpAddImage((aOther).get_OpAddImage());
            break;
        }
    case TOpAddBlobImage:
        {
            new (mozilla::KnownNotNull, ptr_OpAddBlobImage()) OpAddBlobImage((aOther).get_OpAddBlobImage());
            break;
        }
    case TOpUpdateImage:
        {
            new (mozilla::KnownNotNull, ptr_OpUpdateImage()) OpUpdateImage((aOther).get_OpUpdateImage());
            break;
        }
    case TOpUpdateBlobImage:
        {
            new (mozilla::KnownNotNull, ptr_OpUpdateBlobImage()) OpUpdateBlobImage((aOther).get_OpUpdateBlobImage());
            break;
        }
    case TOpSetImageVisibleArea:
        {
            new (mozilla::KnownNotNull, ptr_OpSetImageVisibleArea()) OpSetImageVisibleArea((aOther).get_OpSetImageVisibleArea());
            break;
        }
    case TOpDeleteImage:
        {
            new (mozilla::KnownNotNull, ptr_OpDeleteImage()) OpDeleteImage((aOther).get_OpDeleteImage());
            break;
        }
    case TOpAddRawFont:
        {
            new (mozilla::KnownNotNull, ptr_OpAddRawFont()) OpAddRawFont((aOther).get_OpAddRawFont());
            break;
        }
    case TOpAddFontDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_OpAddFontDescriptor()) OpAddFontDescriptor((aOther).get_OpAddFontDescriptor());
            break;
        }
    case TOpDeleteFont:
        {
            new (mozilla::KnownNotNull, ptr_OpDeleteFont()) OpDeleteFont((aOther).get_OpDeleteFont());
            break;
        }
    case TOpAddFontInstance:
        {
            new (mozilla::KnownNotNull, ptr_OpAddFontInstance()) OpAddFontInstance((aOther).get_OpAddFontInstance());
            break;
        }
    case TOpDeleteFontInstance:
        {
            new (mozilla::KnownNotNull, ptr_OpDeleteFontInstance()) OpDeleteFontInstance((aOther).get_OpDeleteFontInstance());
            break;
        }
    case TOpAddExternalImage:
        {
            new (mozilla::KnownNotNull, ptr_OpAddExternalImage()) OpAddExternalImage((aOther).get_OpAddExternalImage());
            break;
        }
    case TOpPushExternalImageForTexture:
        {
            new (mozilla::KnownNotNull, ptr_OpPushExternalImageForTexture()) OpPushExternalImageForTexture((aOther).get_OpPushExternalImageForTexture());
            break;
        }
    case TOpUpdateExternalImage:
        {
            new (mozilla::KnownNotNull, ptr_OpUpdateExternalImage()) OpUpdateExternalImage((aOther).get_OpUpdateExternalImage());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT OpUpdateResource::OpUpdateResource(OpUpdateResource&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TOpAddImage:
        {
            new (mozilla::KnownNotNull, ptr_OpAddImage()) OpAddImage(std::move((aOther).get_OpAddImage()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpAddBlobImage:
        {
            new (mozilla::KnownNotNull, ptr_OpAddBlobImage()) OpAddBlobImage(std::move((aOther).get_OpAddBlobImage()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpUpdateImage:
        {
            new (mozilla::KnownNotNull, ptr_OpUpdateImage()) OpUpdateImage(std::move((aOther).get_OpUpdateImage()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpUpdateBlobImage:
        {
            new (mozilla::KnownNotNull, ptr_OpUpdateBlobImage()) OpUpdateBlobImage(std::move((aOther).get_OpUpdateBlobImage()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpSetImageVisibleArea:
        {
            new (mozilla::KnownNotNull, ptr_OpSetImageVisibleArea()) OpSetImageVisibleArea(std::move((aOther).get_OpSetImageVisibleArea()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpDeleteImage:
        {
            new (mozilla::KnownNotNull, ptr_OpDeleteImage()) OpDeleteImage(std::move((aOther).get_OpDeleteImage()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpAddRawFont:
        {
            new (mozilla::KnownNotNull, ptr_OpAddRawFont()) OpAddRawFont(std::move((aOther).get_OpAddRawFont()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpAddFontDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_OpAddFontDescriptor()) OpAddFontDescriptor(std::move((aOther).get_OpAddFontDescriptor()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpDeleteFont:
        {
            new (mozilla::KnownNotNull, ptr_OpDeleteFont()) OpDeleteFont(std::move((aOther).get_OpDeleteFont()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpAddFontInstance:
        {
            new (mozilla::KnownNotNull, ptr_OpAddFontInstance()) OpAddFontInstance(std::move((aOther).get_OpAddFontInstance()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpDeleteFontInstance:
        {
            new (mozilla::KnownNotNull, ptr_OpDeleteFontInstance()) OpDeleteFontInstance(std::move((aOther).get_OpDeleteFontInstance()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpAddExternalImage:
        {
            new (mozilla::KnownNotNull, ptr_OpAddExternalImage()) OpAddExternalImage(std::move((aOther).get_OpAddExternalImage()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpPushExternalImageForTexture:
        {
            new (mozilla::KnownNotNull, ptr_OpPushExternalImageForTexture()) OpPushExternalImageForTexture(std::move((aOther).get_OpPushExternalImageForTexture()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpUpdateExternalImage:
        {
            new (mozilla::KnownNotNull, ptr_OpUpdateExternalImage()) OpUpdateExternalImage(std::move((aOther).get_OpUpdateExternalImage()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto OpUpdateResource::operator=(const OpAddImage& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpAddImage)) {
        new (mozilla::KnownNotNull, ptr_OpAddImage()) OpAddImage;
    }
    (*(ptr_OpAddImage())) = aRhs;
    mType = TOpAddImage;
    return (*(this));
}

auto OpUpdateResource::operator=(OpAddImage&& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpAddImage)) {
        new (mozilla::KnownNotNull, ptr_OpAddImage()) OpAddImage;
    }
    (*(ptr_OpAddImage())) = std::move(aRhs);
    mType = TOpAddImage;
    return (*(this));
}

auto OpUpdateResource::operator=(const OpAddBlobImage& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpAddBlobImage)) {
        new (mozilla::KnownNotNull, ptr_OpAddBlobImage()) OpAddBlobImage;
    }
    (*(ptr_OpAddBlobImage())) = aRhs;
    mType = TOpAddBlobImage;
    return (*(this));
}

auto OpUpdateResource::operator=(OpAddBlobImage&& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpAddBlobImage)) {
        new (mozilla::KnownNotNull, ptr_OpAddBlobImage()) OpAddBlobImage;
    }
    (*(ptr_OpAddBlobImage())) = std::move(aRhs);
    mType = TOpAddBlobImage;
    return (*(this));
}

auto OpUpdateResource::operator=(const OpUpdateImage& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpUpdateImage)) {
        new (mozilla::KnownNotNull, ptr_OpUpdateImage()) OpUpdateImage;
    }
    (*(ptr_OpUpdateImage())) = aRhs;
    mType = TOpUpdateImage;
    return (*(this));
}

auto OpUpdateResource::operator=(OpUpdateImage&& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpUpdateImage)) {
        new (mozilla::KnownNotNull, ptr_OpUpdateImage()) OpUpdateImage;
    }
    (*(ptr_OpUpdateImage())) = std::move(aRhs);
    mType = TOpUpdateImage;
    return (*(this));
}

auto OpUpdateResource::operator=(const OpUpdateBlobImage& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpUpdateBlobImage)) {
        new (mozilla::KnownNotNull, ptr_OpUpdateBlobImage()) OpUpdateBlobImage;
    }
    (*(ptr_OpUpdateBlobImage())) = aRhs;
    mType = TOpUpdateBlobImage;
    return (*(this));
}

auto OpUpdateResource::operator=(OpUpdateBlobImage&& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpUpdateBlobImage)) {
        new (mozilla::KnownNotNull, ptr_OpUpdateBlobImage()) OpUpdateBlobImage;
    }
    (*(ptr_OpUpdateBlobImage())) = std::move(aRhs);
    mType = TOpUpdateBlobImage;
    return (*(this));
}

auto OpUpdateResource::operator=(const OpSetImageVisibleArea& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpSetImageVisibleArea)) {
        new (mozilla::KnownNotNull, ptr_OpSetImageVisibleArea()) OpSetImageVisibleArea;
    }
    (*(ptr_OpSetImageVisibleArea())) = aRhs;
    mType = TOpSetImageVisibleArea;
    return (*(this));
}

auto OpUpdateResource::operator=(OpSetImageVisibleArea&& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpSetImageVisibleArea)) {
        new (mozilla::KnownNotNull, ptr_OpSetImageVisibleArea()) OpSetImageVisibleArea;
    }
    (*(ptr_OpSetImageVisibleArea())) = std::move(aRhs);
    mType = TOpSetImageVisibleArea;
    return (*(this));
}

auto OpUpdateResource::operator=(const OpDeleteImage& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpDeleteImage)) {
        new (mozilla::KnownNotNull, ptr_OpDeleteImage()) OpDeleteImage;
    }
    (*(ptr_OpDeleteImage())) = aRhs;
    mType = TOpDeleteImage;
    return (*(this));
}

auto OpUpdateResource::operator=(OpDeleteImage&& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpDeleteImage)) {
        new (mozilla::KnownNotNull, ptr_OpDeleteImage()) OpDeleteImage;
    }
    (*(ptr_OpDeleteImage())) = std::move(aRhs);
    mType = TOpDeleteImage;
    return (*(this));
}

auto OpUpdateResource::operator=(const OpAddRawFont& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpAddRawFont)) {
        new (mozilla::KnownNotNull, ptr_OpAddRawFont()) OpAddRawFont;
    }
    (*(ptr_OpAddRawFont())) = aRhs;
    mType = TOpAddRawFont;
    return (*(this));
}

auto OpUpdateResource::operator=(OpAddRawFont&& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpAddRawFont)) {
        new (mozilla::KnownNotNull, ptr_OpAddRawFont()) OpAddRawFont;
    }
    (*(ptr_OpAddRawFont())) = std::move(aRhs);
    mType = TOpAddRawFont;
    return (*(this));
}

auto OpUpdateResource::operator=(const OpAddFontDescriptor& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpAddFontDescriptor)) {
        new (mozilla::KnownNotNull, ptr_OpAddFontDescriptor()) OpAddFontDescriptor;
    }
    (*(ptr_OpAddFontDescriptor())) = aRhs;
    mType = TOpAddFontDescriptor;
    return (*(this));
}

auto OpUpdateResource::operator=(OpAddFontDescriptor&& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpAddFontDescriptor)) {
        new (mozilla::KnownNotNull, ptr_OpAddFontDescriptor()) OpAddFontDescriptor;
    }
    (*(ptr_OpAddFontDescriptor())) = std::move(aRhs);
    mType = TOpAddFontDescriptor;
    return (*(this));
}

auto OpUpdateResource::operator=(const OpDeleteFont& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpDeleteFont)) {
        new (mozilla::KnownNotNull, ptr_OpDeleteFont()) OpDeleteFont;
    }
    (*(ptr_OpDeleteFont())) = aRhs;
    mType = TOpDeleteFont;
    return (*(this));
}

auto OpUpdateResource::operator=(OpDeleteFont&& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpDeleteFont)) {
        new (mozilla::KnownNotNull, ptr_OpDeleteFont()) OpDeleteFont;
    }
    (*(ptr_OpDeleteFont())) = std::move(aRhs);
    mType = TOpDeleteFont;
    return (*(this));
}

auto OpUpdateResource::operator=(const OpAddFontInstance& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpAddFontInstance)) {
        new (mozilla::KnownNotNull, ptr_OpAddFontInstance()) OpAddFontInstance;
    }
    (*(ptr_OpAddFontInstance())) = aRhs;
    mType = TOpAddFontInstance;
    return (*(this));
}

auto OpUpdateResource::operator=(OpAddFontInstance&& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpAddFontInstance)) {
        new (mozilla::KnownNotNull, ptr_OpAddFontInstance()) OpAddFontInstance;
    }
    (*(ptr_OpAddFontInstance())) = std::move(aRhs);
    mType = TOpAddFontInstance;
    return (*(this));
}

auto OpUpdateResource::operator=(const OpDeleteFontInstance& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpDeleteFontInstance)) {
        new (mozilla::KnownNotNull, ptr_OpDeleteFontInstance()) OpDeleteFontInstance;
    }
    (*(ptr_OpDeleteFontInstance())) = aRhs;
    mType = TOpDeleteFontInstance;
    return (*(this));
}

auto OpUpdateResource::operator=(OpDeleteFontInstance&& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpDeleteFontInstance)) {
        new (mozilla::KnownNotNull, ptr_OpDeleteFontInstance()) OpDeleteFontInstance;
    }
    (*(ptr_OpDeleteFontInstance())) = std::move(aRhs);
    mType = TOpDeleteFontInstance;
    return (*(this));
}

auto OpUpdateResource::operator=(const OpAddExternalImage& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpAddExternalImage)) {
        new (mozilla::KnownNotNull, ptr_OpAddExternalImage()) OpAddExternalImage;
    }
    (*(ptr_OpAddExternalImage())) = aRhs;
    mType = TOpAddExternalImage;
    return (*(this));
}

auto OpUpdateResource::operator=(OpAddExternalImage&& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpAddExternalImage)) {
        new (mozilla::KnownNotNull, ptr_OpAddExternalImage()) OpAddExternalImage;
    }
    (*(ptr_OpAddExternalImage())) = std::move(aRhs);
    mType = TOpAddExternalImage;
    return (*(this));
}

auto OpUpdateResource::operator=(const OpPushExternalImageForTexture& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpPushExternalImageForTexture)) {
        new (mozilla::KnownNotNull, ptr_OpPushExternalImageForTexture()) OpPushExternalImageForTexture;
    }
    (*(ptr_OpPushExternalImageForTexture())) = aRhs;
    mType = TOpPushExternalImageForTexture;
    return (*(this));
}

auto OpUpdateResource::operator=(OpPushExternalImageForTexture&& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpPushExternalImageForTexture)) {
        new (mozilla::KnownNotNull, ptr_OpPushExternalImageForTexture()) OpPushExternalImageForTexture;
    }
    (*(ptr_OpPushExternalImageForTexture())) = std::move(aRhs);
    mType = TOpPushExternalImageForTexture;
    return (*(this));
}

auto OpUpdateResource::operator=(const OpUpdateExternalImage& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpUpdateExternalImage)) {
        new (mozilla::KnownNotNull, ptr_OpUpdateExternalImage()) OpUpdateExternalImage;
    }
    (*(ptr_OpUpdateExternalImage())) = aRhs;
    mType = TOpUpdateExternalImage;
    return (*(this));
}

auto OpUpdateResource::operator=(OpUpdateExternalImage&& aRhs) -> OpUpdateResource&
{
    if (MaybeDestroy(TOpUpdateExternalImage)) {
        new (mozilla::KnownNotNull, ptr_OpUpdateExternalImage()) OpUpdateExternalImage;
    }
    (*(ptr_OpUpdateExternalImage())) = std::move(aRhs);
    mType = TOpUpdateExternalImage;
    return (*(this));
}

auto OpUpdateResource::operator=(const OpUpdateResource& aRhs) -> OpUpdateResource&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TOpAddImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddImage()) OpAddImage;
            }
            (*(ptr_OpAddImage())) = (aRhs).get_OpAddImage();
            break;
        }
    case TOpAddBlobImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddBlobImage()) OpAddBlobImage;
            }
            (*(ptr_OpAddBlobImage())) = (aRhs).get_OpAddBlobImage();
            break;
        }
    case TOpUpdateImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUpdateImage()) OpUpdateImage;
            }
            (*(ptr_OpUpdateImage())) = (aRhs).get_OpUpdateImage();
            break;
        }
    case TOpUpdateBlobImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUpdateBlobImage()) OpUpdateBlobImage;
            }
            (*(ptr_OpUpdateBlobImage())) = (aRhs).get_OpUpdateBlobImage();
            break;
        }
    case TOpSetImageVisibleArea:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpSetImageVisibleArea()) OpSetImageVisibleArea;
            }
            (*(ptr_OpSetImageVisibleArea())) = (aRhs).get_OpSetImageVisibleArea();
            break;
        }
    case TOpDeleteImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpDeleteImage()) OpDeleteImage;
            }
            (*(ptr_OpDeleteImage())) = (aRhs).get_OpDeleteImage();
            break;
        }
    case TOpAddRawFont:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddRawFont()) OpAddRawFont;
            }
            (*(ptr_OpAddRawFont())) = (aRhs).get_OpAddRawFont();
            break;
        }
    case TOpAddFontDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddFontDescriptor()) OpAddFontDescriptor;
            }
            (*(ptr_OpAddFontDescriptor())) = (aRhs).get_OpAddFontDescriptor();
            break;
        }
    case TOpDeleteFont:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpDeleteFont()) OpDeleteFont;
            }
            (*(ptr_OpDeleteFont())) = (aRhs).get_OpDeleteFont();
            break;
        }
    case TOpAddFontInstance:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddFontInstance()) OpAddFontInstance;
            }
            (*(ptr_OpAddFontInstance())) = (aRhs).get_OpAddFontInstance();
            break;
        }
    case TOpDeleteFontInstance:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpDeleteFontInstance()) OpDeleteFontInstance;
            }
            (*(ptr_OpDeleteFontInstance())) = (aRhs).get_OpDeleteFontInstance();
            break;
        }
    case TOpAddExternalImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddExternalImage()) OpAddExternalImage;
            }
            (*(ptr_OpAddExternalImage())) = (aRhs).get_OpAddExternalImage();
            break;
        }
    case TOpPushExternalImageForTexture:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpPushExternalImageForTexture()) OpPushExternalImageForTexture;
            }
            (*(ptr_OpPushExternalImageForTexture())) = (aRhs).get_OpPushExternalImageForTexture();
            break;
        }
    case TOpUpdateExternalImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUpdateExternalImage()) OpUpdateExternalImage;
            }
            (*(ptr_OpUpdateExternalImage())) = (aRhs).get_OpUpdateExternalImage();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto OpUpdateResource::operator=(OpUpdateResource&& aRhs) -> OpUpdateResource&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TOpAddImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddImage()) OpAddImage;
            }
            (*(ptr_OpAddImage())) = std::move((aRhs).get_OpAddImage());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpAddBlobImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddBlobImage()) OpAddBlobImage;
            }
            (*(ptr_OpAddBlobImage())) = std::move((aRhs).get_OpAddBlobImage());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpUpdateImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUpdateImage()) OpUpdateImage;
            }
            (*(ptr_OpUpdateImage())) = std::move((aRhs).get_OpUpdateImage());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpUpdateBlobImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUpdateBlobImage()) OpUpdateBlobImage;
            }
            (*(ptr_OpUpdateBlobImage())) = std::move((aRhs).get_OpUpdateBlobImage());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpSetImageVisibleArea:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpSetImageVisibleArea()) OpSetImageVisibleArea;
            }
            (*(ptr_OpSetImageVisibleArea())) = std::move((aRhs).get_OpSetImageVisibleArea());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpDeleteImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpDeleteImage()) OpDeleteImage;
            }
            (*(ptr_OpDeleteImage())) = std::move((aRhs).get_OpDeleteImage());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpAddRawFont:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddRawFont()) OpAddRawFont;
            }
            (*(ptr_OpAddRawFont())) = std::move((aRhs).get_OpAddRawFont());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpAddFontDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddFontDescriptor()) OpAddFontDescriptor;
            }
            (*(ptr_OpAddFontDescriptor())) = std::move((aRhs).get_OpAddFontDescriptor());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpDeleteFont:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpDeleteFont()) OpDeleteFont;
            }
            (*(ptr_OpDeleteFont())) = std::move((aRhs).get_OpDeleteFont());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpAddFontInstance:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddFontInstance()) OpAddFontInstance;
            }
            (*(ptr_OpAddFontInstance())) = std::move((aRhs).get_OpAddFontInstance());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpDeleteFontInstance:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpDeleteFontInstance()) OpDeleteFontInstance;
            }
            (*(ptr_OpDeleteFontInstance())) = std::move((aRhs).get_OpDeleteFontInstance());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpAddExternalImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAddExternalImage()) OpAddExternalImage;
            }
            (*(ptr_OpAddExternalImage())) = std::move((aRhs).get_OpAddExternalImage());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpPushExternalImageForTexture:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpPushExternalImageForTexture()) OpPushExternalImageForTexture;
            }
            (*(ptr_OpPushExternalImageForTexture())) = std::move((aRhs).get_OpPushExternalImageForTexture());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpUpdateExternalImage:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUpdateExternalImage()) OpUpdateExternalImage;
            }
            (*(ptr_OpUpdateExternalImage())) = std::move((aRhs).get_OpUpdateExternalImage());
            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 OpUpdateResource::operator==(const OpAddImage& aRhs) const -> bool
{
    return (get_OpAddImage()) == (aRhs);
}

auto OpUpdateResource::operator==(const OpAddBlobImage& aRhs) const -> bool
{
    return (get_OpAddBlobImage()) == (aRhs);
}

auto OpUpdateResource::operator==(const OpUpdateImage& aRhs) const -> bool
{
    return (get_OpUpdateImage()) == (aRhs);
}

auto OpUpdateResource::operator==(const OpUpdateBlobImage& aRhs) const -> bool
{
    return (get_OpUpdateBlobImage()) == (aRhs);
}

auto OpUpdateResource::operator==(const OpSetImageVisibleArea& aRhs) const -> bool
{
    return (get_OpSetImageVisibleArea()) == (aRhs);
}

auto OpUpdateResource::operator==(const OpDeleteImage& aRhs) const -> bool
{
    return (get_OpDeleteImage()) == (aRhs);
}

auto OpUpdateResource::operator==(const OpAddRawFont& aRhs) const -> bool
{
    return (get_OpAddRawFont()) == (aRhs);
}

auto OpUpdateResource::operator==(const OpAddFontDescriptor& aRhs) const -> bool
{
    return (get_OpAddFontDescriptor()) == (aRhs);
}

auto OpUpdateResource::operator==(const OpDeleteFont& aRhs) const -> bool
{
    return (get_OpDeleteFont()) == (aRhs);
}

auto OpUpdateResource::operator==(const OpAddFontInstance& aRhs) const -> bool
{
    return (get_OpAddFontInstance()) == (aRhs);
}

auto OpUpdateResource::operator==(const OpDeleteFontInstance& aRhs) const -> bool
{
    return (get_OpDeleteFontInstance()) == (aRhs);
}

auto OpUpdateResource::operator==(const OpAddExternalImage& aRhs) const -> bool
{
    return (get_OpAddExternalImage()) == (aRhs);
}

auto OpUpdateResource::operator==(const OpPushExternalImageForTexture& aRhs) const -> bool
{
    return (get_OpPushExternalImageForTexture()) == (aRhs);
}

auto OpUpdateResource::operator==(const OpUpdateExternalImage& aRhs) const -> bool
{
    return (get_OpUpdateExternalImage()) == (aRhs);
}

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

    switch (type()) {
    case TOpAddImage:
        {
            return (get_OpAddImage()) == ((aRhs).get_OpAddImage());
        }
    case TOpAddBlobImage:
        {
            return (get_OpAddBlobImage()) == ((aRhs).get_OpAddBlobImage());
        }
    case TOpUpdateImage:
        {
            return (get_OpUpdateImage()) == ((aRhs).get_OpUpdateImage());
        }
    case TOpUpdateBlobImage:
        {
            return (get_OpUpdateBlobImage()) == ((aRhs).get_OpUpdateBlobImage());
        }
    case TOpSetImageVisibleArea:
        {
            return (get_OpSetImageVisibleArea()) == ((aRhs).get_OpSetImageVisibleArea());
        }
    case TOpDeleteImage:
        {
            return (get_OpDeleteImage()) == ((aRhs).get_OpDeleteImage());
        }
    case TOpAddRawFont:
        {
            return (get_OpAddRawFont()) == ((aRhs).get_OpAddRawFont());
        }
    case TOpAddFontDescriptor:
        {
            return (get_OpAddFontDescriptor()) == ((aRhs).get_OpAddFontDescriptor());
        }
    case TOpDeleteFont:
        {
            return (get_OpDeleteFont()) == ((aRhs).get_OpDeleteFont());
        }
    case TOpAddFontInstance:
        {
            return (get_OpAddFontInstance()) == ((aRhs).get_OpAddFontInstance());
        }
    case TOpDeleteFontInstance:
        {
            return (get_OpDeleteFontInstance()) == ((aRhs).get_OpDeleteFontInstance());
        }
    case TOpAddExternalImage:
        {
            return (get_OpAddExternalImage()) == ((aRhs).get_OpAddExternalImage());
        }
    case TOpPushExternalImageForTexture:
        {
            return (get_OpPushExternalImageForTexture()) == ((aRhs).get_OpPushExternalImageForTexture());
        }
    case TOpUpdateExternalImage:
        {
            return (get_OpUpdateExternalImage()) == ((aRhs).get_OpUpdateExternalImage());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto OpUpdateResource::get(OpAddImage* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpAddImage();
}

auto OpUpdateResource::get(OpAddBlobImage* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpAddBlobImage();
}

auto OpUpdateResource::get(OpUpdateImage* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpUpdateImage();
}

auto OpUpdateResource::get(OpUpdateBlobImage* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpUpdateBlobImage();
}

auto OpUpdateResource::get(OpSetImageVisibleArea* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpSetImageVisibleArea();
}

auto OpUpdateResource::get(OpDeleteImage* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpDeleteImage();
}

auto OpUpdateResource::get(OpAddRawFont* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpAddRawFont();
}

auto OpUpdateResource::get(OpAddFontDescriptor* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpAddFontDescriptor();
}

auto OpUpdateResource::get(OpDeleteFont* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpDeleteFont();
}

auto OpUpdateResource::get(OpAddFontInstance* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpAddFontInstance();
}

auto OpUpdateResource::get(OpDeleteFontInstance* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpDeleteFontInstance();
}

auto OpUpdateResource::get(OpAddExternalImage* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpAddExternalImage();
}

auto OpUpdateResource::get(OpPushExternalImageForTexture* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpPushExternalImageForTexture();
}

auto OpUpdateResource::get(OpUpdateExternalImage* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpUpdateExternalImage();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TOpAddImage:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpAddImage());
            // Sentinel = 'TOpAddImage'
            (aMsg)->WriteSentinel(4189650618);
            return;
        }
    case union__::TOpAddBlobImage:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpAddBlobImage());
            // Sentinel = 'TOpAddBlobImage'
            (aMsg)->WriteSentinel(2102557857);
            return;
        }
    case union__::TOpUpdateImage:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpUpdateImage());
            // Sentinel = 'TOpUpdateImage'
            (aMsg)->WriteSentinel(2114077531);
            return;
        }
    case union__::TOpUpdateBlobImage:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpUpdateBlobImage());
            // Sentinel = 'TOpUpdateBlobImage'
            (aMsg)->WriteSentinel(3774598784);
            return;
        }
    case union__::TOpSetImageVisibleArea:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpSetImageVisibleArea());
            // Sentinel = 'TOpSetImageVisibleArea'
            (aMsg)->WriteSentinel(1646970581);
            return;
        }
    case union__::TOpDeleteImage:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpDeleteImage());
            // Sentinel = 'TOpDeleteImage'
            (aMsg)->WriteSentinel(3308386441);
            return;
        }
    case union__::TOpAddRawFont:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpAddRawFont());
            // Sentinel = 'TOpAddRawFont'
            (aMsg)->WriteSentinel(4253717546);
            return;
        }
    case union__::TOpAddFontDescriptor:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpAddFontDescriptor());
            // Sentinel = 'TOpAddFontDescriptor'
            (aMsg)->WriteSentinel(385707742);
            return;
        }
    case union__::TOpDeleteFont:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpDeleteFont());
            // Sentinel = 'TOpDeleteFont'
            (aMsg)->WriteSentinel(2290630538);
            return;
        }
    case union__::TOpAddFontInstance:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpAddFontInstance());
            // Sentinel = 'TOpAddFontInstance'
            (aMsg)->WriteSentinel(3199640182);
            return;
        }
    case union__::TOpDeleteFontInstance:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpDeleteFontInstance());
            // Sentinel = 'TOpDeleteFontInstance'
            (aMsg)->WriteSentinel(3483695347);
            return;
        }
    case union__::TOpAddExternalImage:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpAddExternalImage());
            // Sentinel = 'TOpAddExternalImage'
            (aMsg)->WriteSentinel(3145571349);
            return;
        }
    case union__::TOpPushExternalImageForTexture:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpPushExternalImageForTexture());
            // Sentinel = 'TOpPushExternalImageForTexture'
            (aMsg)->WriteSentinel(583224315);
            return;
        }
    case union__::TOpUpdateExternalImage:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpUpdateExternalImage());
            // Sentinel = 'TOpUpdateExternalImage'
            (aMsg)->WriteSentinel(2764999780);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TOpAddImage:
        {
            mozilla::layers::OpAddImage tmp = mozilla::layers::OpAddImage();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpAddImage())))))) {
                (aActor)->FatalError("Error deserializing variant TOpAddImage of union OpUpdateResource");
                return false;
            }
            // Sentinel = 'TOpAddImage'
            if ((!((aMsg)->ReadSentinel(aIter, 4189650618)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpAddImage of union OpUpdateResource");
                return false;
            }
            return true;
        }
    case union__::TOpAddBlobImage:
        {
            mozilla::layers::OpAddBlobImage tmp = mozilla::layers::OpAddBlobImage();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpAddBlobImage())))))) {
                (aActor)->FatalError("Error deserializing variant TOpAddBlobImage of union OpUpdateResource");
                return false;
            }
            // Sentinel = 'TOpAddBlobImage'
            if ((!((aMsg)->ReadSentinel(aIter, 2102557857)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpAddBlobImage of union OpUpdateResource");
                return false;
            }
            return true;
        }
    case union__::TOpUpdateImage:
        {
            mozilla::layers::OpUpdateImage tmp = mozilla::layers::OpUpdateImage();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpUpdateImage())))))) {
                (aActor)->FatalError("Error deserializing variant TOpUpdateImage of union OpUpdateResource");
                return false;
            }
            // Sentinel = 'TOpUpdateImage'
            if ((!((aMsg)->ReadSentinel(aIter, 2114077531)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpUpdateImage of union OpUpdateResource");
                return false;
            }
            return true;
        }
    case union__::TOpUpdateBlobImage:
        {
            mozilla::layers::OpUpdateBlobImage tmp = mozilla::layers::OpUpdateBlobImage();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpUpdateBlobImage())))))) {
                (aActor)->FatalError("Error deserializing variant TOpUpdateBlobImage of union OpUpdateResource");
                return false;
            }
            // Sentinel = 'TOpUpdateBlobImage'
            if ((!((aMsg)->ReadSentinel(aIter, 3774598784)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpUpdateBlobImage of union OpUpdateResource");
                return false;
            }
            return true;
        }
    case union__::TOpSetImageVisibleArea:
        {
            mozilla::layers::OpSetImageVisibleArea tmp = mozilla::layers::OpSetImageVisibleArea();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpSetImageVisibleArea())))))) {
                (aActor)->FatalError("Error deserializing variant TOpSetImageVisibleArea of union OpUpdateResource");
                return false;
            }
            // Sentinel = 'TOpSetImageVisibleArea'
            if ((!((aMsg)->ReadSentinel(aIter, 1646970581)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpSetImageVisibleArea of union OpUpdateResource");
                return false;
            }
            return true;
        }
    case union__::TOpDeleteImage:
        {
            mozilla::layers::OpDeleteImage tmp = mozilla::layers::OpDeleteImage();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpDeleteImage())))))) {
                (aActor)->FatalError("Error deserializing variant TOpDeleteImage of union OpUpdateResource");
                return false;
            }
            // Sentinel = 'TOpDeleteImage'
            if ((!((aMsg)->ReadSentinel(aIter, 3308386441)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpDeleteImage of union OpUpdateResource");
                return false;
            }
            return true;
        }
    case union__::TOpAddRawFont:
        {
            mozilla::layers::OpAddRawFont tmp = mozilla::layers::OpAddRawFont();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpAddRawFont())))))) {
                (aActor)->FatalError("Error deserializing variant TOpAddRawFont of union OpUpdateResource");
                return false;
            }
            // Sentinel = 'TOpAddRawFont'
            if ((!((aMsg)->ReadSentinel(aIter, 4253717546)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpAddRawFont of union OpUpdateResource");
                return false;
            }
            return true;
        }
    case union__::TOpAddFontDescriptor:
        {
            mozilla::layers::OpAddFontDescriptor tmp = mozilla::layers::OpAddFontDescriptor();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpAddFontDescriptor())))))) {
                (aActor)->FatalError("Error deserializing variant TOpAddFontDescriptor of union OpUpdateResource");
                return false;
            }
            // Sentinel = 'TOpAddFontDescriptor'
            if ((!((aMsg)->ReadSentinel(aIter, 385707742)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpAddFontDescriptor of union OpUpdateResource");
                return false;
            }
            return true;
        }
    case union__::TOpDeleteFont:
        {
            mozilla::layers::OpDeleteFont tmp = mozilla::layers::OpDeleteFont();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpDeleteFont())))))) {
                (aActor)->FatalError("Error deserializing variant TOpDeleteFont of union OpUpdateResource");
                return false;
            }
            // Sentinel = 'TOpDeleteFont'
            if ((!((aMsg)->ReadSentinel(aIter, 2290630538)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpDeleteFont of union OpUpdateResource");
                return false;
            }
            return true;
        }
    case union__::TOpAddFontInstance:
        {
            mozilla::layers::OpAddFontInstance tmp = mozilla::layers::OpAddFontInstance();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpAddFontInstance())))))) {
                (aActor)->FatalError("Error deserializing variant TOpAddFontInstance of union OpUpdateResource");
                return false;
            }
            // Sentinel = 'TOpAddFontInstance'
            if ((!((aMsg)->ReadSentinel(aIter, 3199640182)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpAddFontInstance of union OpUpdateResource");
                return false;
            }
            return true;
        }
    case union__::TOpDeleteFontInstance:
        {
            mozilla::layers::OpDeleteFontInstance tmp = mozilla::layers::OpDeleteFontInstance();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpDeleteFontInstance())))))) {
                (aActor)->FatalError("Error deserializing variant TOpDeleteFontInstance of union OpUpdateResource");
                return false;
            }
            // Sentinel = 'TOpDeleteFontInstance'
            if ((!((aMsg)->ReadSentinel(aIter, 3483695347)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpDeleteFontInstance of union OpUpdateResource");
                return false;
            }
            return true;
        }
    case union__::TOpAddExternalImage:
        {
            mozilla::layers::OpAddExternalImage tmp = mozilla::layers::OpAddExternalImage();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpAddExternalImage())))))) {
                (aActor)->FatalError("Error deserializing variant TOpAddExternalImage of union OpUpdateResource");
                return false;
            }
            // Sentinel = 'TOpAddExternalImage'
            if ((!((aMsg)->ReadSentinel(aIter, 3145571349)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpAddExternalImage of union OpUpdateResource");
                return false;
            }
            return true;
        }
    case union__::TOpPushExternalImageForTexture:
        {
            mozilla::layers::OpPushExternalImageForTexture tmp = mozilla::layers::OpPushExternalImageForTexture();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpPushExternalImageForTexture())))))) {
                (aActor)->FatalError("Error deserializing variant TOpPushExternalImageForTexture of union OpUpdateResource");
                return false;
            }
            // Sentinel = 'TOpPushExternalImageForTexture'
            if ((!((aMsg)->ReadSentinel(aIter, 583224315)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpPushExternalImageForTexture of union OpUpdateResource");
                return false;
            }
            return true;
        }
    case union__::TOpUpdateExternalImage:
        {
            mozilla::layers::OpUpdateExternalImage tmp = mozilla::layers::OpUpdateExternalImage();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpUpdateExternalImage())))))) {
                (aActor)->FatalError("Error deserializing variant TOpUpdateExternalImage of union OpUpdateResource");
                return false;
            }
            // Sentinel = 'TOpUpdateExternalImage'
            if ((!((aMsg)->ReadSentinel(aIter, 2764999780)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpUpdateExternalImage of union OpUpdateResource");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53