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

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


#include "mozilla/layers/LayersSurfaces.h"


//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union OverlayHandle|
//
namespace mozilla {
namespace layers {
auto OverlayHandle::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case Tint32_t:
        {
            (ptr_int32_t())->~int32_t__tdef();
            break;
        }
    case Tnull_t:
        {
            (ptr_null_t())->~null_t__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT OverlayHandle::OverlayHandle(const int32_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(aOther);
    mType = Tint32_t;
}

MOZ_IMPLICIT OverlayHandle::OverlayHandle(int32_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move(aOther));
    mType = Tint32_t;
}

MOZ_IMPLICIT OverlayHandle::OverlayHandle(const null_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
    mType = Tnull_t;
}

MOZ_IMPLICIT OverlayHandle::OverlayHandle(null_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aOther));
    mType = Tnull_t;
}

MOZ_IMPLICIT OverlayHandle::OverlayHandle(const OverlayHandle& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tint32_t:
        {
            new (mozilla::KnownNotNull, ptr_int32_t()) int32_t((aOther).get_int32_t());
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT OverlayHandle::OverlayHandle(OverlayHandle&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tint32_t:
        {
            new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move((aOther).get_int32_t()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_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;
}

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

auto OverlayHandle::operator=(const int32_t& aRhs) -> OverlayHandle&
{
    if (MaybeDestroy(Tint32_t)) {
        new (mozilla::KnownNotNull, ptr_int32_t()) int32_t;
    }
    (*(ptr_int32_t())) = aRhs;
    mType = Tint32_t;
    return (*(this));
}

auto OverlayHandle::operator=(int32_t&& aRhs) -> OverlayHandle&
{
    if (MaybeDestroy(Tint32_t)) {
        new (mozilla::KnownNotNull, ptr_int32_t()) int32_t;
    }
    (*(ptr_int32_t())) = std::move(aRhs);
    mType = Tint32_t;
    return (*(this));
}

auto OverlayHandle::operator=(const null_t& aRhs) -> OverlayHandle&
{
    if (MaybeDestroy(Tnull_t)) {
        new (mozilla::KnownNotNull, ptr_null_t()) null_t;
    }
    (*(ptr_null_t())) = aRhs;
    mType = Tnull_t;
    return (*(this));
}

auto OverlayHandle::operator=(null_t&& aRhs) -> OverlayHandle&
{
    if (MaybeDestroy(Tnull_t)) {
        new (mozilla::KnownNotNull, ptr_null_t()) null_t;
    }
    (*(ptr_null_t())) = std::move(aRhs);
    mType = Tnull_t;
    return (*(this));
}

auto OverlayHandle::operator=(const OverlayHandle& aRhs) -> OverlayHandle&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tint32_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_int32_t()) int32_t;
            }
            (*(ptr_int32_t())) = (aRhs).get_int32_t();
            break;
        }
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = (aRhs).get_null_t();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto OverlayHandle::operator=(OverlayHandle&& aRhs) -> OverlayHandle&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tint32_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_int32_t()) int32_t;
            }
            (*(ptr_int32_t())) = std::move((aRhs).get_int32_t());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = std::move((aRhs).get_null_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 OverlayHandle::operator==(const int32_t& aRhs) const -> bool
{
    return (get_int32_t()) == (aRhs);
}

auto OverlayHandle::operator==(const null_t& aRhs) const -> bool
{
    return (get_null_t()) == (aRhs);
}

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

    switch (type()) {
    case Tint32_t:
        {
            return (get_int32_t()) == ((aRhs).get_int32_t());
        }
    case Tnull_t:
        {
            return (get_null_t()) == ((aRhs).get_null_t());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto OverlayHandle::get(int32_t* aOutValue) const -> void
{
    (*(aOutValue)) = get_int32_t();
}

auto OverlayHandle::get(null_t* aOutValue) const -> void
{
    (*(aOutValue)) = get_null_t();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::Tint32_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_int32_t());
            // Sentinel = 'Tint32_t'
            (aMsg)->WriteSentinel(4219052577);
            return;
        }
    case union__::Tnull_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aMsg)->WriteSentinel(3731137201);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::Tint32_t:
        {
            int32_t tmp = int32_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_int32_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tint32_t of union OverlayHandle");
                return false;
            }
            // Sentinel = 'Tint32_t'
            if ((!((aMsg)->ReadSentinel(aIter, 4219052577)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tint32_t of union OverlayHandle");
                return false;
            }
            return true;
        }
    case union__::Tnull_t:
        {
            mozilla::null_t tmp = mozilla::null_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_null_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tnull_t of union OverlayHandle");
                return false;
            }
            // Sentinel = 'Tnull_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3731137201)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union OverlayHandle");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::SurfaceDescriptorFileMapping>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).handle());
    // Sentinel = 'handle'
    (aMsg)->WriteSentinel(453975108);
    WriteIPDLParam(aMsg, aActor, (aVar).format());
    // Sentinel = 'format'
    (aMsg)->WriteSentinel(2052265543);
    WriteIPDLParam(aMsg, aActor, (aVar).size());
    // Sentinel = 'size'
    (aMsg)->WriteSentinel(931048223);
}

auto IPDLParamTraits<mozilla::layers::SurfaceDescriptorFileMapping>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->handle())))))) {
        (aActor)->FatalError("Error deserializing 'handle' (WindowsHandle) member of 'SurfaceDescriptorFileMapping'");
        return false;
    }
    // Sentinel = 'handle'
    if ((!((aMsg)->ReadSentinel(aIter, 453975108)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handle' (WindowsHandle) member of 'SurfaceDescriptorFileMapping'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->format())))))) {
        (aActor)->FatalError("Error deserializing 'format' (SurfaceFormat) member of 'SurfaceDescriptorFileMapping'");
        return false;
    }
    // Sentinel = 'format'
    if ((!((aMsg)->ReadSentinel(aIter, 2052265543)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'format' (SurfaceFormat) member of 'SurfaceDescriptorFileMapping'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->size())))))) {
        (aActor)->FatalError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorFileMapping'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((aMsg)->ReadSentinel(aIter, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorFileMapping'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::SurfaceDescriptorD3D10>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).handle());
    // Sentinel = 'handle'
    (aMsg)->WriteSentinel(453975108);
    WriteIPDLParam(aMsg, aActor, (aVar).format());
    // Sentinel = 'format'
    (aMsg)->WriteSentinel(2052265543);
    WriteIPDLParam(aMsg, aActor, (aVar).size());
    // Sentinel = 'size'
    (aMsg)->WriteSentinel(931048223);
}

auto IPDLParamTraits<mozilla::layers::SurfaceDescriptorD3D10>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->handle())))))) {
        (aActor)->FatalError("Error deserializing 'handle' (WindowsHandle) member of 'SurfaceDescriptorD3D10'");
        return false;
    }
    // Sentinel = 'handle'
    if ((!((aMsg)->ReadSentinel(aIter, 453975108)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handle' (WindowsHandle) member of 'SurfaceDescriptorD3D10'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->format())))))) {
        (aActor)->FatalError("Error deserializing 'format' (SurfaceFormat) member of 'SurfaceDescriptorD3D10'");
        return false;
    }
    // Sentinel = 'format'
    if ((!((aMsg)->ReadSentinel(aIter, 2052265543)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'format' (SurfaceFormat) member of 'SurfaceDescriptorD3D10'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->size())))))) {
        (aActor)->FatalError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorD3D10'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((aMsg)->ReadSentinel(aIter, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorD3D10'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SurfaceDescriptorDXGIYCbCr|
//
namespace mozilla {
namespace layers {
auto SurfaceDescriptorDXGIYCbCr::operator==(const SurfaceDescriptorDXGIYCbCr& _o) const -> bool
{
    if ((!((handleY()) == ((_o).handleY())))) {
        return false;
    }
    if ((!((handleCb()) == ((_o).handleCb())))) {
        return false;
    }
    if ((!((handleCr()) == ((_o).handleCr())))) {
        return false;
    }
    if ((!((size()) == ((_o).size())))) {
        return false;
    }
    if ((!((sizeY()) == ((_o).sizeY())))) {
        return false;
    }
    if ((!((sizeCbCr()) == ((_o).sizeCbCr())))) {
        return false;
    }
    if ((!((yUVColorSpace()) == ((_o).yUVColorSpace())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::SurfaceDescriptorDXGIYCbCr>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).handleY());
    // Sentinel = 'handleY'
    (aMsg)->WriteSentinel(2719705368);
    WriteIPDLParam(aMsg, aActor, (aVar).handleCb());
    // Sentinel = 'handleCb'
    (aMsg)->WriteSentinel(2777335333);
    WriteIPDLParam(aMsg, aActor, (aVar).handleCr());
    // Sentinel = 'handleCr'
    (aMsg)->WriteSentinel(2777335349);
    WriteIPDLParam(aMsg, aActor, (aVar).size());
    // Sentinel = 'size'
    (aMsg)->WriteSentinel(931048223);
    WriteIPDLParam(aMsg, aActor, (aVar).sizeY());
    // Sentinel = 'sizeY'
    (aMsg)->WriteSentinel(886619725);
    WriteIPDLParam(aMsg, aActor, (aVar).sizeCbCr());
    // Sentinel = 'sizeCbCr'
    (aMsg)->WriteSentinel(2196484423);
    WriteIPDLParam(aMsg, aActor, (aVar).yUVColorSpace());
    // Sentinel = 'yUVColorSpace'
    (aMsg)->WriteSentinel(1051398544);
}

auto IPDLParamTraits<mozilla::layers::SurfaceDescriptorDXGIYCbCr>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->handleY())))))) {
        (aActor)->FatalError("Error deserializing 'handleY' (WindowsHandle) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    // Sentinel = 'handleY'
    if ((!((aMsg)->ReadSentinel(aIter, 2719705368)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handleY' (WindowsHandle) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->handleCb())))))) {
        (aActor)->FatalError("Error deserializing 'handleCb' (WindowsHandle) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    // Sentinel = 'handleCb'
    if ((!((aMsg)->ReadSentinel(aIter, 2777335333)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handleCb' (WindowsHandle) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->handleCr())))))) {
        (aActor)->FatalError("Error deserializing 'handleCr' (WindowsHandle) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    // Sentinel = 'handleCr'
    if ((!((aMsg)->ReadSentinel(aIter, 2777335349)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handleCr' (WindowsHandle) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->size())))))) {
        (aActor)->FatalError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((aMsg)->ReadSentinel(aIter, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->sizeY())))))) {
        (aActor)->FatalError("Error deserializing 'sizeY' (IntSize) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    // Sentinel = 'sizeY'
    if ((!((aMsg)->ReadSentinel(aIter, 886619725)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'sizeY' (IntSize) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->sizeCbCr())))))) {
        (aActor)->FatalError("Error deserializing 'sizeCbCr' (IntSize) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    // Sentinel = 'sizeCbCr'
    if ((!((aMsg)->ReadSentinel(aIter, 2196484423)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'sizeCbCr' (IntSize) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->yUVColorSpace())))))) {
        (aActor)->FatalError("Error deserializing 'yUVColorSpace' (YUVColorSpace) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    // Sentinel = 'yUVColorSpace'
    if ((!((aMsg)->ReadSentinel(aIter, 1051398544)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'yUVColorSpace' (YUVColorSpace) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::SurfaceDescriptorMacIOSurface>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).surfaceId());
    // Sentinel = 'surfaceId'
    (aMsg)->WriteSentinel(4108848731);
    WriteIPDLParam(aMsg, aActor, (aVar).scaleFactor());
    // Sentinel = 'scaleFactor'
    (aMsg)->WriteSentinel(1184637148);
    WriteIPDLParam(aMsg, aActor, (aVar).isOpaque());
    // Sentinel = 'isOpaque'
    (aMsg)->WriteSentinel(3519081617);
}

auto IPDLParamTraits<mozilla::layers::SurfaceDescriptorMacIOSurface>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->surfaceId())))))) {
        (aActor)->FatalError("Error deserializing 'surfaceId' (uint32_t) member of 'SurfaceDescriptorMacIOSurface'");
        return false;
    }
    // Sentinel = 'surfaceId'
    if ((!((aMsg)->ReadSentinel(aIter, 4108848731)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'surfaceId' (uint32_t) member of 'SurfaceDescriptorMacIOSurface'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->scaleFactor())))))) {
        (aActor)->FatalError("Error deserializing 'scaleFactor' (double) member of 'SurfaceDescriptorMacIOSurface'");
        return false;
    }
    // Sentinel = 'scaleFactor'
    if ((!((aMsg)->ReadSentinel(aIter, 1184637148)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scaleFactor' (double) member of 'SurfaceDescriptorMacIOSurface'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->isOpaque())))))) {
        (aActor)->FatalError("Error deserializing 'isOpaque' (bool) member of 'SurfaceDescriptorMacIOSurface'");
        return false;
    }
    // Sentinel = 'isOpaque'
    if ((!((aMsg)->ReadSentinel(aIter, 3519081617)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isOpaque' (bool) member of 'SurfaceDescriptorMacIOSurface'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::SurfaceTextureDescriptor>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).handle());
    // Sentinel = 'handle'
    (aMsg)->WriteSentinel(453975108);
    WriteIPDLParam(aMsg, aActor, (aVar).size());
    // Sentinel = 'size'
    (aMsg)->WriteSentinel(931048223);
    WriteIPDLParam(aMsg, aActor, (aVar).format());
    // Sentinel = 'format'
    (aMsg)->WriteSentinel(2052265543);
    WriteIPDLParam(aMsg, aActor, (aVar).continuous());
    // Sentinel = 'continuous'
    (aMsg)->WriteSentinel(2103626571);
    WriteIPDLParam(aMsg, aActor, (aVar).ignoreTransform());
    // Sentinel = 'ignoreTransform'
    (aMsg)->WriteSentinel(3914789313);
}

auto IPDLParamTraits<mozilla::layers::SurfaceTextureDescriptor>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->handle())))))) {
        (aActor)->FatalError("Error deserializing 'handle' (uint64_t) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    // Sentinel = 'handle'
    if ((!((aMsg)->ReadSentinel(aIter, 453975108)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handle' (uint64_t) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->size())))))) {
        (aActor)->FatalError("Error deserializing 'size' (IntSize) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((aMsg)->ReadSentinel(aIter, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->format())))))) {
        (aActor)->FatalError("Error deserializing 'format' (SurfaceFormat) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    // Sentinel = 'format'
    if ((!((aMsg)->ReadSentinel(aIter, 2052265543)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'format' (SurfaceFormat) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->continuous())))))) {
        (aActor)->FatalError("Error deserializing 'continuous' (bool) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    // Sentinel = 'continuous'
    if ((!((aMsg)->ReadSentinel(aIter, 2103626571)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'continuous' (bool) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->ignoreTransform())))))) {
        (aActor)->FatalError("Error deserializing 'ignoreTransform' (bool) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    // Sentinel = 'ignoreTransform'
    if ((!((aMsg)->ReadSentinel(aIter, 3914789313)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ignoreTransform' (bool) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::EGLImageDescriptor>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).image());
    // Sentinel = 'image'
    (aMsg)->WriteSentinel(103190282);
    WriteIPDLParam(aMsg, aActor, (aVar).fence());
    // Sentinel = 'fence'
    (aMsg)->WriteSentinel(1225633926);
    WriteIPDLParam(aMsg, aActor, (aVar).size());
    // Sentinel = 'size'
    (aMsg)->WriteSentinel(931048223);
    WriteIPDLParam(aMsg, aActor, (aVar).hasAlpha());
    // Sentinel = 'hasAlpha'
    (aMsg)->WriteSentinel(309498444);
}

auto IPDLParamTraits<mozilla::layers::EGLImageDescriptor>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->image())))))) {
        (aActor)->FatalError("Error deserializing 'image' (uintptr_t) member of 'EGLImageDescriptor'");
        return false;
    }
    // Sentinel = 'image'
    if ((!((aMsg)->ReadSentinel(aIter, 103190282)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'image' (uintptr_t) member of 'EGLImageDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->fence())))))) {
        (aActor)->FatalError("Error deserializing 'fence' (uintptr_t) member of 'EGLImageDescriptor'");
        return false;
    }
    // Sentinel = 'fence'
    if ((!((aMsg)->ReadSentinel(aIter, 1225633926)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fence' (uintptr_t) member of 'EGLImageDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->size())))))) {
        (aActor)->FatalError("Error deserializing 'size' (IntSize) member of 'EGLImageDescriptor'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((aMsg)->ReadSentinel(aIter, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'EGLImageDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->hasAlpha())))))) {
        (aActor)->FatalError("Error deserializing 'hasAlpha' (bool) member of 'EGLImageDescriptor'");
        return false;
    }
    // Sentinel = 'hasAlpha'
    if ((!((aMsg)->ReadSentinel(aIter, 309498444)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hasAlpha' (bool) member of 'EGLImageDescriptor'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::SurfaceDescriptorSharedGLTexture>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).texture());
    // Sentinel = 'texture'
    (aMsg)->WriteSentinel(3654462510);
    WriteIPDLParam(aMsg, aActor, (aVar).target());
    // Sentinel = 'target'
    (aMsg)->WriteSentinel(2226365285);
    WriteIPDLParam(aMsg, aActor, (aVar).fence());
    // Sentinel = 'fence'
    (aMsg)->WriteSentinel(1225633926);
    WriteIPDLParam(aMsg, aActor, (aVar).size());
    // Sentinel = 'size'
    (aMsg)->WriteSentinel(931048223);
    WriteIPDLParam(aMsg, aActor, (aVar).hasAlpha());
    // Sentinel = 'hasAlpha'
    (aMsg)->WriteSentinel(309498444);
}

auto IPDLParamTraits<mozilla::layers::SurfaceDescriptorSharedGLTexture>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->texture())))))) {
        (aActor)->FatalError("Error deserializing 'texture' (uint32_t) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    // Sentinel = 'texture'
    if ((!((aMsg)->ReadSentinel(aIter, 3654462510)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'texture' (uint32_t) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->target())))))) {
        (aActor)->FatalError("Error deserializing 'target' (uint32_t) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    // Sentinel = 'target'
    if ((!((aMsg)->ReadSentinel(aIter, 2226365285)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'target' (uint32_t) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->fence())))))) {
        (aActor)->FatalError("Error deserializing 'fence' (uintptr_t) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    // Sentinel = 'fence'
    if ((!((aMsg)->ReadSentinel(aIter, 1225633926)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fence' (uintptr_t) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->size())))))) {
        (aActor)->FatalError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((aMsg)->ReadSentinel(aIter, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->hasAlpha())))))) {
        (aActor)->FatalError("Error deserializing 'hasAlpha' (bool) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    // Sentinel = 'hasAlpha'
    if ((!((aMsg)->ReadSentinel(aIter, 309498444)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hasAlpha' (bool) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union GPUVideoSubDescriptor|
//
namespace mozilla {
namespace layers {
auto GPUVideoSubDescriptor::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TSurfaceDescriptorD3D10:
        {
            (ptr_SurfaceDescriptorD3D10())->~SurfaceDescriptorD3D10__tdef();
            break;
        }
    case TSurfaceDescriptorDXGIYCbCr:
        {
            (ptr_SurfaceDescriptorDXGIYCbCr())->~SurfaceDescriptorDXGIYCbCr__tdef();
            break;
        }
    case Tnull_t:
        {
            (ptr_null_t())->~null_t__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT GPUVideoSubDescriptor::GPUVideoSubDescriptor(const SurfaceDescriptorD3D10& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10(aOther);
    mType = TSurfaceDescriptorD3D10;
}

MOZ_IMPLICIT GPUVideoSubDescriptor::GPUVideoSubDescriptor(SurfaceDescriptorD3D10&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10(std::move(aOther));
    mType = TSurfaceDescriptorD3D10;
}

MOZ_IMPLICIT GPUVideoSubDescriptor::GPUVideoSubDescriptor(const SurfaceDescriptorDXGIYCbCr& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr(aOther);
    mType = TSurfaceDescriptorDXGIYCbCr;
}

MOZ_IMPLICIT GPUVideoSubDescriptor::GPUVideoSubDescriptor(SurfaceDescriptorDXGIYCbCr&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr(std::move(aOther));
    mType = TSurfaceDescriptorDXGIYCbCr;
}

MOZ_IMPLICIT GPUVideoSubDescriptor::GPUVideoSubDescriptor(const null_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
    mType = Tnull_t;
}

MOZ_IMPLICIT GPUVideoSubDescriptor::GPUVideoSubDescriptor(null_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aOther));
    mType = Tnull_t;
}

MOZ_IMPLICIT GPUVideoSubDescriptor::GPUVideoSubDescriptor(const GPUVideoSubDescriptor& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TSurfaceDescriptorD3D10:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10((aOther).get_SurfaceDescriptorD3D10());
            break;
        }
    case TSurfaceDescriptorDXGIYCbCr:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr((aOther).get_SurfaceDescriptorDXGIYCbCr());
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT GPUVideoSubDescriptor::GPUVideoSubDescriptor(GPUVideoSubDescriptor&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TSurfaceDescriptorD3D10:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10(std::move((aOther).get_SurfaceDescriptorD3D10()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorDXGIYCbCr:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr(std::move((aOther).get_SurfaceDescriptorDXGIYCbCr()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_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;
}

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

auto GPUVideoSubDescriptor::operator=(const SurfaceDescriptorD3D10& aRhs) -> GPUVideoSubDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorD3D10)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10;
    }
    (*(ptr_SurfaceDescriptorD3D10())) = aRhs;
    mType = TSurfaceDescriptorD3D10;
    return (*(this));
}

auto GPUVideoSubDescriptor::operator=(SurfaceDescriptorD3D10&& aRhs) -> GPUVideoSubDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorD3D10)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10;
    }
    (*(ptr_SurfaceDescriptorD3D10())) = std::move(aRhs);
    mType = TSurfaceDescriptorD3D10;
    return (*(this));
}

auto GPUVideoSubDescriptor::operator=(const SurfaceDescriptorDXGIYCbCr& aRhs) -> GPUVideoSubDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorDXGIYCbCr)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr;
    }
    (*(ptr_SurfaceDescriptorDXGIYCbCr())) = aRhs;
    mType = TSurfaceDescriptorDXGIYCbCr;
    return (*(this));
}

auto GPUVideoSubDescriptor::operator=(SurfaceDescriptorDXGIYCbCr&& aRhs) -> GPUVideoSubDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorDXGIYCbCr)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr;
    }
    (*(ptr_SurfaceDescriptorDXGIYCbCr())) = std::move(aRhs);
    mType = TSurfaceDescriptorDXGIYCbCr;
    return (*(this));
}

auto GPUVideoSubDescriptor::operator=(const null_t& aRhs) -> GPUVideoSubDescriptor&
{
    if (MaybeDestroy(Tnull_t)) {
        new (mozilla::KnownNotNull, ptr_null_t()) null_t;
    }
    (*(ptr_null_t())) = aRhs;
    mType = Tnull_t;
    return (*(this));
}

auto GPUVideoSubDescriptor::operator=(null_t&& aRhs) -> GPUVideoSubDescriptor&
{
    if (MaybeDestroy(Tnull_t)) {
        new (mozilla::KnownNotNull, ptr_null_t()) null_t;
    }
    (*(ptr_null_t())) = std::move(aRhs);
    mType = Tnull_t;
    return (*(this));
}

auto GPUVideoSubDescriptor::operator=(const GPUVideoSubDescriptor& aRhs) -> GPUVideoSubDescriptor&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TSurfaceDescriptorD3D10:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10;
            }
            (*(ptr_SurfaceDescriptorD3D10())) = (aRhs).get_SurfaceDescriptorD3D10();
            break;
        }
    case TSurfaceDescriptorDXGIYCbCr:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr;
            }
            (*(ptr_SurfaceDescriptorDXGIYCbCr())) = (aRhs).get_SurfaceDescriptorDXGIYCbCr();
            break;
        }
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = (aRhs).get_null_t();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto GPUVideoSubDescriptor::operator=(GPUVideoSubDescriptor&& aRhs) -> GPUVideoSubDescriptor&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TSurfaceDescriptorD3D10:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10;
            }
            (*(ptr_SurfaceDescriptorD3D10())) = std::move((aRhs).get_SurfaceDescriptorD3D10());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorDXGIYCbCr:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr;
            }
            (*(ptr_SurfaceDescriptorDXGIYCbCr())) = std::move((aRhs).get_SurfaceDescriptorDXGIYCbCr());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = std::move((aRhs).get_null_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 GPUVideoSubDescriptor::operator==(const SurfaceDescriptorD3D10& aRhs) const -> bool
{
    return (get_SurfaceDescriptorD3D10()) == (aRhs);
}

auto GPUVideoSubDescriptor::operator==(const SurfaceDescriptorDXGIYCbCr& aRhs) const -> bool
{
    return (get_SurfaceDescriptorDXGIYCbCr()) == (aRhs);
}

auto GPUVideoSubDescriptor::operator==(const null_t& aRhs) const -> bool
{
    return (get_null_t()) == (aRhs);
}

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

    switch (type()) {
    case TSurfaceDescriptorD3D10:
        {
            return (get_SurfaceDescriptorD3D10()) == ((aRhs).get_SurfaceDescriptorD3D10());
        }
    case TSurfaceDescriptorDXGIYCbCr:
        {
            return (get_SurfaceDescriptorDXGIYCbCr()) == ((aRhs).get_SurfaceDescriptorDXGIYCbCr());
        }
    case Tnull_t:
        {
            return (get_null_t()) == ((aRhs).get_null_t());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto GPUVideoSubDescriptor::get(SurfaceDescriptorD3D10* aOutValue) const -> void
{
    (*(aOutValue)) = get_SurfaceDescriptorD3D10();
}

auto GPUVideoSubDescriptor::get(SurfaceDescriptorDXGIYCbCr* aOutValue) const -> void
{
    (*(aOutValue)) = get_SurfaceDescriptorDXGIYCbCr();
}

auto GPUVideoSubDescriptor::get(null_t* aOutValue) const -> void
{
    (*(aOutValue)) = get_null_t();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TSurfaceDescriptorD3D10:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SurfaceDescriptorD3D10());
            // Sentinel = 'TSurfaceDescriptorD3D10'
            (aMsg)->WriteSentinel(2753564567);
            return;
        }
    case union__::TSurfaceDescriptorDXGIYCbCr:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SurfaceDescriptorDXGIYCbCr());
            // Sentinel = 'TSurfaceDescriptorDXGIYCbCr'
            (aMsg)->WriteSentinel(3061212892);
            return;
        }
    case union__::Tnull_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aMsg)->WriteSentinel(3731137201);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TSurfaceDescriptorD3D10:
        {
            mozilla::layers::SurfaceDescriptorD3D10 tmp = mozilla::layers::SurfaceDescriptorD3D10();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SurfaceDescriptorD3D10())))))) {
                (aActor)->FatalError("Error deserializing variant TSurfaceDescriptorD3D10 of union GPUVideoSubDescriptor");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorD3D10'
            if ((!((aMsg)->ReadSentinel(aIter, 2753564567)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSurfaceDescriptorD3D10 of union GPUVideoSubDescriptor");
                return false;
            }
            return true;
        }
    case union__::TSurfaceDescriptorDXGIYCbCr:
        {
            mozilla::layers::SurfaceDescriptorDXGIYCbCr tmp = mozilla::layers::SurfaceDescriptorDXGIYCbCr();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SurfaceDescriptorDXGIYCbCr())))))) {
                (aActor)->FatalError("Error deserializing variant TSurfaceDescriptorDXGIYCbCr of union GPUVideoSubDescriptor");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorDXGIYCbCr'
            if ((!((aMsg)->ReadSentinel(aIter, 3061212892)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSurfaceDescriptorDXGIYCbCr of union GPUVideoSubDescriptor");
                return false;
            }
            return true;
        }
    case union__::Tnull_t:
        {
            mozilla::null_t tmp = mozilla::null_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_null_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tnull_t of union GPUVideoSubDescriptor");
                return false;
            }
            // Sentinel = 'Tnull_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3731137201)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union GPUVideoSubDescriptor");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::RGBDescriptor>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).size());
    // Sentinel = 'size'
    (aMsg)->WriteSentinel(931048223);
    WriteIPDLParam(aMsg, aActor, (aVar).format());
    // Sentinel = 'format'
    (aMsg)->WriteSentinel(2052265543);
    WriteIPDLParam(aMsg, aActor, (aVar).hasIntermediateBuffer());
    // Sentinel = 'hasIntermediateBuffer'
    (aMsg)->WriteSentinel(985857996);
}

auto IPDLParamTraits<mozilla::layers::RGBDescriptor>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->size())))))) {
        (aActor)->FatalError("Error deserializing 'size' (IntSize) member of 'RGBDescriptor'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((aMsg)->ReadSentinel(aIter, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'RGBDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->format())))))) {
        (aActor)->FatalError("Error deserializing 'format' (SurfaceFormat) member of 'RGBDescriptor'");
        return false;
    }
    // Sentinel = 'format'
    if ((!((aMsg)->ReadSentinel(aIter, 2052265543)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'format' (SurfaceFormat) member of 'RGBDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->hasIntermediateBuffer())))))) {
        (aActor)->FatalError("Error deserializing 'hasIntermediateBuffer' (bool) member of 'RGBDescriptor'");
        return false;
    }
    // Sentinel = 'hasIntermediateBuffer'
    if ((!((aMsg)->ReadSentinel(aIter, 985857996)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hasIntermediateBuffer' (bool) member of 'RGBDescriptor'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct YCbCrDescriptor|
//
namespace mozilla {
namespace layers {
auto YCbCrDescriptor::operator==(const YCbCrDescriptor& _o) const -> bool
{
    if ((!((ySize()) == ((_o).ySize())))) {
        return false;
    }
    if ((!((yStride()) == ((_o).yStride())))) {
        return false;
    }
    if ((!((cbCrSize()) == ((_o).cbCrSize())))) {
        return false;
    }
    if ((!((cbCrStride()) == ((_o).cbCrStride())))) {
        return false;
    }
    if ((!((yOffset()) == ((_o).yOffset())))) {
        return false;
    }
    if ((!((cbOffset()) == ((_o).cbOffset())))) {
        return false;
    }
    if ((!((crOffset()) == ((_o).crOffset())))) {
        return false;
    }
    if ((!((stereoMode()) == ((_o).stereoMode())))) {
        return false;
    }
    if ((!((yUVColorSpace()) == ((_o).yUVColorSpace())))) {
        return false;
    }
    if ((!((bitDepth()) == ((_o).bitDepth())))) {
        return false;
    }
    if ((!((hasIntermediateBuffer()) == ((_o).hasIntermediateBuffer())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::YCbCrDescriptor>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).ySize());
    // Sentinel = 'ySize'
    (aMsg)->WriteSentinel(313512843);
    WriteIPDLParam(aMsg, aActor, (aVar).yStride());
    // Sentinel = 'yStride'
    (aMsg)->WriteSentinel(2975587197);
    WriteIPDLParam(aMsg, aActor, (aVar).cbCrSize());
    // Sentinel = 'cbCrSize'
    (aMsg)->WriteSentinel(2601117167);
    WriteIPDLParam(aMsg, aActor, (aVar).cbCrStride());
    // Sentinel = 'cbCrStride'
    (aMsg)->WriteSentinel(301955305);
    WriteIPDLParam(aMsg, aActor, (aVar).yOffset());
    // Sentinel = 'yOffset'
    (aMsg)->WriteSentinel(983795183);
    WriteIPDLParam(aMsg, aActor, (aVar).cbOffset());
    // Sentinel = 'cbOffset'
    (aMsg)->WriteSentinel(4197159602);
    WriteIPDLParam(aMsg, aActor, (aVar).crOffset());
    // Sentinel = 'crOffset'
    (aMsg)->WriteSentinel(1739681986);
    WriteIPDLParam(aMsg, aActor, (aVar).stereoMode());
    // Sentinel = 'stereoMode'
    (aMsg)->WriteSentinel(2234072623);
    WriteIPDLParam(aMsg, aActor, (aVar).yUVColorSpace());
    // Sentinel = 'yUVColorSpace'
    (aMsg)->WriteSentinel(1051398544);
    WriteIPDLParam(aMsg, aActor, (aVar).bitDepth());
    // Sentinel = 'bitDepth'
    (aMsg)->WriteSentinel(3117232644);
    WriteIPDLParam(aMsg, aActor, (aVar).hasIntermediateBuffer());
    // Sentinel = 'hasIntermediateBuffer'
    (aMsg)->WriteSentinel(985857996);
}

auto IPDLParamTraits<mozilla::layers::YCbCrDescriptor>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->ySize())))))) {
        (aActor)->FatalError("Error deserializing 'ySize' (IntSize) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'ySize'
    if ((!((aMsg)->ReadSentinel(aIter, 313512843)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ySize' (IntSize) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->yStride())))))) {
        (aActor)->FatalError("Error deserializing 'yStride' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'yStride'
    if ((!((aMsg)->ReadSentinel(aIter, 2975587197)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'yStride' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->cbCrSize())))))) {
        (aActor)->FatalError("Error deserializing 'cbCrSize' (IntSize) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'cbCrSize'
    if ((!((aMsg)->ReadSentinel(aIter, 2601117167)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cbCrSize' (IntSize) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->cbCrStride())))))) {
        (aActor)->FatalError("Error deserializing 'cbCrStride' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'cbCrStride'
    if ((!((aMsg)->ReadSentinel(aIter, 301955305)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cbCrStride' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->yOffset())))))) {
        (aActor)->FatalError("Error deserializing 'yOffset' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'yOffset'
    if ((!((aMsg)->ReadSentinel(aIter, 983795183)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'yOffset' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->cbOffset())))))) {
        (aActor)->FatalError("Error deserializing 'cbOffset' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'cbOffset'
    if ((!((aMsg)->ReadSentinel(aIter, 4197159602)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cbOffset' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->crOffset())))))) {
        (aActor)->FatalError("Error deserializing 'crOffset' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'crOffset'
    if ((!((aMsg)->ReadSentinel(aIter, 1739681986)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'crOffset' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->stereoMode())))))) {
        (aActor)->FatalError("Error deserializing 'stereoMode' (StereoMode) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'stereoMode'
    if ((!((aMsg)->ReadSentinel(aIter, 2234072623)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'stereoMode' (StereoMode) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->yUVColorSpace())))))) {
        (aActor)->FatalError("Error deserializing 'yUVColorSpace' (YUVColorSpace) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'yUVColorSpace'
    if ((!((aMsg)->ReadSentinel(aIter, 1051398544)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'yUVColorSpace' (YUVColorSpace) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->bitDepth())))))) {
        (aActor)->FatalError("Error deserializing 'bitDepth' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'bitDepth'
    if ((!((aMsg)->ReadSentinel(aIter, 3117232644)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bitDepth' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->hasIntermediateBuffer())))))) {
        (aActor)->FatalError("Error deserializing 'hasIntermediateBuffer' (bool) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'hasIntermediateBuffer'
    if ((!((aMsg)->ReadSentinel(aIter, 985857996)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hasIntermediateBuffer' (bool) member of 'YCbCrDescriptor'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union BufferDescriptor|
//
namespace mozilla {
namespace layers {
auto BufferDescriptor::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TRGBDescriptor:
        {
            (ptr_RGBDescriptor())->~RGBDescriptor__tdef();
            break;
        }
    case TYCbCrDescriptor:
        {
            (ptr_YCbCrDescriptor())->~YCbCrDescriptor__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT BufferDescriptor::BufferDescriptor(const RGBDescriptor& aOther)
{
    new (mozilla::KnownNotNull, ptr_RGBDescriptor()) RGBDescriptor(aOther);
    mType = TRGBDescriptor;
}

MOZ_IMPLICIT BufferDescriptor::BufferDescriptor(RGBDescriptor&& aOther)
{
    new (mozilla::KnownNotNull, ptr_RGBDescriptor()) RGBDescriptor(std::move(aOther));
    mType = TRGBDescriptor;
}

MOZ_IMPLICIT BufferDescriptor::BufferDescriptor(const YCbCrDescriptor& aOther)
{
    new (mozilla::KnownNotNull, ptr_YCbCrDescriptor()) YCbCrDescriptor(aOther);
    mType = TYCbCrDescriptor;
}

MOZ_IMPLICIT BufferDescriptor::BufferDescriptor(YCbCrDescriptor&& aOther)
{
    new (mozilla::KnownNotNull, ptr_YCbCrDescriptor()) YCbCrDescriptor(std::move(aOther));
    mType = TYCbCrDescriptor;
}

MOZ_IMPLICIT BufferDescriptor::BufferDescriptor(const BufferDescriptor& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TRGBDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_RGBDescriptor()) RGBDescriptor((aOther).get_RGBDescriptor());
            break;
        }
    case TYCbCrDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_YCbCrDescriptor()) YCbCrDescriptor((aOther).get_YCbCrDescriptor());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT BufferDescriptor::BufferDescriptor(BufferDescriptor&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TRGBDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_RGBDescriptor()) RGBDescriptor(std::move((aOther).get_RGBDescriptor()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TYCbCrDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_YCbCrDescriptor()) YCbCrDescriptor(std::move((aOther).get_YCbCrDescriptor()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto BufferDescriptor::operator=(const RGBDescriptor& aRhs) -> BufferDescriptor&
{
    if (MaybeDestroy(TRGBDescriptor)) {
        new (mozilla::KnownNotNull, ptr_RGBDescriptor()) RGBDescriptor;
    }
    (*(ptr_RGBDescriptor())) = aRhs;
    mType = TRGBDescriptor;
    return (*(this));
}

auto BufferDescriptor::operator=(RGBDescriptor&& aRhs) -> BufferDescriptor&
{
    if (MaybeDestroy(TRGBDescriptor)) {
        new (mozilla::KnownNotNull, ptr_RGBDescriptor()) RGBDescriptor;
    }
    (*(ptr_RGBDescriptor())) = std::move(aRhs);
    mType = TRGBDescriptor;
    return (*(this));
}

auto BufferDescriptor::operator=(const YCbCrDescriptor& aRhs) -> BufferDescriptor&
{
    if (MaybeDestroy(TYCbCrDescriptor)) {
        new (mozilla::KnownNotNull, ptr_YCbCrDescriptor()) YCbCrDescriptor;
    }
    (*(ptr_YCbCrDescriptor())) = aRhs;
    mType = TYCbCrDescriptor;
    return (*(this));
}

auto BufferDescriptor::operator=(YCbCrDescriptor&& aRhs) -> BufferDescriptor&
{
    if (MaybeDestroy(TYCbCrDescriptor)) {
        new (mozilla::KnownNotNull, ptr_YCbCrDescriptor()) YCbCrDescriptor;
    }
    (*(ptr_YCbCrDescriptor())) = std::move(aRhs);
    mType = TYCbCrDescriptor;
    return (*(this));
}

auto BufferDescriptor::operator=(const BufferDescriptor& aRhs) -> BufferDescriptor&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TRGBDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_RGBDescriptor()) RGBDescriptor;
            }
            (*(ptr_RGBDescriptor())) = (aRhs).get_RGBDescriptor();
            break;
        }
    case TYCbCrDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_YCbCrDescriptor()) YCbCrDescriptor;
            }
            (*(ptr_YCbCrDescriptor())) = (aRhs).get_YCbCrDescriptor();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto BufferDescriptor::operator=(BufferDescriptor&& aRhs) -> BufferDescriptor&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TRGBDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_RGBDescriptor()) RGBDescriptor;
            }
            (*(ptr_RGBDescriptor())) = std::move((aRhs).get_RGBDescriptor());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TYCbCrDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_YCbCrDescriptor()) YCbCrDescriptor;
            }
            (*(ptr_YCbCrDescriptor())) = std::move((aRhs).get_YCbCrDescriptor());
            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 BufferDescriptor::operator==(const RGBDescriptor& aRhs) const -> bool
{
    return (get_RGBDescriptor()) == (aRhs);
}

auto BufferDescriptor::operator==(const YCbCrDescriptor& aRhs) const -> bool
{
    return (get_YCbCrDescriptor()) == (aRhs);
}

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

    switch (type()) {
    case TRGBDescriptor:
        {
            return (get_RGBDescriptor()) == ((aRhs).get_RGBDescriptor());
        }
    case TYCbCrDescriptor:
        {
            return (get_YCbCrDescriptor()) == ((aRhs).get_YCbCrDescriptor());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto BufferDescriptor::get(RGBDescriptor* aOutValue) const -> void
{
    (*(aOutValue)) = get_RGBDescriptor();
}

auto BufferDescriptor::get(YCbCrDescriptor* aOutValue) const -> void
{
    (*(aOutValue)) = get_YCbCrDescriptor();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TRGBDescriptor:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_RGBDescriptor());
            // Sentinel = 'TRGBDescriptor'
            (aMsg)->WriteSentinel(2888062100);
            return;
        }
    case union__::TYCbCrDescriptor:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_YCbCrDescriptor());
            // Sentinel = 'TYCbCrDescriptor'
            (aMsg)->WriteSentinel(3533945878);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TRGBDescriptor:
        {
            mozilla::layers::RGBDescriptor tmp = mozilla::layers::RGBDescriptor();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_RGBDescriptor())))))) {
                (aActor)->FatalError("Error deserializing variant TRGBDescriptor of union BufferDescriptor");
                return false;
            }
            // Sentinel = 'TRGBDescriptor'
            if ((!((aMsg)->ReadSentinel(aIter, 2888062100)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TRGBDescriptor of union BufferDescriptor");
                return false;
            }
            return true;
        }
    case union__::TYCbCrDescriptor:
        {
            mozilla::layers::YCbCrDescriptor tmp = mozilla::layers::YCbCrDescriptor();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_YCbCrDescriptor())))))) {
                (aActor)->FatalError("Error deserializing variant TYCbCrDescriptor of union BufferDescriptor");
                return false;
            }
            // Sentinel = 'TYCbCrDescriptor'
            if ((!((aMsg)->ReadSentinel(aIter, 3533945878)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TYCbCrDescriptor of union BufferDescriptor");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union MemoryOrShmem|
//
namespace mozilla {
namespace layers {
auto MemoryOrShmem::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case Tuintptr_t:
        {
            (ptr_uintptr_t())->~uintptr_t__tdef();
            break;
        }
    case TShmem:
        {
            (ptr_Shmem())->~Shmem__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT MemoryOrShmem::MemoryOrShmem(const uintptr_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t(aOther);
    mType = Tuintptr_t;
}

MOZ_IMPLICIT MemoryOrShmem::MemoryOrShmem(uintptr_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t(std::move(aOther));
    mType = Tuintptr_t;
}

MOZ_IMPLICIT MemoryOrShmem::MemoryOrShmem(Shmem& aOther)
{
    new (mozilla::KnownNotNull, ptr_Shmem()) Shmem(aOther);
    mType = TShmem;
}

MOZ_IMPLICIT MemoryOrShmem::MemoryOrShmem(Shmem&& aOther)
{
    new (mozilla::KnownNotNull, ptr_Shmem()) Shmem(std::move(aOther));
    mType = TShmem;
}

MOZ_IMPLICIT MemoryOrShmem::MemoryOrShmem(const MemoryOrShmem& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tuintptr_t:
        {
            new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t((aOther).get_uintptr_t());
            break;
        }
    case TShmem:
        {
            new (mozilla::KnownNotNull, ptr_Shmem()) Shmem((aOther).get_Shmem());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT MemoryOrShmem::MemoryOrShmem(MemoryOrShmem&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tuintptr_t:
        {
            new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t(std::move((aOther).get_uintptr_t()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TShmem:
        {
            new (mozilla::KnownNotNull, ptr_Shmem()) Shmem(std::move((aOther).get_Shmem()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto MemoryOrShmem::operator=(const uintptr_t& aRhs) -> MemoryOrShmem&
{
    if (MaybeDestroy(Tuintptr_t)) {
        new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t;
    }
    (*(ptr_uintptr_t())) = aRhs;
    mType = Tuintptr_t;
    return (*(this));
}

auto MemoryOrShmem::operator=(uintptr_t&& aRhs) -> MemoryOrShmem&
{
    if (MaybeDestroy(Tuintptr_t)) {
        new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t;
    }
    (*(ptr_uintptr_t())) = std::move(aRhs);
    mType = Tuintptr_t;
    return (*(this));
}

auto MemoryOrShmem::operator=(Shmem& aRhs) -> MemoryOrShmem&
{
    if (MaybeDestroy(TShmem)) {
        new (mozilla::KnownNotNull, ptr_Shmem()) Shmem;
    }
    (*(ptr_Shmem())) = aRhs;
    mType = TShmem;
    return (*(this));
}

auto MemoryOrShmem::operator=(Shmem&& aRhs) -> MemoryOrShmem&
{
    if (MaybeDestroy(TShmem)) {
        new (mozilla::KnownNotNull, ptr_Shmem()) Shmem;
    }
    (*(ptr_Shmem())) = std::move(aRhs);
    mType = TShmem;
    return (*(this));
}

auto MemoryOrShmem::operator=(const MemoryOrShmem& aRhs) -> MemoryOrShmem&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tuintptr_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t;
            }
            (*(ptr_uintptr_t())) = (aRhs).get_uintptr_t();
            break;
        }
    case TShmem:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Shmem()) Shmem;
            }
            (*(ptr_Shmem())) = (aRhs).get_Shmem();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto MemoryOrShmem::operator=(MemoryOrShmem&& aRhs) -> MemoryOrShmem&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tuintptr_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t;
            }
            (*(ptr_uintptr_t())) = std::move((aRhs).get_uintptr_t());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TShmem:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Shmem()) Shmem;
            }
            (*(ptr_Shmem())) = std::move((aRhs).get_Shmem());
            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 MemoryOrShmem::operator==(const uintptr_t& aRhs) const -> bool
{
    return (get_uintptr_t()) == (aRhs);
}

auto MemoryOrShmem::operator==(Shmem& aRhs) const -> bool
{
    return (get_Shmem()) == (aRhs);
}

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

    switch (type()) {
    case Tuintptr_t:
        {
            return (get_uintptr_t()) == ((aRhs).get_uintptr_t());
        }
    case TShmem:
        {
            return (get_Shmem()) == ((aRhs).get_Shmem());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto MemoryOrShmem::get(uintptr_t* aOutValue) const -> void
{
    (*(aOutValue)) = get_uintptr_t();
}

auto MemoryOrShmem::get(Shmem* aOutValue) const -> void
{
    (*(aOutValue)) = get_Shmem();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::Tuintptr_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_uintptr_t());
            // Sentinel = 'Tuintptr_t'
            (aMsg)->WriteSentinel(3218141805);
            return;
        }
    case union__::TShmem:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_Shmem());
            // Sentinel = 'TShmem'
            (aMsg)->WriteSentinel(3517971266);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::Tuintptr_t:
        {
            uintptr_t tmp = uintptr_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_uintptr_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tuintptr_t of union MemoryOrShmem");
                return false;
            }
            // Sentinel = 'Tuintptr_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3218141805)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tuintptr_t of union MemoryOrShmem");
                return false;
            }
            return true;
        }
    case union__::TShmem:
        {
            mozilla::ipc::Shmem tmp = mozilla::ipc::Shmem();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_Shmem())))))) {
                (aActor)->FatalError("Error deserializing variant TShmem of union MemoryOrShmem");
                return false;
            }
            // Sentinel = 'TShmem'
            if ((!((aMsg)->ReadSentinel(aIter, 3517971266)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TShmem of union MemoryOrShmem");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::SurfaceDescriptorShared>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).size());
    // Sentinel = 'size'
    (aMsg)->WriteSentinel(931048223);
    WriteIPDLParam(aMsg, aActor, (aVar).stride());
    // Sentinel = 'stride'
    (aMsg)->WriteSentinel(2746301169);
    WriteIPDLParam(aMsg, aActor, (aVar).format());
    // Sentinel = 'format'
    (aMsg)->WriteSentinel(2052265543);
    WriteIPDLParam(aMsg, aActor, (aVar).handle());
    // Sentinel = 'handle'
    (aMsg)->WriteSentinel(453975108);
}

auto IPDLParamTraits<mozilla::layers::SurfaceDescriptorShared>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->size())))))) {
        (aActor)->FatalError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorShared'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((aMsg)->ReadSentinel(aIter, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorShared'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->stride())))))) {
        (aActor)->FatalError("Error deserializing 'stride' (int32_t) member of 'SurfaceDescriptorShared'");
        return false;
    }
    // Sentinel = 'stride'
    if ((!((aMsg)->ReadSentinel(aIter, 2746301169)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'stride' (int32_t) member of 'SurfaceDescriptorShared'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->format())))))) {
        (aActor)->FatalError("Error deserializing 'format' (SurfaceFormat) member of 'SurfaceDescriptorShared'");
        return false;
    }
    // Sentinel = 'format'
    if ((!((aMsg)->ReadSentinel(aIter, 2052265543)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'format' (SurfaceFormat) member of 'SurfaceDescriptorShared'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->handle())))))) {
        (aActor)->FatalError("Error deserializing 'handle' (Handle) member of 'SurfaceDescriptorShared'");
        return false;
    }
    // Sentinel = 'handle'
    if ((!((aMsg)->ReadSentinel(aIter, 453975108)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handle' (Handle) member of 'SurfaceDescriptorShared'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union SurfaceDescriptor|
//
namespace mozilla {
namespace layers {
auto SurfaceDescriptor::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TSurfaceDescriptorBuffer:
        {
            (ptr_SurfaceDescriptorBuffer())->~SurfaceDescriptorBuffer__tdef();
            break;
        }
    case TSurfaceDescriptorDIB:
        {
            (ptr_SurfaceDescriptorDIB())->~SurfaceDescriptorDIB__tdef();
            break;
        }
    case TSurfaceDescriptorD3D10:
        {
            (ptr_SurfaceDescriptorD3D10())->~SurfaceDescriptorD3D10__tdef();
            break;
        }
    case TSurfaceDescriptorFileMapping:
        {
            (ptr_SurfaceDescriptorFileMapping())->~SurfaceDescriptorFileMapping__tdef();
            break;
        }
    case TSurfaceDescriptorDXGIYCbCr:
        {
            (ptr_SurfaceDescriptorDXGIYCbCr())->~SurfaceDescriptorDXGIYCbCr__tdef();
            break;
        }
    case TSurfaceDescriptorX11:
        {
            (ptr_SurfaceDescriptorX11())->~SurfaceDescriptorX11__tdef();
            break;
        }
    case TSurfaceTextureDescriptor:
        {
            (ptr_SurfaceTextureDescriptor())->~SurfaceTextureDescriptor__tdef();
            break;
        }
    case TEGLImageDescriptor:
        {
            (ptr_EGLImageDescriptor())->~EGLImageDescriptor__tdef();
            break;
        }
    case TSurfaceDescriptorMacIOSurface:
        {
            (ptr_SurfaceDescriptorMacIOSurface())->~SurfaceDescriptorMacIOSurface__tdef();
            break;
        }
    case TSurfaceDescriptorSharedGLTexture:
        {
            (ptr_SurfaceDescriptorSharedGLTexture())->~SurfaceDescriptorSharedGLTexture__tdef();
            break;
        }
    case TSurfaceDescriptorGPUVideo:
        {
            (ptr_SurfaceDescriptorGPUVideo())->~SurfaceDescriptorGPUVideo__tdef();
            break;
        }
    case Tnull_t:
        {
            (ptr_null_t())->~null_t__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(const SurfaceDescriptorBuffer& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorBuffer()) SurfaceDescriptorBuffer(aOther);
    mType = TSurfaceDescriptorBuffer;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(SurfaceDescriptorBuffer&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorBuffer()) SurfaceDescriptorBuffer(std::move(aOther));
    mType = TSurfaceDescriptorBuffer;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(const SurfaceDescriptorDIB& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDIB()) SurfaceDescriptorDIB(aOther);
    mType = TSurfaceDescriptorDIB;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(SurfaceDescriptorDIB&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDIB()) SurfaceDescriptorDIB(std::move(aOther));
    mType = TSurfaceDescriptorDIB;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(const SurfaceDescriptorD3D10& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10(aOther);
    mType = TSurfaceDescriptorD3D10;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(SurfaceDescriptorD3D10&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10(std::move(aOther));
    mType = TSurfaceDescriptorD3D10;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(const SurfaceDescriptorFileMapping& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorFileMapping()) SurfaceDescriptorFileMapping(aOther);
    mType = TSurfaceDescriptorFileMapping;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(SurfaceDescriptorFileMapping&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorFileMapping()) SurfaceDescriptorFileMapping(std::move(aOther));
    mType = TSurfaceDescriptorFileMapping;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(const SurfaceDescriptorDXGIYCbCr& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr(aOther);
    mType = TSurfaceDescriptorDXGIYCbCr;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(SurfaceDescriptorDXGIYCbCr&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr(std::move(aOther));
    mType = TSurfaceDescriptorDXGIYCbCr;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(const SurfaceDescriptorX11& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorX11()) SurfaceDescriptorX11(aOther);
    mType = TSurfaceDescriptorX11;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(SurfaceDescriptorX11&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorX11()) SurfaceDescriptorX11(std::move(aOther));
    mType = TSurfaceDescriptorX11;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(const SurfaceTextureDescriptor& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceTextureDescriptor()) SurfaceTextureDescriptor(aOther);
    mType = TSurfaceTextureDescriptor;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(SurfaceTextureDescriptor&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceTextureDescriptor()) SurfaceTextureDescriptor(std::move(aOther));
    mType = TSurfaceTextureDescriptor;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(const EGLImageDescriptor& aOther)
{
    new (mozilla::KnownNotNull, ptr_EGLImageDescriptor()) EGLImageDescriptor(aOther);
    mType = TEGLImageDescriptor;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(EGLImageDescriptor&& aOther)
{
    new (mozilla::KnownNotNull, ptr_EGLImageDescriptor()) EGLImageDescriptor(std::move(aOther));
    mType = TEGLImageDescriptor;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(const SurfaceDescriptorMacIOSurface& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorMacIOSurface()) SurfaceDescriptorMacIOSurface(aOther);
    mType = TSurfaceDescriptorMacIOSurface;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(SurfaceDescriptorMacIOSurface&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorMacIOSurface()) SurfaceDescriptorMacIOSurface(std::move(aOther));
    mType = TSurfaceDescriptorMacIOSurface;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(const SurfaceDescriptorSharedGLTexture& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorSharedGLTexture()) SurfaceDescriptorSharedGLTexture(aOther);
    mType = TSurfaceDescriptorSharedGLTexture;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(SurfaceDescriptorSharedGLTexture&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorSharedGLTexture()) SurfaceDescriptorSharedGLTexture(std::move(aOther));
    mType = TSurfaceDescriptorSharedGLTexture;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(const SurfaceDescriptorGPUVideo& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorGPUVideo()) SurfaceDescriptorGPUVideo(aOther);
    mType = TSurfaceDescriptorGPUVideo;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(SurfaceDescriptorGPUVideo&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SurfaceDescriptorGPUVideo()) SurfaceDescriptorGPUVideo(std::move(aOther));
    mType = TSurfaceDescriptorGPUVideo;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(const null_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
    mType = Tnull_t;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(null_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aOther));
    mType = Tnull_t;
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(const SurfaceDescriptor& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TSurfaceDescriptorBuffer:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorBuffer()) SurfaceDescriptorBuffer((aOther).get_SurfaceDescriptorBuffer());
            break;
        }
    case TSurfaceDescriptorDIB:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDIB()) SurfaceDescriptorDIB((aOther).get_SurfaceDescriptorDIB());
            break;
        }
    case TSurfaceDescriptorD3D10:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10((aOther).get_SurfaceDescriptorD3D10());
            break;
        }
    case TSurfaceDescriptorFileMapping:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorFileMapping()) SurfaceDescriptorFileMapping((aOther).get_SurfaceDescriptorFileMapping());
            break;
        }
    case TSurfaceDescriptorDXGIYCbCr:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr((aOther).get_SurfaceDescriptorDXGIYCbCr());
            break;
        }
    case TSurfaceDescriptorX11:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorX11()) SurfaceDescriptorX11((aOther).get_SurfaceDescriptorX11());
            break;
        }
    case TSurfaceTextureDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceTextureDescriptor()) SurfaceTextureDescriptor((aOther).get_SurfaceTextureDescriptor());
            break;
        }
    case TEGLImageDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_EGLImageDescriptor()) EGLImageDescriptor((aOther).get_EGLImageDescriptor());
            break;
        }
    case TSurfaceDescriptorMacIOSurface:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorMacIOSurface()) SurfaceDescriptorMacIOSurface((aOther).get_SurfaceDescriptorMacIOSurface());
            break;
        }
    case TSurfaceDescriptorSharedGLTexture:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorSharedGLTexture()) SurfaceDescriptorSharedGLTexture((aOther).get_SurfaceDescriptorSharedGLTexture());
            break;
        }
    case TSurfaceDescriptorGPUVideo:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorGPUVideo()) SurfaceDescriptorGPUVideo((aOther).get_SurfaceDescriptorGPUVideo());
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT SurfaceDescriptor::SurfaceDescriptor(SurfaceDescriptor&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TSurfaceDescriptorBuffer:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorBuffer()) SurfaceDescriptorBuffer(std::move((aOther).get_SurfaceDescriptorBuffer()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorDIB:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDIB()) SurfaceDescriptorDIB(std::move((aOther).get_SurfaceDescriptorDIB()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorD3D10:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10(std::move((aOther).get_SurfaceDescriptorD3D10()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorFileMapping:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorFileMapping()) SurfaceDescriptorFileMapping(std::move((aOther).get_SurfaceDescriptorFileMapping()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorDXGIYCbCr:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr(std::move((aOther).get_SurfaceDescriptorDXGIYCbCr()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorX11:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorX11()) SurfaceDescriptorX11(std::move((aOther).get_SurfaceDescriptorX11()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceTextureDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceTextureDescriptor()) SurfaceTextureDescriptor(std::move((aOther).get_SurfaceTextureDescriptor()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TEGLImageDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_EGLImageDescriptor()) EGLImageDescriptor(std::move((aOther).get_EGLImageDescriptor()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorMacIOSurface:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorMacIOSurface()) SurfaceDescriptorMacIOSurface(std::move((aOther).get_SurfaceDescriptorMacIOSurface()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorSharedGLTexture:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorSharedGLTexture()) SurfaceDescriptorSharedGLTexture(std::move((aOther).get_SurfaceDescriptorSharedGLTexture()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorGPUVideo:
        {
            new (mozilla::KnownNotNull, ptr_SurfaceDescriptorGPUVideo()) SurfaceDescriptorGPUVideo(std::move((aOther).get_SurfaceDescriptorGPUVideo()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_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;
}

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

auto SurfaceDescriptor::operator=(const SurfaceDescriptorBuffer& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorBuffer)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorBuffer()) SurfaceDescriptorBuffer;
    }
    (*(ptr_SurfaceDescriptorBuffer())) = aRhs;
    mType = TSurfaceDescriptorBuffer;
    return (*(this));
}

auto SurfaceDescriptor::operator=(SurfaceDescriptorBuffer&& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorBuffer)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorBuffer()) SurfaceDescriptorBuffer;
    }
    (*(ptr_SurfaceDescriptorBuffer())) = std::move(aRhs);
    mType = TSurfaceDescriptorBuffer;
    return (*(this));
}

auto SurfaceDescriptor::operator=(const SurfaceDescriptorDIB& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorDIB)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDIB()) SurfaceDescriptorDIB;
    }
    (*(ptr_SurfaceDescriptorDIB())) = aRhs;
    mType = TSurfaceDescriptorDIB;
    return (*(this));
}

auto SurfaceDescriptor::operator=(SurfaceDescriptorDIB&& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorDIB)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDIB()) SurfaceDescriptorDIB;
    }
    (*(ptr_SurfaceDescriptorDIB())) = std::move(aRhs);
    mType = TSurfaceDescriptorDIB;
    return (*(this));
}

auto SurfaceDescriptor::operator=(const SurfaceDescriptorD3D10& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorD3D10)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10;
    }
    (*(ptr_SurfaceDescriptorD3D10())) = aRhs;
    mType = TSurfaceDescriptorD3D10;
    return (*(this));
}

auto SurfaceDescriptor::operator=(SurfaceDescriptorD3D10&& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorD3D10)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10;
    }
    (*(ptr_SurfaceDescriptorD3D10())) = std::move(aRhs);
    mType = TSurfaceDescriptorD3D10;
    return (*(this));
}

auto SurfaceDescriptor::operator=(const SurfaceDescriptorFileMapping& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorFileMapping)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorFileMapping()) SurfaceDescriptorFileMapping;
    }
    (*(ptr_SurfaceDescriptorFileMapping())) = aRhs;
    mType = TSurfaceDescriptorFileMapping;
    return (*(this));
}

auto SurfaceDescriptor::operator=(SurfaceDescriptorFileMapping&& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorFileMapping)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorFileMapping()) SurfaceDescriptorFileMapping;
    }
    (*(ptr_SurfaceDescriptorFileMapping())) = std::move(aRhs);
    mType = TSurfaceDescriptorFileMapping;
    return (*(this));
}

auto SurfaceDescriptor::operator=(const SurfaceDescriptorDXGIYCbCr& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorDXGIYCbCr)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr;
    }
    (*(ptr_SurfaceDescriptorDXGIYCbCr())) = aRhs;
    mType = TSurfaceDescriptorDXGIYCbCr;
    return (*(this));
}

auto SurfaceDescriptor::operator=(SurfaceDescriptorDXGIYCbCr&& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorDXGIYCbCr)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr;
    }
    (*(ptr_SurfaceDescriptorDXGIYCbCr())) = std::move(aRhs);
    mType = TSurfaceDescriptorDXGIYCbCr;
    return (*(this));
}

auto SurfaceDescriptor::operator=(const SurfaceDescriptorX11& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorX11)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorX11()) SurfaceDescriptorX11;
    }
    (*(ptr_SurfaceDescriptorX11())) = aRhs;
    mType = TSurfaceDescriptorX11;
    return (*(this));
}

auto SurfaceDescriptor::operator=(SurfaceDescriptorX11&& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorX11)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorX11()) SurfaceDescriptorX11;
    }
    (*(ptr_SurfaceDescriptorX11())) = std::move(aRhs);
    mType = TSurfaceDescriptorX11;
    return (*(this));
}

auto SurfaceDescriptor::operator=(const SurfaceTextureDescriptor& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceTextureDescriptor)) {
        new (mozilla::KnownNotNull, ptr_SurfaceTextureDescriptor()) SurfaceTextureDescriptor;
    }
    (*(ptr_SurfaceTextureDescriptor())) = aRhs;
    mType = TSurfaceTextureDescriptor;
    return (*(this));
}

auto SurfaceDescriptor::operator=(SurfaceTextureDescriptor&& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceTextureDescriptor)) {
        new (mozilla::KnownNotNull, ptr_SurfaceTextureDescriptor()) SurfaceTextureDescriptor;
    }
    (*(ptr_SurfaceTextureDescriptor())) = std::move(aRhs);
    mType = TSurfaceTextureDescriptor;
    return (*(this));
}

auto SurfaceDescriptor::operator=(const EGLImageDescriptor& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TEGLImageDescriptor)) {
        new (mozilla::KnownNotNull, ptr_EGLImageDescriptor()) EGLImageDescriptor;
    }
    (*(ptr_EGLImageDescriptor())) = aRhs;
    mType = TEGLImageDescriptor;
    return (*(this));
}

auto SurfaceDescriptor::operator=(EGLImageDescriptor&& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TEGLImageDescriptor)) {
        new (mozilla::KnownNotNull, ptr_EGLImageDescriptor()) EGLImageDescriptor;
    }
    (*(ptr_EGLImageDescriptor())) = std::move(aRhs);
    mType = TEGLImageDescriptor;
    return (*(this));
}

auto SurfaceDescriptor::operator=(const SurfaceDescriptorMacIOSurface& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorMacIOSurface)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorMacIOSurface()) SurfaceDescriptorMacIOSurface;
    }
    (*(ptr_SurfaceDescriptorMacIOSurface())) = aRhs;
    mType = TSurfaceDescriptorMacIOSurface;
    return (*(this));
}

auto SurfaceDescriptor::operator=(SurfaceDescriptorMacIOSurface&& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorMacIOSurface)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorMacIOSurface()) SurfaceDescriptorMacIOSurface;
    }
    (*(ptr_SurfaceDescriptorMacIOSurface())) = std::move(aRhs);
    mType = TSurfaceDescriptorMacIOSurface;
    return (*(this));
}

auto SurfaceDescriptor::operator=(const SurfaceDescriptorSharedGLTexture& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorSharedGLTexture)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorSharedGLTexture()) SurfaceDescriptorSharedGLTexture;
    }
    (*(ptr_SurfaceDescriptorSharedGLTexture())) = aRhs;
    mType = TSurfaceDescriptorSharedGLTexture;
    return (*(this));
}

auto SurfaceDescriptor::operator=(SurfaceDescriptorSharedGLTexture&& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorSharedGLTexture)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorSharedGLTexture()) SurfaceDescriptorSharedGLTexture;
    }
    (*(ptr_SurfaceDescriptorSharedGLTexture())) = std::move(aRhs);
    mType = TSurfaceDescriptorSharedGLTexture;
    return (*(this));
}

auto SurfaceDescriptor::operator=(const SurfaceDescriptorGPUVideo& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorGPUVideo)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorGPUVideo()) SurfaceDescriptorGPUVideo;
    }
    (*(ptr_SurfaceDescriptorGPUVideo())) = aRhs;
    mType = TSurfaceDescriptorGPUVideo;
    return (*(this));
}

auto SurfaceDescriptor::operator=(SurfaceDescriptorGPUVideo&& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(TSurfaceDescriptorGPUVideo)) {
        new (mozilla::KnownNotNull, ptr_SurfaceDescriptorGPUVideo()) SurfaceDescriptorGPUVideo;
    }
    (*(ptr_SurfaceDescriptorGPUVideo())) = std::move(aRhs);
    mType = TSurfaceDescriptorGPUVideo;
    return (*(this));
}

auto SurfaceDescriptor::operator=(const null_t& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(Tnull_t)) {
        new (mozilla::KnownNotNull, ptr_null_t()) null_t;
    }
    (*(ptr_null_t())) = aRhs;
    mType = Tnull_t;
    return (*(this));
}

auto SurfaceDescriptor::operator=(null_t&& aRhs) -> SurfaceDescriptor&
{
    if (MaybeDestroy(Tnull_t)) {
        new (mozilla::KnownNotNull, ptr_null_t()) null_t;
    }
    (*(ptr_null_t())) = std::move(aRhs);
    mType = Tnull_t;
    return (*(this));
}

auto SurfaceDescriptor::operator=(const SurfaceDescriptor& aRhs) -> SurfaceDescriptor&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TSurfaceDescriptorBuffer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorBuffer()) SurfaceDescriptorBuffer;
            }
            (*(ptr_SurfaceDescriptorBuffer())) = (aRhs).get_SurfaceDescriptorBuffer();
            break;
        }
    case TSurfaceDescriptorDIB:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDIB()) SurfaceDescriptorDIB;
            }
            (*(ptr_SurfaceDescriptorDIB())) = (aRhs).get_SurfaceDescriptorDIB();
            break;
        }
    case TSurfaceDescriptorD3D10:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10;
            }
            (*(ptr_SurfaceDescriptorD3D10())) = (aRhs).get_SurfaceDescriptorD3D10();
            break;
        }
    case TSurfaceDescriptorFileMapping:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorFileMapping()) SurfaceDescriptorFileMapping;
            }
            (*(ptr_SurfaceDescriptorFileMapping())) = (aRhs).get_SurfaceDescriptorFileMapping();
            break;
        }
    case TSurfaceDescriptorDXGIYCbCr:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr;
            }
            (*(ptr_SurfaceDescriptorDXGIYCbCr())) = (aRhs).get_SurfaceDescriptorDXGIYCbCr();
            break;
        }
    case TSurfaceDescriptorX11:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorX11()) SurfaceDescriptorX11;
            }
            (*(ptr_SurfaceDescriptorX11())) = (aRhs).get_SurfaceDescriptorX11();
            break;
        }
    case TSurfaceTextureDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceTextureDescriptor()) SurfaceTextureDescriptor;
            }
            (*(ptr_SurfaceTextureDescriptor())) = (aRhs).get_SurfaceTextureDescriptor();
            break;
        }
    case TEGLImageDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_EGLImageDescriptor()) EGLImageDescriptor;
            }
            (*(ptr_EGLImageDescriptor())) = (aRhs).get_EGLImageDescriptor();
            break;
        }
    case TSurfaceDescriptorMacIOSurface:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorMacIOSurface()) SurfaceDescriptorMacIOSurface;
            }
            (*(ptr_SurfaceDescriptorMacIOSurface())) = (aRhs).get_SurfaceDescriptorMacIOSurface();
            break;
        }
    case TSurfaceDescriptorSharedGLTexture:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorSharedGLTexture()) SurfaceDescriptorSharedGLTexture;
            }
            (*(ptr_SurfaceDescriptorSharedGLTexture())) = (aRhs).get_SurfaceDescriptorSharedGLTexture();
            break;
        }
    case TSurfaceDescriptorGPUVideo:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorGPUVideo()) SurfaceDescriptorGPUVideo;
            }
            (*(ptr_SurfaceDescriptorGPUVideo())) = (aRhs).get_SurfaceDescriptorGPUVideo();
            break;
        }
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = (aRhs).get_null_t();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto SurfaceDescriptor::operator=(SurfaceDescriptor&& aRhs) -> SurfaceDescriptor&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TSurfaceDescriptorBuffer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorBuffer()) SurfaceDescriptorBuffer;
            }
            (*(ptr_SurfaceDescriptorBuffer())) = std::move((aRhs).get_SurfaceDescriptorBuffer());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorDIB:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDIB()) SurfaceDescriptorDIB;
            }
            (*(ptr_SurfaceDescriptorDIB())) = std::move((aRhs).get_SurfaceDescriptorDIB());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorD3D10:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10;
            }
            (*(ptr_SurfaceDescriptorD3D10())) = std::move((aRhs).get_SurfaceDescriptorD3D10());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorFileMapping:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorFileMapping()) SurfaceDescriptorFileMapping;
            }
            (*(ptr_SurfaceDescriptorFileMapping())) = std::move((aRhs).get_SurfaceDescriptorFileMapping());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorDXGIYCbCr:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorDXGIYCbCr()) SurfaceDescriptorDXGIYCbCr;
            }
            (*(ptr_SurfaceDescriptorDXGIYCbCr())) = std::move((aRhs).get_SurfaceDescriptorDXGIYCbCr());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorX11:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorX11()) SurfaceDescriptorX11;
            }
            (*(ptr_SurfaceDescriptorX11())) = std::move((aRhs).get_SurfaceDescriptorX11());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceTextureDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceTextureDescriptor()) SurfaceTextureDescriptor;
            }
            (*(ptr_SurfaceTextureDescriptor())) = std::move((aRhs).get_SurfaceTextureDescriptor());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TEGLImageDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_EGLImageDescriptor()) EGLImageDescriptor;
            }
            (*(ptr_EGLImageDescriptor())) = std::move((aRhs).get_EGLImageDescriptor());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorMacIOSurface:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorMacIOSurface()) SurfaceDescriptorMacIOSurface;
            }
            (*(ptr_SurfaceDescriptorMacIOSurface())) = std::move((aRhs).get_SurfaceDescriptorMacIOSurface());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorSharedGLTexture:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorSharedGLTexture()) SurfaceDescriptorSharedGLTexture;
            }
            (*(ptr_SurfaceDescriptorSharedGLTexture())) = std::move((aRhs).get_SurfaceDescriptorSharedGLTexture());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TSurfaceDescriptorGPUVideo:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SurfaceDescriptorGPUVideo()) SurfaceDescriptorGPUVideo;
            }
            (*(ptr_SurfaceDescriptorGPUVideo())) = std::move((aRhs).get_SurfaceDescriptorGPUVideo());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = std::move((aRhs).get_null_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 SurfaceDescriptor::operator==(const SurfaceDescriptorBuffer& aRhs) const -> bool
{
    return (get_SurfaceDescriptorBuffer()) == (aRhs);
}

auto SurfaceDescriptor::operator==(const SurfaceDescriptorDIB& aRhs) const -> bool
{
    return (get_SurfaceDescriptorDIB()) == (aRhs);
}

auto SurfaceDescriptor::operator==(const SurfaceDescriptorD3D10& aRhs) const -> bool
{
    return (get_SurfaceDescriptorD3D10()) == (aRhs);
}

auto SurfaceDescriptor::operator==(const SurfaceDescriptorFileMapping& aRhs) const -> bool
{
    return (get_SurfaceDescriptorFileMapping()) == (aRhs);
}

auto SurfaceDescriptor::operator==(const SurfaceDescriptorDXGIYCbCr& aRhs) const -> bool
{
    return (get_SurfaceDescriptorDXGIYCbCr()) == (aRhs);
}

auto SurfaceDescriptor::operator==(const SurfaceDescriptorX11& aRhs) const -> bool
{
    return (get_SurfaceDescriptorX11()) == (aRhs);
}

auto SurfaceDescriptor::operator==(const SurfaceTextureDescriptor& aRhs) const -> bool
{
    return (get_SurfaceTextureDescriptor()) == (aRhs);
}

auto SurfaceDescriptor::operator==(const EGLImageDescriptor& aRhs) const -> bool
{
    return (get_EGLImageDescriptor()) == (aRhs);
}

auto SurfaceDescriptor::operator==(const SurfaceDescriptorMacIOSurface& aRhs) const -> bool
{
    return (get_SurfaceDescriptorMacIOSurface()) == (aRhs);
}

auto SurfaceDescriptor::operator==(const SurfaceDescriptorSharedGLTexture& aRhs) const -> bool
{
    return (get_SurfaceDescriptorSharedGLTexture()) == (aRhs);
}

auto SurfaceDescriptor::operator==(const SurfaceDescriptorGPUVideo& aRhs) const -> bool
{
    return (get_SurfaceDescriptorGPUVideo()) == (aRhs);
}

auto SurfaceDescriptor::operator==(const null_t& aRhs) const -> bool
{
    return (get_null_t()) == (aRhs);
}

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

    switch (type()) {
    case TSurfaceDescriptorBuffer:
        {
            return (get_SurfaceDescriptorBuffer()) == ((aRhs).get_SurfaceDescriptorBuffer());
        }
    case TSurfaceDescriptorDIB:
        {
            return (get_SurfaceDescriptorDIB()) == ((aRhs).get_SurfaceDescriptorDIB());
        }
    case TSurfaceDescriptorD3D10:
        {
            return (get_SurfaceDescriptorD3D10()) == ((aRhs).get_SurfaceDescriptorD3D10());
        }
    case TSurfaceDescriptorFileMapping:
        {
            return (get_SurfaceDescriptorFileMapping()) == ((aRhs).get_SurfaceDescriptorFileMapping());
        }
    case TSurfaceDescriptorDXGIYCbCr:
        {
            return (get_SurfaceDescriptorDXGIYCbCr()) == ((aRhs).get_SurfaceDescriptorDXGIYCbCr());
        }
    case TSurfaceDescriptorX11:
        {
            return (get_SurfaceDescriptorX11()) == ((aRhs).get_SurfaceDescriptorX11());
        }
    case TSurfaceTextureDescriptor:
        {
            return (get_SurfaceTextureDescriptor()) == ((aRhs).get_SurfaceTextureDescriptor());
        }
    case TEGLImageDescriptor:
        {
            return (get_EGLImageDescriptor()) == ((aRhs).get_EGLImageDescriptor());
        }
    case TSurfaceDescriptorMacIOSurface:
        {
            return (get_SurfaceDescriptorMacIOSurface()) == ((aRhs).get_SurfaceDescriptorMacIOSurface());
        }
    case TSurfaceDescriptorSharedGLTexture:
        {
            return (get_SurfaceDescriptorSharedGLTexture()) == ((aRhs).get_SurfaceDescriptorSharedGLTexture());
        }
    case TSurfaceDescriptorGPUVideo:
        {
            return (get_SurfaceDescriptorGPUVideo()) == ((aRhs).get_SurfaceDescriptorGPUVideo());
        }
    case Tnull_t:
        {
            return (get_null_t()) == ((aRhs).get_null_t());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto SurfaceDescriptor::get(SurfaceDescriptorBuffer* aOutValue) const -> void
{
    (*(aOutValue)) = get_SurfaceDescriptorBuffer();
}

auto SurfaceDescriptor::get(SurfaceDescriptorDIB* aOutValue) const -> void
{
    (*(aOutValue)) = get_SurfaceDescriptorDIB();
}

auto SurfaceDescriptor::get(SurfaceDescriptorD3D10* aOutValue) const -> void
{
    (*(aOutValue)) = get_SurfaceDescriptorD3D10();
}

auto SurfaceDescriptor::get(SurfaceDescriptorFileMapping* aOutValue) const -> void
{
    (*(aOutValue)) = get_SurfaceDescriptorFileMapping();
}

auto SurfaceDescriptor::get(SurfaceDescriptorDXGIYCbCr* aOutValue) const -> void
{
    (*(aOutValue)) = get_SurfaceDescriptorDXGIYCbCr();
}

auto SurfaceDescriptor::get(SurfaceDescriptorX11* aOutValue) const -> void
{
    (*(aOutValue)) = get_SurfaceDescriptorX11();
}

auto SurfaceDescriptor::get(SurfaceTextureDescriptor* aOutValue) const -> void
{
    (*(aOutValue)) = get_SurfaceTextureDescriptor();
}

auto SurfaceDescriptor::get(EGLImageDescriptor* aOutValue) const -> void
{
    (*(aOutValue)) = get_EGLImageDescriptor();
}

auto SurfaceDescriptor::get(SurfaceDescriptorMacIOSurface* aOutValue) const -> void
{
    (*(aOutValue)) = get_SurfaceDescriptorMacIOSurface();
}

auto SurfaceDescriptor::get(SurfaceDescriptorSharedGLTexture* aOutValue) const -> void
{
    (*(aOutValue)) = get_SurfaceDescriptorSharedGLTexture();
}

auto SurfaceDescriptor::get(SurfaceDescriptorGPUVideo* aOutValue) const -> void
{
    (*(aOutValue)) = get_SurfaceDescriptorGPUVideo();
}

auto SurfaceDescriptor::get(null_t* aOutValue) const -> void
{
    (*(aOutValue)) = get_null_t();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TSurfaceDescriptorBuffer:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SurfaceDescriptorBuffer());
            // Sentinel = 'TSurfaceDescriptorBuffer'
            (aMsg)->WriteSentinel(2202696360);
            return;
        }
    case union__::TSurfaceDescriptorDIB:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SurfaceDescriptorDIB());
            // Sentinel = 'TSurfaceDescriptorDIB'
            (aMsg)->WriteSentinel(998410538);
            return;
        }
    case union__::TSurfaceDescriptorD3D10:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SurfaceDescriptorD3D10());
            // Sentinel = 'TSurfaceDescriptorD3D10'
            (aMsg)->WriteSentinel(2753564567);
            return;
        }
    case union__::TSurfaceDescriptorFileMapping:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SurfaceDescriptorFileMapping());
            // Sentinel = 'TSurfaceDescriptorFileMapping'
            (aMsg)->WriteSentinel(722196935);
            return;
        }
    case union__::TSurfaceDescriptorDXGIYCbCr:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SurfaceDescriptorDXGIYCbCr());
            // Sentinel = 'TSurfaceDescriptorDXGIYCbCr'
            (aMsg)->WriteSentinel(3061212892);
            return;
        }
    case union__::TSurfaceDescriptorX11:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SurfaceDescriptorX11());
            // Sentinel = 'TSurfaceDescriptorX11'
            (aMsg)->WriteSentinel(3923930613);
            return;
        }
    case union__::TSurfaceTextureDescriptor:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SurfaceTextureDescriptor());
            // Sentinel = 'TSurfaceTextureDescriptor'
            (aMsg)->WriteSentinel(2253946800);
            return;
        }
    case union__::TEGLImageDescriptor:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_EGLImageDescriptor());
            // Sentinel = 'TEGLImageDescriptor'
            (aMsg)->WriteSentinel(2680446099);
            return;
        }
    case union__::TSurfaceDescriptorMacIOSurface:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SurfaceDescriptorMacIOSurface());
            // Sentinel = 'TSurfaceDescriptorMacIOSurface'
            (aMsg)->WriteSentinel(4267688786);
            return;
        }
    case union__::TSurfaceDescriptorSharedGLTexture:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SurfaceDescriptorSharedGLTexture());
            // Sentinel = 'TSurfaceDescriptorSharedGLTexture'
            (aMsg)->WriteSentinel(4169514976);
            return;
        }
    case union__::TSurfaceDescriptorGPUVideo:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SurfaceDescriptorGPUVideo());
            // Sentinel = 'TSurfaceDescriptorGPUVideo'
            (aMsg)->WriteSentinel(2406892431);
            return;
        }
    case union__::Tnull_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aMsg)->WriteSentinel(3731137201);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TSurfaceDescriptorBuffer:
        {
            mozilla::layers::SurfaceDescriptorBuffer tmp = mozilla::layers::SurfaceDescriptorBuffer();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SurfaceDescriptorBuffer())))))) {
                (aActor)->FatalError("Error deserializing variant TSurfaceDescriptorBuffer of union SurfaceDescriptor");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorBuffer'
            if ((!((aMsg)->ReadSentinel(aIter, 2202696360)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSurfaceDescriptorBuffer of union SurfaceDescriptor");
                return false;
            }
            return true;
        }
    case union__::TSurfaceDescriptorDIB:
        {
            mozilla::layers::SurfaceDescriptorDIB tmp = mozilla::layers::SurfaceDescriptorDIB();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SurfaceDescriptorDIB())))))) {
                (aActor)->FatalError("Error deserializing variant TSurfaceDescriptorDIB of union SurfaceDescriptor");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorDIB'
            if ((!((aMsg)->ReadSentinel(aIter, 998410538)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSurfaceDescriptorDIB of union SurfaceDescriptor");
                return false;
            }
            return true;
        }
    case union__::TSurfaceDescriptorD3D10:
        {
            mozilla::layers::SurfaceDescriptorD3D10 tmp = mozilla::layers::SurfaceDescriptorD3D10();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SurfaceDescriptorD3D10())))))) {
                (aActor)->FatalError("Error deserializing variant TSurfaceDescriptorD3D10 of union SurfaceDescriptor");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorD3D10'
            if ((!((aMsg)->ReadSentinel(aIter, 2753564567)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSurfaceDescriptorD3D10 of union SurfaceDescriptor");
                return false;
            }
            return true;
        }
    case union__::TSurfaceDescriptorFileMapping:
        {
            mozilla::layers::SurfaceDescriptorFileMapping tmp = mozilla::layers::SurfaceDescriptorFileMapping();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SurfaceDescriptorFileMapping())))))) {
                (aActor)->FatalError("Error deserializing variant TSurfaceDescriptorFileMapping of union SurfaceDescriptor");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorFileMapping'
            if ((!((aMsg)->ReadSentinel(aIter, 722196935)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSurfaceDescriptorFileMapping of union SurfaceDescriptor");
                return false;
            }
            return true;
        }
    case union__::TSurfaceDescriptorDXGIYCbCr:
        {
            mozilla::layers::SurfaceDescriptorDXGIYCbCr tmp = mozilla::layers::SurfaceDescriptorDXGIYCbCr();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SurfaceDescriptorDXGIYCbCr())))))) {
                (aActor)->FatalError("Error deserializing variant TSurfaceDescriptorDXGIYCbCr of union SurfaceDescriptor");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorDXGIYCbCr'
            if ((!((aMsg)->ReadSentinel(aIter, 3061212892)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSurfaceDescriptorDXGIYCbCr of union SurfaceDescriptor");
                return false;
            }
            return true;
        }
    case union__::TSurfaceDescriptorX11:
        {
            mozilla::layers::SurfaceDescriptorX11 tmp = mozilla::layers::SurfaceDescriptorX11();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SurfaceDescriptorX11())))))) {
                (aActor)->FatalError("Error deserializing variant TSurfaceDescriptorX11 of union SurfaceDescriptor");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorX11'
            if ((!((aMsg)->ReadSentinel(aIter, 3923930613)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSurfaceDescriptorX11 of union SurfaceDescriptor");
                return false;
            }
            return true;
        }
    case union__::TSurfaceTextureDescriptor:
        {
            mozilla::layers::SurfaceTextureDescriptor tmp = mozilla::layers::SurfaceTextureDescriptor();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SurfaceTextureDescriptor())))))) {
                (aActor)->FatalError("Error deserializing variant TSurfaceTextureDescriptor of union SurfaceDescriptor");
                return false;
            }
            // Sentinel = 'TSurfaceTextureDescriptor'
            if ((!((aMsg)->ReadSentinel(aIter, 2253946800)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSurfaceTextureDescriptor of union SurfaceDescriptor");
                return false;
            }
            return true;
        }
    case union__::TEGLImageDescriptor:
        {
            mozilla::layers::EGLImageDescriptor tmp = mozilla::layers::EGLImageDescriptor();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_EGLImageDescriptor())))))) {
                (aActor)->FatalError("Error deserializing variant TEGLImageDescriptor of union SurfaceDescriptor");
                return false;
            }
            // Sentinel = 'TEGLImageDescriptor'
            if ((!((aMsg)->ReadSentinel(aIter, 2680446099)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TEGLImageDescriptor of union SurfaceDescriptor");
                return false;
            }
            return true;
        }
    case union__::TSurfaceDescriptorMacIOSurface:
        {
            mozilla::layers::SurfaceDescriptorMacIOSurface tmp = mozilla::layers::SurfaceDescriptorMacIOSurface();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SurfaceDescriptorMacIOSurface())))))) {
                (aActor)->FatalError("Error deserializing variant TSurfaceDescriptorMacIOSurface of union SurfaceDescriptor");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorMacIOSurface'
            if ((!((aMsg)->ReadSentinel(aIter, 4267688786)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSurfaceDescriptorMacIOSurface of union SurfaceDescriptor");
                return false;
            }
            return true;
        }
    case union__::TSurfaceDescriptorSharedGLTexture:
        {
            mozilla::layers::SurfaceDescriptorSharedGLTexture tmp = mozilla::layers::SurfaceDescriptorSharedGLTexture();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SurfaceDescriptorSharedGLTexture())))))) {
                (aActor)->FatalError("Error deserializing variant TSurfaceDescriptorSharedGLTexture of union SurfaceDescriptor");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorSharedGLTexture'
            if ((!((aMsg)->ReadSentinel(aIter, 4169514976)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSurfaceDescriptorSharedGLTexture of union SurfaceDescriptor");
                return false;
            }
            return true;
        }
    case union__::TSurfaceDescriptorGPUVideo:
        {
            mozilla::layers::SurfaceDescriptorGPUVideo tmp = mozilla::layers::SurfaceDescriptorGPUVideo();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SurfaceDescriptorGPUVideo())))))) {
                (aActor)->FatalError("Error deserializing variant TSurfaceDescriptorGPUVideo of union SurfaceDescriptor");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorGPUVideo'
            if ((!((aMsg)->ReadSentinel(aIter, 2406892431)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSurfaceDescriptorGPUVideo of union SurfaceDescriptor");
                return false;
            }
            return true;
        }
    case union__::Tnull_t:
        {
            mozilla::null_t tmp = mozilla::null_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_null_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tnull_t of union SurfaceDescriptor");
                return false;
            }
            // Sentinel = 'Tnull_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3731137201)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union SurfaceDescriptor");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53