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


#include "gfxipc/ShadowLayerUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "gfxipc/ShadowLayerUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/layers/WebRenderMessageUtils.h"
#include "mozilla/layers/PCompositorBridgeParent.h"
#include "mozilla/layers/PCompositorBridgeChild.h"
#include "mozilla/layers/PTextureParent.h"
#include "mozilla/layers/PTextureChild.h"
#include "mozilla/layers/LayersMessages.h"

#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"


//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct TargetConfig|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::TargetConfig>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).naturalBounds());
    // Sentinel = 'naturalBounds'
    (aWriter)->WriteSentinel(634062179);
    IPC::WriteParam(aWriter, (aVar).rotation());
    // Sentinel = 'rotation'
    (aWriter)->WriteSentinel(261423985);
    IPC::WriteParam(aWriter, (aVar).orientation());
    // Sentinel = 'orientation'
    (aWriter)->WriteSentinel(471008429);
    IPC::WriteParam(aWriter, (aVar).clearRegion());
    // Sentinel = 'clearRegion'
    (aWriter)->WriteSentinel(440337516);
}

auto ParamTraits<::mozilla::layers::TargetConfig>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___naturalBounds = IPC::ReadParam<::mozilla::gfx::IntRect>(aReader);
    if (!maybe___naturalBounds) {
        aReader->FatalError("Error deserializing 'naturalBounds' (IntRect) member of 'TargetConfig'");
        return {};

    }
    auto& _naturalBounds = *maybe___naturalBounds;
    // Sentinel = 'naturalBounds'
    if ((!((aReader)->ReadSentinel(634062179)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'naturalBounds' (IntRect) member of 'TargetConfig'");
        return {};
    }
    auto maybe___rotation = IPC::ReadParam<::mozilla::ScreenRotation>(aReader);
    if (!maybe___rotation) {
        aReader->FatalError("Error deserializing 'rotation' (ScreenRotation) member of 'TargetConfig'");
        return {};

    }
    auto& _rotation = *maybe___rotation;
    // Sentinel = 'rotation'
    if ((!((aReader)->ReadSentinel(261423985)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'rotation' (ScreenRotation) member of 'TargetConfig'");
        return {};
    }
    auto maybe___orientation = IPC::ReadParam<::mozilla::hal::ScreenOrientation>(aReader);
    if (!maybe___orientation) {
        aReader->FatalError("Error deserializing 'orientation' (ScreenOrientation) member of 'TargetConfig'");
        return {};

    }
    auto& _orientation = *maybe___orientation;
    // Sentinel = 'orientation'
    if ((!((aReader)->ReadSentinel(471008429)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'orientation' (ScreenOrientation) member of 'TargetConfig'");
        return {};
    }
    auto maybe___clearRegion = IPC::ReadParam<::nsIntRegion>(aReader);
    if (!maybe___clearRegion) {
        aReader->FatalError("Error deserializing 'clearRegion' (nsIntRegion) member of 'TargetConfig'");
        return {};

    }
    auto& _clearRegion = *maybe___clearRegion;
    // Sentinel = 'clearRegion'
    if ((!((aReader)->ReadSentinel(440337516)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'clearRegion' (nsIntRegion) member of 'TargetConfig'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_naturalBounds),
            std::move(_rotation),
            std::move(_orientation),
            std::move(_clearRegion)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpAttachCompositable|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::OpAttachCompositable>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).layer());
    // Sentinel = 'layer'
    (aWriter)->WriteSentinel(105644574);
    IPC::WriteParam(aWriter, (aVar).compositable());
    // Sentinel = 'compositable'
    (aWriter)->WriteSentinel(551879939);
}

auto ParamTraits<::mozilla::layers::OpAttachCompositable>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___layer = IPC::ReadParam<::mozilla::layers::LayerHandle>(aReader);
    if (!maybe___layer) {
        aReader->FatalError("Error deserializing 'layer' (LayerHandle) member of 'OpAttachCompositable'");
        return {};

    }
    auto& _layer = *maybe___layer;
    // Sentinel = 'layer'
    if ((!((aReader)->ReadSentinel(105644574)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'layer' (LayerHandle) member of 'OpAttachCompositable'");
        return {};
    }
    auto maybe___compositable = IPC::ReadParam<::mozilla::layers::CompositableHandle>(aReader);
    if (!maybe___compositable) {
        aReader->FatalError("Error deserializing 'compositable' (CompositableHandle) member of 'OpAttachCompositable'");
        return {};

    }
    auto& _compositable = *maybe___compositable;
    // Sentinel = 'compositable'
    if ((!((aReader)->ReadSentinel(551879939)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'compositable' (CompositableHandle) member of 'OpAttachCompositable'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_layer),
            std::move(_compositable)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpAttachAsyncCompositable|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::OpAttachAsyncCompositable>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).layer());
    // Sentinel = 'layer'
    (aWriter)->WriteSentinel(105644574);
    IPC::WriteParam(aWriter, (aVar).compositable());
    // Sentinel = 'compositable'
    (aWriter)->WriteSentinel(551879939);
}

auto ParamTraits<::mozilla::layers::OpAttachAsyncCompositable>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___layer = IPC::ReadParam<::mozilla::layers::LayerHandle>(aReader);
    if (!maybe___layer) {
        aReader->FatalError("Error deserializing 'layer' (LayerHandle) member of 'OpAttachAsyncCompositable'");
        return {};

    }
    auto& _layer = *maybe___layer;
    // Sentinel = 'layer'
    if ((!((aReader)->ReadSentinel(105644574)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'layer' (LayerHandle) member of 'OpAttachAsyncCompositable'");
        return {};
    }
    auto maybe___compositable = IPC::ReadParam<::mozilla::layers::CompositableHandle>(aReader);
    if (!maybe___compositable) {
        aReader->FatalError("Error deserializing 'compositable' (CompositableHandle) member of 'OpAttachAsyncCompositable'");
        return {};

    }
    auto& _compositable = *maybe___compositable;
    // Sentinel = 'compositable'
    if ((!((aReader)->ReadSentinel(551879939)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'compositable' (CompositableHandle) member of 'OpAttachAsyncCompositable'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_layer),
            std::move(_compositable)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct LayerColor|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla

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

auto ParamTraits<::mozilla::layers::LayerColor>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___value = IPC::ReadParam<::mozilla::gfx::DeviceColor>(aReader);
    if (!maybe___value) {
        aReader->FatalError("Error deserializing 'value' (DeviceColor) member of 'LayerColor'");
        return {};

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union Animatable|
//
namespace mozilla {
namespace layers {
auto Animatable::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tnull_t:
        {
            (ptr_null_t())->~null_t__tdef();
            break;
        }
    case Tfloat:
        {
            (ptr_float())->~float__tdef();
            break;
        }
    case Tnscolor:
        {
            (ptr_nscolor())->~nscolor__tdef();
            break;
        }
    case TStyleRotate:
        {
            (ptr_StyleRotate())->~StyleRotate__tdef();
            break;
        }
    case TStyleScale:
        {
            (ptr_StyleScale())->~StyleScale__tdef();
            break;
        }
    case TStyleTranslate:
        {
            (ptr_StyleTranslate())->~StyleTranslate__tdef();
            break;
        }
    case TStyleTransform:
        {
            (ptr_StyleTransform())->~StyleTransform__tdef();
            break;
        }
    case TStyleOffsetPath:
        {
            (ptr_StyleOffsetPath())->~StyleOffsetPath__tdef();
            break;
        }
    case TLengthPercentage:
        {
            (ptr_LengthPercentage())->~LengthPercentage__tdef();
            break;
        }
    case TStyleOffsetRotate:
        {
            (ptr_StyleOffsetRotate())->~StyleOffsetRotate__tdef();
            break;
        }
    case TStylePositionOrAuto:
        {
            (ptr_StylePositionOrAuto())->~StylePositionOrAuto__tdef();
            break;
        }
    case TStyleOffsetPosition:
        {
            (ptr_StyleOffsetPosition())->~StyleOffsetPosition__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

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

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

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

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

MOZ_IMPLICIT Animatable::Animatable(const nscolor& aOther)
{
    new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(aOther);
    mType = Tnscolor;
}

MOZ_IMPLICIT Animatable::Animatable(nscolor&& aOther)
{
    new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move(aOther));
    mType = Tnscolor;
}

MOZ_IMPLICIT Animatable::Animatable(const StyleRotate& aOther)
{
    new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate(aOther);
    mType = TStyleRotate;
}

MOZ_IMPLICIT Animatable::Animatable(StyleRotate&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate(std::move(aOther));
    mType = TStyleRotate;
}

MOZ_IMPLICIT Animatable::Animatable(const StyleScale& aOther)
{
    new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale(aOther);
    mType = TStyleScale;
}

MOZ_IMPLICIT Animatable::Animatable(StyleScale&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale(std::move(aOther));
    mType = TStyleScale;
}

MOZ_IMPLICIT Animatable::Animatable(const StyleTranslate& aOther)
{
    new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate(aOther);
    mType = TStyleTranslate;
}

MOZ_IMPLICIT Animatable::Animatable(StyleTranslate&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate(std::move(aOther));
    mType = TStyleTranslate;
}

MOZ_IMPLICIT Animatable::Animatable(const StyleTransform& aOther)
{
    new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform(aOther);
    mType = TStyleTransform;
}

MOZ_IMPLICIT Animatable::Animatable(StyleTransform&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform(std::move(aOther));
    mType = TStyleTransform;
}

MOZ_IMPLICIT Animatable::Animatable(const StyleOffsetPath& aOther)
{
    new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath(aOther);
    mType = TStyleOffsetPath;
}

MOZ_IMPLICIT Animatable::Animatable(StyleOffsetPath&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath(std::move(aOther));
    mType = TStyleOffsetPath;
}

MOZ_IMPLICIT Animatable::Animatable(const LengthPercentage& aOther)
{
    new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage(aOther);
    mType = TLengthPercentage;
}

MOZ_IMPLICIT Animatable::Animatable(LengthPercentage&& aOther)
{
    new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage(std::move(aOther));
    mType = TLengthPercentage;
}

MOZ_IMPLICIT Animatable::Animatable(const StyleOffsetRotate& aOther)
{
    new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate(aOther);
    mType = TStyleOffsetRotate;
}

MOZ_IMPLICIT Animatable::Animatable(StyleOffsetRotate&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate(std::move(aOther));
    mType = TStyleOffsetRotate;
}

MOZ_IMPLICIT Animatable::Animatable(const StylePositionOrAuto& aOther)
{
    new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto(aOther);
    mType = TStylePositionOrAuto;
}

MOZ_IMPLICIT Animatable::Animatable(StylePositionOrAuto&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto(std::move(aOther));
    mType = TStylePositionOrAuto;
}

MOZ_IMPLICIT Animatable::Animatable(const StyleOffsetPosition& aOther)
{
    new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition(aOther);
    mType = TStyleOffsetPosition;
}

MOZ_IMPLICIT Animatable::Animatable(StyleOffsetPosition&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition(std::move(aOther));
    mType = TStyleOffsetPosition;
}

MOZ_IMPLICIT Animatable::Animatable(const Animatable& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case Tfloat:
        {
            new (mozilla::KnownNotNull, ptr_float()) float((aOther).get_float());
            break;
        }
    case Tnscolor:
        {
            new (mozilla::KnownNotNull, ptr_nscolor()) nscolor((aOther).get_nscolor());
            break;
        }
    case TStyleRotate:
        {
            new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate((aOther).get_StyleRotate());
            break;
        }
    case TStyleScale:
        {
            new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale((aOther).get_StyleScale());
            break;
        }
    case TStyleTranslate:
        {
            new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate((aOther).get_StyleTranslate());
            break;
        }
    case TStyleTransform:
        {
            new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform((aOther).get_StyleTransform());
            break;
        }
    case TStyleOffsetPath:
        {
            new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath((aOther).get_StyleOffsetPath());
            break;
        }
    case TLengthPercentage:
        {
            new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage((aOther).get_LengthPercentage());
            break;
        }
    case TStyleOffsetRotate:
        {
            new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate((aOther).get_StyleOffsetRotate());
            break;
        }
    case TStylePositionOrAuto:
        {
            new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto((aOther).get_StylePositionOrAuto());
            break;
        }
    case TStyleOffsetPosition:
        {
            new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition((aOther).get_StyleOffsetPosition());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT Animatable::Animatable(Animatable&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tfloat:
        {
            new (mozilla::KnownNotNull, ptr_float()) float(std::move((aOther).get_float()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tnscolor:
        {
            new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move((aOther).get_nscolor()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStyleRotate:
        {
            new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate(std::move((aOther).get_StyleRotate()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStyleScale:
        {
            new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale(std::move((aOther).get_StyleScale()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStyleTranslate:
        {
            new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate(std::move((aOther).get_StyleTranslate()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStyleTransform:
        {
            new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform(std::move((aOther).get_StyleTransform()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStyleOffsetPath:
        {
            new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath(std::move((aOther).get_StyleOffsetPath()));
            (aOther).MaybeDestroy();
            break;
        }
    case TLengthPercentage:
        {
            new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage(std::move((aOther).get_LengthPercentage()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStyleOffsetRotate:
        {
            new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate(std::move((aOther).get_StyleOffsetRotate()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStylePositionOrAuto:
        {
            new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto(std::move((aOther).get_StylePositionOrAuto()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStyleOffsetPosition:
        {
            new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition(std::move((aOther).get_StyleOffsetPosition()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

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

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

auto Animatable::operator=(const nscolor& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(aRhs);
    mType = Tnscolor;
    return (*(this));
}

auto Animatable::operator=(nscolor&& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move(aRhs));
    mType = Tnscolor;
    return (*(this));
}

auto Animatable::operator=(const StyleRotate& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate(aRhs);
    mType = TStyleRotate;
    return (*(this));
}

auto Animatable::operator=(StyleRotate&& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate(std::move(aRhs));
    mType = TStyleRotate;
    return (*(this));
}

auto Animatable::operator=(const StyleScale& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale(aRhs);
    mType = TStyleScale;
    return (*(this));
}

auto Animatable::operator=(StyleScale&& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale(std::move(aRhs));
    mType = TStyleScale;
    return (*(this));
}

auto Animatable::operator=(const StyleTranslate& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate(aRhs);
    mType = TStyleTranslate;
    return (*(this));
}

auto Animatable::operator=(StyleTranslate&& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate(std::move(aRhs));
    mType = TStyleTranslate;
    return (*(this));
}

auto Animatable::operator=(const StyleTransform& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform(aRhs);
    mType = TStyleTransform;
    return (*(this));
}

auto Animatable::operator=(StyleTransform&& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform(std::move(aRhs));
    mType = TStyleTransform;
    return (*(this));
}

auto Animatable::operator=(const StyleOffsetPath& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath(aRhs);
    mType = TStyleOffsetPath;
    return (*(this));
}

auto Animatable::operator=(StyleOffsetPath&& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath(std::move(aRhs));
    mType = TStyleOffsetPath;
    return (*(this));
}

auto Animatable::operator=(const LengthPercentage& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage(aRhs);
    mType = TLengthPercentage;
    return (*(this));
}

auto Animatable::operator=(LengthPercentage&& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage(std::move(aRhs));
    mType = TLengthPercentage;
    return (*(this));
}

auto Animatable::operator=(const StyleOffsetRotate& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate(aRhs);
    mType = TStyleOffsetRotate;
    return (*(this));
}

auto Animatable::operator=(StyleOffsetRotate&& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate(std::move(aRhs));
    mType = TStyleOffsetRotate;
    return (*(this));
}

auto Animatable::operator=(const StylePositionOrAuto& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto(aRhs);
    mType = TStylePositionOrAuto;
    return (*(this));
}

auto Animatable::operator=(StylePositionOrAuto&& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto(std::move(aRhs));
    mType = TStylePositionOrAuto;
    return (*(this));
}

auto Animatable::operator=(const StyleOffsetPosition& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition(aRhs);
    mType = TStyleOffsetPosition;
    return (*(this));
}

auto Animatable::operator=(StyleOffsetPosition&& aRhs) -> Animatable&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition(std::move(aRhs));
    mType = TStyleOffsetPosition;
    return (*(this));
}

auto Animatable::operator=(const Animatable& aRhs) -> Animatable&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnull_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aRhs).get_null_t());
            break;
        }
    case Tfloat:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_float()) float((aRhs).get_float());
            break;
        }
    case Tnscolor:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nscolor()) nscolor((aRhs).get_nscolor());
            break;
        }
    case TStyleRotate:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate((aRhs).get_StyleRotate());
            break;
        }
    case TStyleScale:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale((aRhs).get_StyleScale());
            break;
        }
    case TStyleTranslate:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate((aRhs).get_StyleTranslate());
            break;
        }
    case TStyleTransform:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform((aRhs).get_StyleTransform());
            break;
        }
    case TStyleOffsetPath:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath((aRhs).get_StyleOffsetPath());
            break;
        }
    case TLengthPercentage:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage((aRhs).get_LengthPercentage());
            break;
        }
    case TStyleOffsetRotate:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate((aRhs).get_StyleOffsetRotate());
            break;
        }
    case TStylePositionOrAuto:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto((aRhs).get_StylePositionOrAuto());
            break;
        }
    case TStyleOffsetPosition:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition((aRhs).get_StyleOffsetPosition());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto Animatable::operator=(Animatable&& aRhs) -> Animatable&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnull_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aRhs).get_null_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tfloat:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_float()) float(std::move((aRhs).get_float()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tnscolor:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move((aRhs).get_nscolor()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStyleRotate:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate(std::move((aRhs).get_StyleRotate()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStyleScale:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale(std::move((aRhs).get_StyleScale()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStyleTranslate:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate(std::move((aRhs).get_StyleTranslate()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStyleTransform:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform(std::move((aRhs).get_StyleTransform()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStyleOffsetPath:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath(std::move((aRhs).get_StyleOffsetPath()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TLengthPercentage:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage(std::move((aRhs).get_LengthPercentage()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStyleOffsetRotate:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate(std::move((aRhs).get_StyleOffsetRotate()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStylePositionOrAuto:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto(std::move((aRhs).get_StylePositionOrAuto()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStyleOffsetPosition:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition(std::move((aRhs).get_StyleOffsetPosition()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

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

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

auto Animatable::operator==(const nscolor& aRhs) const -> bool
{
    return (get_nscolor()) == (aRhs);
}

auto Animatable::operator==(const StyleRotate& aRhs) const -> bool
{
    return (get_StyleRotate()) == (aRhs);
}

auto Animatable::operator==(const StyleScale& aRhs) const -> bool
{
    return (get_StyleScale()) == (aRhs);
}

auto Animatable::operator==(const StyleTranslate& aRhs) const -> bool
{
    return (get_StyleTranslate()) == (aRhs);
}

auto Animatable::operator==(const StyleTransform& aRhs) const -> bool
{
    return (get_StyleTransform()) == (aRhs);
}

auto Animatable::operator==(const StyleOffsetPath& aRhs) const -> bool
{
    return (get_StyleOffsetPath()) == (aRhs);
}

auto Animatable::operator==(const LengthPercentage& aRhs) const -> bool
{
    return (get_LengthPercentage()) == (aRhs);
}

auto Animatable::operator==(const StyleOffsetRotate& aRhs) const -> bool
{
    return (get_StyleOffsetRotate()) == (aRhs);
}

auto Animatable::operator==(const StylePositionOrAuto& aRhs) const -> bool
{
    return (get_StylePositionOrAuto()) == (aRhs);
}

auto Animatable::operator==(const StyleOffsetPosition& aRhs) const -> bool
{
    return (get_StyleOffsetPosition()) == (aRhs);
}

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

    switch (type()) {
    case Tnull_t:
        {
            return (get_null_t()) == ((aRhs).get_null_t());
        }
    case Tfloat:
        {
            return (get_float()) == ((aRhs).get_float());
        }
    case Tnscolor:
        {
            return (get_nscolor()) == ((aRhs).get_nscolor());
        }
    case TStyleRotate:
        {
            return (get_StyleRotate()) == ((aRhs).get_StyleRotate());
        }
    case TStyleScale:
        {
            return (get_StyleScale()) == ((aRhs).get_StyleScale());
        }
    case TStyleTranslate:
        {
            return (get_StyleTranslate()) == ((aRhs).get_StyleTranslate());
        }
    case TStyleTransform:
        {
            return (get_StyleTransform()) == ((aRhs).get_StyleTransform());
        }
    case TStyleOffsetPath:
        {
            return (get_StyleOffsetPath()) == ((aRhs).get_StyleOffsetPath());
        }
    case TLengthPercentage:
        {
            return (get_LengthPercentage()) == ((aRhs).get_LengthPercentage());
        }
    case TStyleOffsetRotate:
        {
            return (get_StyleOffsetRotate()) == ((aRhs).get_StyleOffsetRotate());
        }
    case TStylePositionOrAuto:
        {
            return (get_StylePositionOrAuto()) == ((aRhs).get_StylePositionOrAuto());
        }
    case TStyleOffsetPosition:
        {
            return (get_StyleOffsetPosition()) == ((aRhs).get_StyleOffsetPosition());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::Tnull_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aWriter)->WriteSentinel(190186211);
            return;
        }
    case union__::Tfloat:
        {
            IPC::WriteParam(aWriter, (aVar).get_float());
            // Sentinel = 'Tfloat'
            (aWriter)->WriteSentinel(137298539);
            return;
        }
    case union__::Tnscolor:
        {
            IPC::WriteParam(aWriter, (aVar).get_nscolor());
            // Sentinel = 'Tnscolor'
            (aWriter)->WriteSentinel(245039957);
            return;
        }
    case union__::TStyleRotate:
        {
            IPC::WriteParam(aWriter, (aVar).get_StyleRotate());
            // Sentinel = 'TStyleRotate'
            (aWriter)->WriteSentinel(516949205);
            return;
        }
    case union__::TStyleScale:
        {
            IPC::WriteParam(aWriter, (aVar).get_StyleScale());
            // Sentinel = 'TStyleScale'
            (aWriter)->WriteSentinel(429786190);
            return;
        }
    case union__::TStyleTranslate:
        {
            IPC::WriteParam(aWriter, (aVar).get_StyleTranslate());
            // Sentinel = 'TStyleTranslate'
            (aWriter)->WriteSentinel(801703444);
            return;
        }
    case union__::TStyleTransform:
        {
            IPC::WriteParam(aWriter, (aVar).get_StyleTransform());
            // Sentinel = 'TStyleTransform'
            (aWriter)->WriteSentinel(803145250);
            return;
        }
    case union__::TStyleOffsetPath:
        {
            IPC::WriteParam(aWriter, (aVar).get_StyleOffsetPath());
            // Sentinel = 'TStyleOffsetPath'
            (aWriter)->WriteSentinel(895944282);
            return;
        }
    case union__::TLengthPercentage:
        {
            IPC::WriteParam(aWriter, (aVar).get_LengthPercentage());
            // Sentinel = 'TLengthPercentage'
            (aWriter)->WriteSentinel(991102645);
            return;
        }
    case union__::TStyleOffsetRotate:
        {
            IPC::WriteParam(aWriter, (aVar).get_StyleOffsetRotate());
            // Sentinel = 'TStyleOffsetRotate'
            (aWriter)->WriteSentinel(1134888764);
            return;
        }
    case union__::TStylePositionOrAuto:
        {
            IPC::WriteParam(aWriter, (aVar).get_StylePositionOrAuto());
            // Sentinel = 'TStylePositionOrAuto'
            (aWriter)->WriteSentinel(1410598933);
            return;
        }
    case union__::TStyleOffsetPosition:
        {
            IPC::WriteParam(aWriter, (aVar).get_StyleOffsetPosition());
            // Sentinel = 'TStyleOffsetPosition'
            (aWriter)->WriteSentinel(1401358370);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union Animatable");
            return;
        }
    }
}

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

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

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

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tnull_t'
            if ((!((aReader)->ReadSentinel(190186211)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union Animatable");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tfloat:
        {
            auto maybe__tmp = IPC::ReadParam<float>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tfloat of union Animatable");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tfloat'
            if ((!((aReader)->ReadSentinel(137298539)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tfloat of union Animatable");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tnscolor:
        {
            auto maybe__tmp = IPC::ReadParam<::nscolor>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tnscolor of union Animatable");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tnscolor'
            if ((!((aReader)->ReadSentinel(245039957)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnscolor of union Animatable");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStyleRotate:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::StyleRotate>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStyleRotate of union Animatable");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStyleRotate'
            if ((!((aReader)->ReadSentinel(516949205)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStyleRotate of union Animatable");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStyleScale:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::StyleScale>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStyleScale of union Animatable");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStyleScale'
            if ((!((aReader)->ReadSentinel(429786190)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStyleScale of union Animatable");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStyleTranslate:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::StyleTranslate>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStyleTranslate of union Animatable");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStyleTranslate'
            if ((!((aReader)->ReadSentinel(801703444)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStyleTranslate of union Animatable");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStyleTransform:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::StyleTransform>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStyleTransform of union Animatable");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStyleTransform'
            if ((!((aReader)->ReadSentinel(803145250)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStyleTransform of union Animatable");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStyleOffsetPath:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::StyleOffsetPath>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStyleOffsetPath of union Animatable");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStyleOffsetPath'
            if ((!((aReader)->ReadSentinel(895944282)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStyleOffsetPath of union Animatable");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TLengthPercentage:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::LengthPercentage>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TLengthPercentage of union Animatable");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TLengthPercentage'
            if ((!((aReader)->ReadSentinel(991102645)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TLengthPercentage of union Animatable");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStyleOffsetRotate:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::StyleOffsetRotate>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStyleOffsetRotate of union Animatable");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStyleOffsetRotate'
            if ((!((aReader)->ReadSentinel(1134888764)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStyleOffsetRotate of union Animatable");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStylePositionOrAuto:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::StylePositionOrAuto>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStylePositionOrAuto of union Animatable");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStylePositionOrAuto'
            if ((!((aReader)->ReadSentinel(1410598933)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStylePositionOrAuto of union Animatable");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStyleOffsetPosition:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::StyleOffsetPosition>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStyleOffsetPosition of union Animatable");
                return {};

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct AnimationSegment|
//
namespace mozilla {
namespace layers {
auto AnimationSegment::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(AnimationSegment, endPortion_) - offsetof(AnimationSegment, startPortion_)) == 4,
        "Bad assumptions about field layout!");
    static_assert(
        (offsetof(AnimationSegment, endComposite_) - offsetof(AnimationSegment, startComposite_)) == 1,
        "Bad assumptions about field layout!");
}

} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::AnimationSegment>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).startState());
    // Sentinel = 'startState'
    (aWriter)->WriteSentinel(391709744);
    IPC::WriteParam(aWriter, (aVar).endState());
    // Sentinel = 'endState'
    (aWriter)->WriteSentinel(241763129);
    IPC::WriteParam(aWriter, (aVar).sampleFn());
    // Sentinel = 'sampleFn'
    (aWriter)->WriteSentinel(249430839);
    (aWriter)->WriteBytes((&((aVar).startPortion())), 8);
    // Sentinel = 'startPortion | endPortion'
    (aWriter)->WriteSentinel(2191526392);
    (aWriter)->WriteBytes((&((aVar).startComposite())), 2);
    // Sentinel = 'startComposite | endComposite'
    (aWriter)->WriteSentinel(2918452104);
}

auto ParamTraits<::mozilla::layers::AnimationSegment>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___startState = IPC::ReadParam<::mozilla::layers::Animatable>(aReader);
    if (!maybe___startState) {
        aReader->FatalError("Error deserializing 'startState' (Animatable) member of 'AnimationSegment'");
        return {};

    }
    auto& _startState = *maybe___startState;
    // Sentinel = 'startState'
    if ((!((aReader)->ReadSentinel(391709744)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'startState' (Animatable) member of 'AnimationSegment'");
        return {};
    }
    auto maybe___endState = IPC::ReadParam<::mozilla::layers::Animatable>(aReader);
    if (!maybe___endState) {
        aReader->FatalError("Error deserializing 'endState' (Animatable) member of 'AnimationSegment'");
        return {};

    }
    auto& _endState = *maybe___endState;
    // Sentinel = 'endState'
    if ((!((aReader)->ReadSentinel(241763129)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'endState' (Animatable) member of 'AnimationSegment'");
        return {};
    }
    auto maybe___sampleFn = IPC::ReadParam<mozilla::Maybe<::mozilla::StyleComputedTimingFunction>>(aReader);
    if (!maybe___sampleFn) {
        aReader->FatalError("Error deserializing 'sampleFn' (StyleComputedTimingFunction?) member of 'AnimationSegment'");
        return {};

    }
    auto& _sampleFn = *maybe___sampleFn;
    // Sentinel = 'sampleFn'
    if ((!((aReader)->ReadSentinel(249430839)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'sampleFn' (StyleComputedTimingFunction?) member of 'AnimationSegment'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_startState),
            std::move(_endState),
            float{0},
            float{0},
            ::uint8_t{0},
            ::uint8_t{0},
            std::move(_sampleFn)};
    if ((!((aReader)->ReadBytesInto((&((result__)->startPortion())), 8)))) {
        aReader->FatalError("Error bulk reading fields from float");
        return {};
    }
    // Sentinel = 'startPortion | endPortion'
    if ((!((aReader)->ReadSentinel(2191526392)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from float");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->startComposite())), 2)))) {
        aReader->FatalError("Error bulk reading fields from uint8_t");
        return {};
    }
    // Sentinel = 'startComposite | endComposite'
    if ((!((aReader)->ReadSentinel(2918452104)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint8_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct MotionPathData|
//
namespace mozilla {
namespace layers {
auto MotionPathData::operator==(const MotionPathData& _o) const -> bool
{
    if ((!((origin()) == ((_o).origin())))) {
        return false;
    }
    if ((!((anchorAdjustment()) == ((_o).anchorAdjustment())))) {
        return false;
    }
    if ((!((coordBox()) == ((_o).coordBox())))) {
        return false;
    }
    if ((!((currentPosition()) == ((_o).currentPosition())))) {
        return false;
    }
    if ((!((rayContainReferenceLength()) == ((_o).rayContainReferenceLength())))) {
        return false;
    }
    if ((!((coordBoxInsetRadii()) == ((_o).coordBoxInsetRadii())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::MotionPathData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).origin());
    // Sentinel = 'origin'
    (aWriter)->WriteSentinel(150143625);
    IPC::WriteParam(aWriter, (aVar).anchorAdjustment());
    // Sentinel = 'anchorAdjustment'
    (aWriter)->WriteSentinel(924321435);
    IPC::WriteParam(aWriter, (aVar).coordBox());
    // Sentinel = 'coordBox'
    (aWriter)->WriteSentinel(245957441);
    IPC::WriteParam(aWriter, (aVar).currentPosition());
    // Sentinel = 'currentPosition'
    (aWriter)->WriteSentinel(851052121);
    IPC::WriteParam(aWriter, (aVar).rayContainReferenceLength());
    // Sentinel = 'rayContainReferenceLength'
    (aWriter)->WriteSentinel(2193295882);
    IPC::WriteParam(aWriter, (aVar).coordBoxInsetRadii());
    // Sentinel = 'coordBoxInsetRadii'
    (aWriter)->WriteSentinel(1149437741);
}

auto ParamTraits<::mozilla::layers::MotionPathData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___origin = IPC::ReadParam<::mozilla::CSSPoint>(aReader);
    if (!maybe___origin) {
        aReader->FatalError("Error deserializing 'origin' (CSSPoint) member of 'MotionPathData'");
        return {};

    }
    auto& _origin = *maybe___origin;
    // Sentinel = 'origin'
    if ((!((aReader)->ReadSentinel(150143625)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'origin' (CSSPoint) member of 'MotionPathData'");
        return {};
    }
    auto maybe___anchorAdjustment = IPC::ReadParam<::mozilla::CSSPoint>(aReader);
    if (!maybe___anchorAdjustment) {
        aReader->FatalError("Error deserializing 'anchorAdjustment' (CSSPoint) member of 'MotionPathData'");
        return {};

    }
    auto& _anchorAdjustment = *maybe___anchorAdjustment;
    // Sentinel = 'anchorAdjustment'
    if ((!((aReader)->ReadSentinel(924321435)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'anchorAdjustment' (CSSPoint) member of 'MotionPathData'");
        return {};
    }
    auto maybe___coordBox = IPC::ReadParam<::nsRect>(aReader);
    if (!maybe___coordBox) {
        aReader->FatalError("Error deserializing 'coordBox' (nsRect) member of 'MotionPathData'");
        return {};

    }
    auto& _coordBox = *maybe___coordBox;
    // Sentinel = 'coordBox'
    if ((!((aReader)->ReadSentinel(245957441)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'coordBox' (nsRect) member of 'MotionPathData'");
        return {};
    }
    auto maybe___currentPosition = IPC::ReadParam<::nsPoint>(aReader);
    if (!maybe___currentPosition) {
        aReader->FatalError("Error deserializing 'currentPosition' (nsPoint) member of 'MotionPathData'");
        return {};

    }
    auto& _currentPosition = *maybe___currentPosition;
    // Sentinel = 'currentPosition'
    if ((!((aReader)->ReadSentinel(851052121)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'currentPosition' (nsPoint) member of 'MotionPathData'");
        return {};
    }
    auto maybe___rayContainReferenceLength = IPC::ReadParam<::mozilla::CSSCoord>(aReader);
    if (!maybe___rayContainReferenceLength) {
        aReader->FatalError("Error deserializing 'rayContainReferenceLength' (CSSCoord) member of 'MotionPathData'");
        return {};

    }
    auto& _rayContainReferenceLength = *maybe___rayContainReferenceLength;
    // Sentinel = 'rayContainReferenceLength'
    if ((!((aReader)->ReadSentinel(2193295882)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'rayContainReferenceLength' (CSSCoord) member of 'MotionPathData'");
        return {};
    }
    auto maybe___coordBoxInsetRadii = IPC::ReadParam<nsTArray<::nscoord>>(aReader);
    if (!maybe___coordBoxInsetRadii) {
        aReader->FatalError("Error deserializing 'coordBoxInsetRadii' (nscoord[]) member of 'MotionPathData'");
        return {};

    }
    auto& _coordBoxInsetRadii = *maybe___coordBoxInsetRadii;
    // Sentinel = 'coordBoxInsetRadii'
    if ((!((aReader)->ReadSentinel(1149437741)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'coordBoxInsetRadii' (nscoord[]) member of 'MotionPathData'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_origin),
            std::move(_anchorAdjustment),
            std::move(_coordBox),
            std::move(_currentPosition),
            std::move(_rayContainReferenceLength),
            std::move(_coordBoxInsetRadii)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct PartialPrerenderData|
//
namespace mozilla {
namespace layers {
auto PartialPrerenderData::operator==(const PartialPrerenderData& _o) const -> bool
{
    if ((!((rect()) == ((_o).rect())))) {
        return false;
    }
    if ((!((overflowedSides()) == ((_o).overflowedSides())))) {
        return false;
    }
    if ((!((scrollId()) == ((_o).scrollId())))) {
        return false;
    }
    if ((!((clipRect()) == ((_o).clipRect())))) {
        return false;
    }
    if ((!((transformInClip()) == ((_o).transformInClip())))) {
        return false;
    }
    if ((!((position()) == ((_o).position())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::PartialPrerenderData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).rect());
    // Sentinel = 'rect'
    (aWriter)->WriteSentinel(70582703);
    IPC::WriteParam(aWriter, (aVar).overflowedSides());
    // Sentinel = 'overflowedSides'
    (aWriter)->WriteSentinel(847054390);
    IPC::WriteParam(aWriter, (aVar).scrollId());
    // Sentinel = 'scrollId'
    (aWriter)->WriteSentinel(253100861);
    IPC::WriteParam(aWriter, (aVar).clipRect());
    // Sentinel = 'clipRect'
    (aWriter)->WriteSentinel(241894199);
    IPC::WriteParam(aWriter, (aVar).transformInClip());
    // Sentinel = 'transformInClip'
    (aWriter)->WriteSentinel(838403612);
    IPC::WriteParam(aWriter, (aVar).position());
    // Sentinel = 'position'
    (aWriter)->WriteSentinel(262603638);
}

auto ParamTraits<::mozilla::layers::PartialPrerenderData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___rect = IPC::ReadParam<::mozilla::LayoutDeviceRect>(aReader);
    if (!maybe___rect) {
        aReader->FatalError("Error deserializing 'rect' (LayoutDeviceRect) member of 'PartialPrerenderData'");
        return {};

    }
    auto& _rect = *maybe___rect;
    // Sentinel = 'rect'
    if ((!((aReader)->ReadSentinel(70582703)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'rect' (LayoutDeviceRect) member of 'PartialPrerenderData'");
        return {};
    }
    auto maybe___overflowedSides = IPC::ReadParam<::mozilla::SideBits>(aReader);
    if (!maybe___overflowedSides) {
        aReader->FatalError("Error deserializing 'overflowedSides' (SideBits) member of 'PartialPrerenderData'");
        return {};

    }
    auto& _overflowedSides = *maybe___overflowedSides;
    // Sentinel = 'overflowedSides'
    if ((!((aReader)->ReadSentinel(847054390)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'overflowedSides' (SideBits) member of 'PartialPrerenderData'");
        return {};
    }
    auto maybe___scrollId = IPC::ReadParam<::mozilla::layers::ScrollableLayerGuid::ViewID>(aReader);
    if (!maybe___scrollId) {
        aReader->FatalError("Error deserializing 'scrollId' (ViewID) member of 'PartialPrerenderData'");
        return {};

    }
    auto& _scrollId = *maybe___scrollId;
    // Sentinel = 'scrollId'
    if ((!((aReader)->ReadSentinel(253100861)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scrollId' (ViewID) member of 'PartialPrerenderData'");
        return {};
    }
    auto maybe___clipRect = IPC::ReadParam<::mozilla::ParentLayerRect>(aReader);
    if (!maybe___clipRect) {
        aReader->FatalError("Error deserializing 'clipRect' (ParentLayerRect) member of 'PartialPrerenderData'");
        return {};

    }
    auto& _clipRect = *maybe___clipRect;
    // Sentinel = 'clipRect'
    if ((!((aReader)->ReadSentinel(241894199)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'clipRect' (ParentLayerRect) member of 'PartialPrerenderData'");
        return {};
    }
    auto maybe___transformInClip = IPC::ReadParam<::mozilla::gfx::Matrix4x4>(aReader);
    if (!maybe___transformInClip) {
        aReader->FatalError("Error deserializing 'transformInClip' (Matrix4x4) member of 'PartialPrerenderData'");
        return {};

    }
    auto& _transformInClip = *maybe___transformInClip;
    // Sentinel = 'transformInClip'
    if ((!((aReader)->ReadSentinel(838403612)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'transformInClip' (Matrix4x4) member of 'PartialPrerenderData'");
        return {};
    }
    auto maybe___position = IPC::ReadParam<::mozilla::LayoutDevicePoint>(aReader);
    if (!maybe___position) {
        aReader->FatalError("Error deserializing 'position' (LayoutDevicePoint) member of 'PartialPrerenderData'");
        return {};

    }
    auto& _position = *maybe___position;
    // Sentinel = 'position'
    if ((!((aReader)->ReadSentinel(262603638)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'position' (LayoutDevicePoint) member of 'PartialPrerenderData'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_rect),
            std::move(_overflowedSides),
            std::move(_scrollId),
            std::move(_clipRect),
            std::move(_transformInClip),
            std::move(_position)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct TransformData|
//
namespace mozilla {
namespace layers {
auto TransformData::operator==(const TransformData& _o) const -> bool
{
    if ((!((origin()) == ((_o).origin())))) {
        return false;
    }
    if ((!((transformOrigin()) == ((_o).transformOrigin())))) {
        return false;
    }
    if ((!((bounds()) == ((_o).bounds())))) {
        return false;
    }
    if ((!((appUnitsPerDevPixel()) == ((_o).appUnitsPerDevPixel())))) {
        return false;
    }
    if ((!((motionPathData()) == ((_o).motionPathData())))) {
        return false;
    }
    if ((!((partialPrerenderData()) == ((_o).partialPrerenderData())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::TransformData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).origin());
    // Sentinel = 'origin'
    (aWriter)->WriteSentinel(150143625);
    IPC::WriteParam(aWriter, (aVar).transformOrigin());
    // Sentinel = 'transformOrigin'
    (aWriter)->WriteSentinel(850921029);
    IPC::WriteParam(aWriter, (aVar).bounds());
    // Sentinel = 'bounds'
    (aWriter)->WriteSentinel(148243084);
    IPC::WriteParam(aWriter, (aVar).motionPathData());
    // Sentinel = 'motionPathData'
    (aWriter)->WriteSentinel(724632990);
    IPC::WriteParam(aWriter, (aVar).partialPrerenderData());
    // Sentinel = 'partialPrerenderData'
    (aWriter)->WriteSentinel(1441138703);
    (aWriter)->WriteBytes((&((aVar).appUnitsPerDevPixel())), 4);
    // Sentinel = 'appUnitsPerDevPixel'
    (aWriter)->WriteSentinel(1278936989);
}

auto ParamTraits<::mozilla::layers::TransformData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___origin = IPC::ReadParam<::nsPoint>(aReader);
    if (!maybe___origin) {
        aReader->FatalError("Error deserializing 'origin' (nsPoint) member of 'TransformData'");
        return {};

    }
    auto& _origin = *maybe___origin;
    // Sentinel = 'origin'
    if ((!((aReader)->ReadSentinel(150143625)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'origin' (nsPoint) member of 'TransformData'");
        return {};
    }
    auto maybe___transformOrigin = IPC::ReadParam<::mozilla::gfx::Point3D>(aReader);
    if (!maybe___transformOrigin) {
        aReader->FatalError("Error deserializing 'transformOrigin' (Point3D) member of 'TransformData'");
        return {};

    }
    auto& _transformOrigin = *maybe___transformOrigin;
    // Sentinel = 'transformOrigin'
    if ((!((aReader)->ReadSentinel(850921029)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'transformOrigin' (Point3D) member of 'TransformData'");
        return {};
    }
    auto maybe___bounds = IPC::ReadParam<::nsRect>(aReader);
    if (!maybe___bounds) {
        aReader->FatalError("Error deserializing 'bounds' (nsRect) member of 'TransformData'");
        return {};

    }
    auto& _bounds = *maybe___bounds;
    // Sentinel = 'bounds'
    if ((!((aReader)->ReadSentinel(148243084)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bounds' (nsRect) member of 'TransformData'");
        return {};
    }
    auto maybe___motionPathData = IPC::ReadParam<mozilla::Maybe<::mozilla::layers::MotionPathData>>(aReader);
    if (!maybe___motionPathData) {
        aReader->FatalError("Error deserializing 'motionPathData' (MotionPathData?) member of 'TransformData'");
        return {};

    }
    auto& _motionPathData = *maybe___motionPathData;
    // Sentinel = 'motionPathData'
    if ((!((aReader)->ReadSentinel(724632990)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'motionPathData' (MotionPathData?) member of 'TransformData'");
        return {};
    }
    auto maybe___partialPrerenderData = IPC::ReadParam<mozilla::Maybe<::mozilla::layers::PartialPrerenderData>>(aReader);
    if (!maybe___partialPrerenderData) {
        aReader->FatalError("Error deserializing 'partialPrerenderData' (PartialPrerenderData?) member of 'TransformData'");
        return {};

    }
    auto& _partialPrerenderData = *maybe___partialPrerenderData;
    // Sentinel = 'partialPrerenderData'
    if ((!((aReader)->ReadSentinel(1441138703)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'partialPrerenderData' (PartialPrerenderData?) member of 'TransformData'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_origin),
            std::move(_transformOrigin),
            std::move(_bounds),
            ::int32_t{0},
            std::move(_motionPathData),
            std::move(_partialPrerenderData)};
    if ((!((aReader)->ReadBytesInto((&((result__)->appUnitsPerDevPixel())), 4)))) {
        aReader->FatalError("Error bulk reading fields from int32_t");
        return {};
    }
    // Sentinel = 'appUnitsPerDevPixel'
    if ((!((aReader)->ReadSentinel(1278936989)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ScrollTimelineOptions|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla

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

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

    }
    auto& _source = *maybe___source;
    // Sentinel = 'source'
    if ((!((aReader)->ReadSentinel(154665618)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'source' (ViewID) member of 'ScrollTimelineOptions'");
        return {};
    }
    auto maybe___axis = IPC::ReadParam<::mozilla::layers::ScrollDirection>(aReader);
    if (!maybe___axis) {
        aReader->FatalError("Error deserializing 'axis' (ScrollDirection) member of 'ScrollTimelineOptions'");
        return {};

    }
    auto& _axis = *maybe___axis;
    // Sentinel = 'axis'
    if ((!((aReader)->ReadSentinel(70582710)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'axis' (ScrollDirection) member of 'ScrollTimelineOptions'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_source),
            std::move(_axis)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct Animation|
//
namespace mozilla {
namespace layers {
auto Animation::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(Animation, previousPlaybackRate_) - offsetof(Animation, iterations_)) == 12,
        "Bad assumptions about field layout!");
    static_assert(
        (offsetof(Animation, iterationComposite_) - offsetof(Animation, direction_)) == 2,
        "Bad assumptions about field layout!");
}

} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::Animation>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).originTime());
    // Sentinel = 'originTime'
    (aWriter)->WriteSentinel(383845400);
    IPC::WriteParam(aWriter, (aVar).startTime());
    // Sentinel = 'startTime'
    (aWriter)->WriteSentinel(320144318);
    IPC::WriteParam(aWriter, (aVar).delay());
    // Sentinel = 'delay'
    (aWriter)->WriteSentinel(101450256);
    IPC::WriteParam(aWriter, (aVar).endDelay());
    // Sentinel = 'endDelay'
    (aWriter)->WriteSentinel(233898791);
    IPC::WriteParam(aWriter, (aVar).holdTime());
    // Sentinel = 'holdTime'
    (aWriter)->WriteSentinel(244777783);
    IPC::WriteParam(aWriter, (aVar).duration());
    // Sentinel = 'duration'
    (aWriter)->WriteSentinel(256050023);
    IPC::WriteParam(aWriter, (aVar).segments());
    // Sentinel = 'segments'
    (aWriter)->WriteSentinel(254215015);
    IPC::WriteParam(aWriter, (aVar).property());
    // Sentinel = 'property'
    (aWriter)->WriteSentinel(263914374);
    IPC::WriteParam(aWriter, (aVar).easingFunction());
    // Sentinel = 'easingFunction'
    (aWriter)->WriteSentinel(714081726);
    IPC::WriteParam(aWriter, (aVar).isNotPlaying());
    // Sentinel = 'isNotPlaying'
    (aWriter)->WriteSentinel(528155874);
    IPC::WriteParam(aWriter, (aVar).isNotAnimating());
    // Sentinel = 'isNotAnimating'
    (aWriter)->WriteSentinel(703661478);
    IPC::WriteParam(aWriter, (aVar).baseStyle());
    // Sentinel = 'baseStyle'
    (aWriter)->WriteSentinel(303891373);
    IPC::WriteParam(aWriter, (aVar).transformData());
    // Sentinel = 'transformData'
    (aWriter)->WriteSentinel(642581847);
    IPC::WriteParam(aWriter, (aVar).replacedTransitionId());
    // Sentinel = 'replacedTransitionId'
    (aWriter)->WriteSentinel(1437861913);
    IPC::WriteParam(aWriter, (aVar).scrollTimelineOptions());
    // Sentinel = 'scrollTimelineOptions'
    (aWriter)->WriteSentinel(1601177779);
    (aWriter)->WriteBytes((&((aVar).iterations())), 16);
    // Sentinel = 'iterations | iterationStart | playbackRate | previousPlaybackRate'
    (aWriter)->WriteSentinel(1175198039);
    (aWriter)->WriteBytes((&((aVar).direction())), 3);
    // Sentinel = 'direction | fillMode | iterationComposite'
    (aWriter)->WriteSentinel(1216810984);
}

auto ParamTraits<::mozilla::layers::Animation>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___originTime = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___originTime) {
        aReader->FatalError("Error deserializing 'originTime' (TimeStamp) member of 'Animation'");
        return {};

    }
    auto& _originTime = *maybe___originTime;
    // Sentinel = 'originTime'
    if ((!((aReader)->ReadSentinel(383845400)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'originTime' (TimeStamp) member of 'Animation'");
        return {};
    }
    auto maybe___startTime = IPC::ReadParam<mozilla::Maybe<::mozilla::TimeDuration>>(aReader);
    if (!maybe___startTime) {
        aReader->FatalError("Error deserializing 'startTime' (TimeDuration?) member of 'Animation'");
        return {};

    }
    auto& _startTime = *maybe___startTime;
    // Sentinel = 'startTime'
    if ((!((aReader)->ReadSentinel(320144318)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'startTime' (TimeDuration?) member of 'Animation'");
        return {};
    }
    auto maybe___delay = IPC::ReadParam<::mozilla::TimeDuration>(aReader);
    if (!maybe___delay) {
        aReader->FatalError("Error deserializing 'delay' (TimeDuration) member of 'Animation'");
        return {};

    }
    auto& _delay = *maybe___delay;
    // Sentinel = 'delay'
    if ((!((aReader)->ReadSentinel(101450256)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'delay' (TimeDuration) member of 'Animation'");
        return {};
    }
    auto maybe___endDelay = IPC::ReadParam<::mozilla::TimeDuration>(aReader);
    if (!maybe___endDelay) {
        aReader->FatalError("Error deserializing 'endDelay' (TimeDuration) member of 'Animation'");
        return {};

    }
    auto& _endDelay = *maybe___endDelay;
    // Sentinel = 'endDelay'
    if ((!((aReader)->ReadSentinel(233898791)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'endDelay' (TimeDuration) member of 'Animation'");
        return {};
    }
    auto maybe___holdTime = IPC::ReadParam<::mozilla::TimeDuration>(aReader);
    if (!maybe___holdTime) {
        aReader->FatalError("Error deserializing 'holdTime' (TimeDuration) member of 'Animation'");
        return {};

    }
    auto& _holdTime = *maybe___holdTime;
    // Sentinel = 'holdTime'
    if ((!((aReader)->ReadSentinel(244777783)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'holdTime' (TimeDuration) member of 'Animation'");
        return {};
    }
    auto maybe___duration = IPC::ReadParam<::mozilla::TimeDuration>(aReader);
    if (!maybe___duration) {
        aReader->FatalError("Error deserializing 'duration' (TimeDuration) member of 'Animation'");
        return {};

    }
    auto& _duration = *maybe___duration;
    // Sentinel = 'duration'
    if ((!((aReader)->ReadSentinel(256050023)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'duration' (TimeDuration) member of 'Animation'");
        return {};
    }
    auto maybe___segments = IPC::ReadParam<nsTArray<::mozilla::layers::AnimationSegment>>(aReader);
    if (!maybe___segments) {
        aReader->FatalError("Error deserializing 'segments' (AnimationSegment[]) member of 'Animation'");
        return {};

    }
    auto& _segments = *maybe___segments;
    // Sentinel = 'segments'
    if ((!((aReader)->ReadSentinel(254215015)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'segments' (AnimationSegment[]) member of 'Animation'");
        return {};
    }
    auto maybe___property = IPC::ReadParam<::NonCustomCSSPropertyId>(aReader);
    if (!maybe___property) {
        aReader->FatalError("Error deserializing 'property' (NonCustomCSSPropertyId) member of 'Animation'");
        return {};

    }
    auto& _property = *maybe___property;
    // Sentinel = 'property'
    if ((!((aReader)->ReadSentinel(263914374)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'property' (NonCustomCSSPropertyId) member of 'Animation'");
        return {};
    }
    auto maybe___easingFunction = IPC::ReadParam<mozilla::Maybe<::mozilla::StyleComputedTimingFunction>>(aReader);
    if (!maybe___easingFunction) {
        aReader->FatalError("Error deserializing 'easingFunction' (StyleComputedTimingFunction?) member of 'Animation'");
        return {};

    }
    auto& _easingFunction = *maybe___easingFunction;
    // Sentinel = 'easingFunction'
    if ((!((aReader)->ReadSentinel(714081726)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'easingFunction' (StyleComputedTimingFunction?) member of 'Animation'");
        return {};
    }
    auto maybe___isNotPlaying = IPC::ReadParam<bool>(aReader);
    if (!maybe___isNotPlaying) {
        aReader->FatalError("Error deserializing 'isNotPlaying' (bool) member of 'Animation'");
        return {};

    }
    auto& _isNotPlaying = *maybe___isNotPlaying;
    // Sentinel = 'isNotPlaying'
    if ((!((aReader)->ReadSentinel(528155874)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isNotPlaying' (bool) member of 'Animation'");
        return {};
    }
    auto maybe___isNotAnimating = IPC::ReadParam<bool>(aReader);
    if (!maybe___isNotAnimating) {
        aReader->FatalError("Error deserializing 'isNotAnimating' (bool) member of 'Animation'");
        return {};

    }
    auto& _isNotAnimating = *maybe___isNotAnimating;
    // Sentinel = 'isNotAnimating'
    if ((!((aReader)->ReadSentinel(703661478)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isNotAnimating' (bool) member of 'Animation'");
        return {};
    }
    auto maybe___baseStyle = IPC::ReadParam<::mozilla::layers::Animatable>(aReader);
    if (!maybe___baseStyle) {
        aReader->FatalError("Error deserializing 'baseStyle' (Animatable) member of 'Animation'");
        return {};

    }
    auto& _baseStyle = *maybe___baseStyle;
    // Sentinel = 'baseStyle'
    if ((!((aReader)->ReadSentinel(303891373)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'baseStyle' (Animatable) member of 'Animation'");
        return {};
    }
    auto maybe___transformData = IPC::ReadParam<mozilla::Maybe<::mozilla::layers::TransformData>>(aReader);
    if (!maybe___transformData) {
        aReader->FatalError("Error deserializing 'transformData' (TransformData?) member of 'Animation'");
        return {};

    }
    auto& _transformData = *maybe___transformData;
    // Sentinel = 'transformData'
    if ((!((aReader)->ReadSentinel(642581847)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'transformData' (TransformData?) member of 'Animation'");
        return {};
    }
    auto maybe___replacedTransitionId = IPC::ReadParam<mozilla::Maybe<::uint64_t>>(aReader);
    if (!maybe___replacedTransitionId) {
        aReader->FatalError("Error deserializing 'replacedTransitionId' (uint64_t?) member of 'Animation'");
        return {};

    }
    auto& _replacedTransitionId = *maybe___replacedTransitionId;
    // Sentinel = 'replacedTransitionId'
    if ((!((aReader)->ReadSentinel(1437861913)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'replacedTransitionId' (uint64_t?) member of 'Animation'");
        return {};
    }
    auto maybe___scrollTimelineOptions = IPC::ReadParam<mozilla::Maybe<::mozilla::layers::ScrollTimelineOptions>>(aReader);
    if (!maybe___scrollTimelineOptions) {
        aReader->FatalError("Error deserializing 'scrollTimelineOptions' (ScrollTimelineOptions?) member of 'Animation'");
        return {};

    }
    auto& _scrollTimelineOptions = *maybe___scrollTimelineOptions;
    // Sentinel = 'scrollTimelineOptions'
    if ((!((aReader)->ReadSentinel(1601177779)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scrollTimelineOptions' (ScrollTimelineOptions?) member of 'Animation'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_originTime),
            std::move(_startTime),
            std::move(_delay),
            std::move(_endDelay),
            std::move(_holdTime),
            std::move(_duration),
            std::move(_segments),
            float{0},
            float{0},
            ::uint8_t{0},
            ::uint8_t{0},
            std::move(_property),
            float{0},
            float{0},
            std::move(_easingFunction),
            ::uint8_t{0},
            std::move(_isNotPlaying),
            std::move(_isNotAnimating),
            std::move(_baseStyle),
            std::move(_transformData),
            std::move(_replacedTransitionId),
            std::move(_scrollTimelineOptions)};
    if ((!((aReader)->ReadBytesInto((&((result__)->iterations())), 16)))) {
        aReader->FatalError("Error bulk reading fields from float");
        return {};
    }
    // Sentinel = 'iterations | iterationStart | playbackRate | previousPlaybackRate'
    if ((!((aReader)->ReadSentinel(1175198039)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from float");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->direction())), 3)))) {
        aReader->FatalError("Error bulk reading fields from uint8_t");
        return {};
    }
    // Sentinel = 'direction | fillMode | iterationComposite'
    if ((!((aReader)->ReadSentinel(1216810984)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint8_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CompositorAnimations|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::CompositorAnimations>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).animations());
    // Sentinel = 'animations'
    (aWriter)->WriteSentinel(381617204);
    (aWriter)->WriteBytes((&((aVar).id())), 8);
    // Sentinel = 'id'
    (aWriter)->WriteSentinel(20447438);
}

auto ParamTraits<::mozilla::layers::CompositorAnimations>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___animations = IPC::ReadParam<nsTArray<::mozilla::layers::Animation>>(aReader);
    if (!maybe___animations) {
        aReader->FatalError("Error deserializing 'animations' (Animation[]) member of 'CompositorAnimations'");
        return {};

    }
    auto& _animations = *maybe___animations;
    // Sentinel = 'animations'
    if ((!((aReader)->ReadSentinel(381617204)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'animations' (Animation[]) member of 'CompositorAnimations'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_animations),
            ::uint64_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->id())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint64_t");
        return {};
    }
    // Sentinel = 'id'
    if ((!((aReader)->ReadSentinel(20447438)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::UntrustedShmemSection>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, std::move((aVar).shmem()));
    // Sentinel = 'shmem'
    (aWriter)->WriteSentinel(107086363);
    (aWriter)->WriteBytes((&((aVar).offset())), 8);
    // Sentinel = 'offset | size'
    (aWriter)->WriteSentinel(592250111);
}

auto ParamTraits<::mozilla::layers::UntrustedShmemSection>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___shmem = IPC::ReadParam<::mozilla::ipc::Shmem>(aReader);
    if (!maybe___shmem) {
        aReader->FatalError("Error deserializing 'shmem' (Shmem) member of 'UntrustedShmemSection'");
        return {};

    }
    auto& _shmem = *maybe___shmem;
    // Sentinel = 'shmem'
    if ((!((aReader)->ReadSentinel(107086363)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'shmem' (Shmem) member of 'UntrustedShmemSection'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_shmem),
            ::uint32_t{0},
            ::uint32_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->offset())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'offset | size'
    if ((!((aReader)->ReadSentinel(592250111)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CrossProcessSemaphoreDescriptor|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::CrossProcessSemaphoreDescriptor>::Write(
        IPC::MessageWriter* aWriter,
        paramType&& aVar) -> void
{
    IPC::WriteParam(aWriter, std::move((aVar).sem()));
    // Sentinel = 'sem'
    (aWriter)->WriteSentinel(43188550);
}

auto ParamTraits<::mozilla::layers::CrossProcessSemaphoreDescriptor>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___sem = IPC::ReadParam<::mozilla::CrossProcessSemaphoreHandle>(aReader);
    if (!maybe___sem) {
        aReader->FatalError("Error deserializing 'sem' (CrossProcessSemaphoreHandle) member of 'CrossProcessSemaphoreDescriptor'");
        return {};

    }
    auto& _sem = *maybe___sem;
    // Sentinel = 'sem'
    if ((!((aReader)->ReadSentinel(43188550)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'sem' (CrossProcessSemaphoreHandle) member of 'CrossProcessSemaphoreDescriptor'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_sem)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ReadLockDescriptor|
//
namespace mozilla {
namespace layers {
auto ReadLockDescriptor::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TUntrustedShmemSection:
        {
            (ptr_UntrustedShmemSection())->~UntrustedShmemSection__tdef();
            break;
        }
    case TCrossProcessSemaphoreDescriptor:
        {
            (ptr_CrossProcessSemaphoreDescriptor())->~CrossProcessSemaphoreDescriptor__tdef();
            break;
        }
    case Tuintptr_t:
        {
            (ptr_uintptr_t())->~uintptr_t__tdef();
            break;
        }
    case Tnull_t:
        {
            (ptr_null_t())->~null_t__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(const UntrustedShmemSection& aOther)
{
    new (mozilla::KnownNotNull, ptr_UntrustedShmemSection()) UntrustedShmemSection(aOther);
    mType = TUntrustedShmemSection;
}

MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(UntrustedShmemSection&& aOther)
{
    new (mozilla::KnownNotNull, ptr_UntrustedShmemSection()) UntrustedShmemSection(std::move(aOther));
    mType = TUntrustedShmemSection;
}

MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(CrossProcessSemaphoreDescriptor&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor(std::move(aOther));
    mType = TCrossProcessSemaphoreDescriptor;
}

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

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

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

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

MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(ReadLockDescriptor&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TUntrustedShmemSection:
        {
            new (mozilla::KnownNotNull, ptr_UntrustedShmemSection()) UntrustedShmemSection(std::move((aOther).get_UntrustedShmemSection()));
            (aOther).MaybeDestroy();
            break;
        }
    case TCrossProcessSemaphoreDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor(std::move((aOther).get_CrossProcessSemaphoreDescriptor()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tuintptr_t:
        {
            new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t(std::move((aOther).get_uintptr_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto ReadLockDescriptor::operator=(const UntrustedShmemSection& aRhs) -> ReadLockDescriptor&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_UntrustedShmemSection()) UntrustedShmemSection(aRhs);
    mType = TUntrustedShmemSection;
    return (*(this));
}

auto ReadLockDescriptor::operator=(UntrustedShmemSection&& aRhs) -> ReadLockDescriptor&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_UntrustedShmemSection()) UntrustedShmemSection(std::move(aRhs));
    mType = TUntrustedShmemSection;
    return (*(this));
}

auto ReadLockDescriptor::operator=(CrossProcessSemaphoreDescriptor&& aRhs) -> ReadLockDescriptor&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor(std::move(aRhs));
    mType = TCrossProcessSemaphoreDescriptor;
    return (*(this));
}

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

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

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

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

auto ReadLockDescriptor::operator=(ReadLockDescriptor&& aRhs) -> ReadLockDescriptor&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TUntrustedShmemSection:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_UntrustedShmemSection()) UntrustedShmemSection(std::move((aRhs).get_UntrustedShmemSection()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TCrossProcessSemaphoreDescriptor:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor(std::move((aRhs).get_CrossProcessSemaphoreDescriptor()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tuintptr_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t(std::move((aRhs).get_uintptr_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tnull_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aRhs).get_null_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TUntrustedShmemSection:
        {
            IPC::WriteParam(aWriter, (aVar).get_UntrustedShmemSection());
            // Sentinel = 'TUntrustedShmemSection'
            (aWriter)->WriteSentinel(1716914418);
            return;
        }
    case union__::TCrossProcessSemaphoreDescriptor:
        {
            IPC::WriteParam(aWriter, std::move((aVar).get_CrossProcessSemaphoreDescriptor()));
            // Sentinel = 'TCrossProcessSemaphoreDescriptor'
            (aWriter)->WriteSentinel(3536981249);
            return;
        }
    case union__::Tuintptr_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_uintptr_t());
            // Sentinel = 'Tuintptr_t'
            (aWriter)->WriteSentinel(385418302);
            return;
        }
    case union__::Tnull_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aWriter)->WriteSentinel(190186211);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union ReadLockDescriptor");
            return;
        }
    }
}

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

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

    switch (type) {
    case union__::TUntrustedShmemSection:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::layers::UntrustedShmemSection>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TUntrustedShmemSection of union ReadLockDescriptor");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TUntrustedShmemSection'
            if ((!((aReader)->ReadSentinel(1716914418)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TUntrustedShmemSection of union ReadLockDescriptor");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TCrossProcessSemaphoreDescriptor:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::layers::CrossProcessSemaphoreDescriptor>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TCrossProcessSemaphoreDescriptor of union ReadLockDescriptor");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TCrossProcessSemaphoreDescriptor'
            if ((!((aReader)->ReadSentinel(3536981249)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCrossProcessSemaphoreDescriptor of union ReadLockDescriptor");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tuintptr_t:
        {
            auto maybe__tmp = IPC::ReadParam<::uintptr_t>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tuintptr_t of union ReadLockDescriptor");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tuintptr_t'
            if ((!((aReader)->ReadSentinel(385418302)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tuintptr_t of union ReadLockDescriptor");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tnull_t:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::null_t>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tnull_t of union ReadLockDescriptor");
                return {};

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpRemoveTexture|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::OpRemoveTexture>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).texture());
    // Sentinel = 'texture'
    (aWriter)->WriteSentinel(207684370);
}

auto ParamTraits<::mozilla::layers::OpRemoveTexture>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___texture = IPC::ReadParam<mozilla::NotNull<::mozilla::ipc::SideVariant<::mozilla::layers::PTextureParent*, ::mozilla::layers::PTextureChild*>>>(aReader);
    if (!maybe___texture) {
        aReader->FatalError("Error deserializing 'texture' (NotNull<PTexture>) member of 'OpRemoveTexture'");
        return {};

    }
    auto& _texture = *maybe___texture;
    // Sentinel = 'texture'
    if ((!((aReader)->ReadSentinel(207684370)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'texture' (NotNull<PTexture>) member of 'OpRemoveTexture'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_texture)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpClearImages|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::OpClearImages>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).type());
    // Sentinel = 'type'
    (aWriter)->WriteSentinel(75760067);
}

auto ParamTraits<::mozilla::layers::OpClearImages>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___type = IPC::ReadParam<::mozilla::layers::ClearImagesType>(aReader);
    if (!maybe___type) {
        aReader->FatalError("Error deserializing 'type' (ClearImagesType) member of 'OpClearImages'");
        return {};

    }
    auto& _type = *maybe___type;
    // Sentinel = 'type'
    if ((!((aReader)->ReadSentinel(75760067)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'type' (ClearImagesType) member of 'OpClearImages'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_type)};
    return result__;
}

} // namespace IPC

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

} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::TimedTexture>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).texture());
    // Sentinel = 'texture'
    (aWriter)->WriteSentinel(207684370);
    IPC::WriteParam(aWriter, (aVar).timeStamp());
    // Sentinel = 'timeStamp'
    (aWriter)->WriteSentinel(312083381);
    IPC::WriteParam(aWriter, (aVar).picture());
    // Sentinel = 'picture'
    (aWriter)->WriteSentinel(200540925);
    IPC::WriteParam(aWriter, (aVar).readLocked());
    // Sentinel = 'readLocked'
    (aWriter)->WriteSentinel(364708847);
    (aWriter)->WriteBytes((&((aVar).frameID())), 8);
    // Sentinel = 'frameID | producerID'
    (aWriter)->WriteSentinel(1286801222);
}

auto ParamTraits<::mozilla::layers::TimedTexture>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___texture = IPC::ReadParam<mozilla::NotNull<::mozilla::ipc::SideVariant<::mozilla::layers::PTextureParent*, ::mozilla::layers::PTextureChild*>>>(aReader);
    if (!maybe___texture) {
        aReader->FatalError("Error deserializing 'texture' (NotNull<PTexture>) member of 'TimedTexture'");
        return {};

    }
    auto& _texture = *maybe___texture;
    // Sentinel = 'texture'
    if ((!((aReader)->ReadSentinel(207684370)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'texture' (NotNull<PTexture>) member of 'TimedTexture'");
        return {};
    }
    auto maybe___timeStamp = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___timeStamp) {
        aReader->FatalError("Error deserializing 'timeStamp' (TimeStamp) member of 'TimedTexture'");
        return {};

    }
    auto& _timeStamp = *maybe___timeStamp;
    // Sentinel = 'timeStamp'
    if ((!((aReader)->ReadSentinel(312083381)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'timeStamp' (TimeStamp) member of 'TimedTexture'");
        return {};
    }
    auto maybe___picture = IPC::ReadParam<::mozilla::gfx::IntRect>(aReader);
    if (!maybe___picture) {
        aReader->FatalError("Error deserializing 'picture' (IntRect) member of 'TimedTexture'");
        return {};

    }
    auto& _picture = *maybe___picture;
    // Sentinel = 'picture'
    if ((!((aReader)->ReadSentinel(200540925)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'picture' (IntRect) member of 'TimedTexture'");
        return {};
    }
    auto maybe___readLocked = IPC::ReadParam<bool>(aReader);
    if (!maybe___readLocked) {
        aReader->FatalError("Error deserializing 'readLocked' (bool) member of 'TimedTexture'");
        return {};

    }
    auto& _readLocked = *maybe___readLocked;
    // Sentinel = 'readLocked'
    if ((!((aReader)->ReadSentinel(364708847)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'readLocked' (bool) member of 'TimedTexture'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_texture),
            std::move(_timeStamp),
            std::move(_picture),
            ::uint32_t{0},
            ::uint32_t{0},
            std::move(_readLocked)};
    if ((!((aReader)->ReadBytesInto((&((result__)->frameID())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'frameID | producerID'
    if ((!((aReader)->ReadSentinel(1286801222)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpUseTexture|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::OpUseTexture>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).textures());
    // Sentinel = 'textures'
    (aWriter)->WriteSentinel(266732421);
}

auto ParamTraits<::mozilla::layers::OpUseTexture>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___textures = IPC::ReadParam<nsTArray<::mozilla::layers::TimedTexture>>(aReader);
    if (!maybe___textures) {
        aReader->FatalError("Error deserializing 'textures' (TimedTexture[]) member of 'OpUseTexture'");
        return {};

    }
    auto& _textures = *maybe___textures;
    // Sentinel = 'textures'
    if ((!((aReader)->ReadSentinel(266732421)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'textures' (TimedTexture[]) member of 'OpUseTexture'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_textures)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpUseRemoteTexture|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::OpUseRemoteTexture>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).textureId());
    // Sentinel = 'textureId'
    (aWriter)->WriteSentinel(326828991);
    IPC::WriteParam(aWriter, (aVar).ownerId());
    // Sentinel = 'ownerId'
    (aWriter)->WriteSentinel(199230169);
    IPC::WriteParam(aWriter, (aVar).size());
    // Sentinel = 'size'
    (aWriter)->WriteSentinel(73662908);
    IPC::WriteParam(aWriter, (aVar).textureFlags());
    // Sentinel = 'textureFlags'
    (aWriter)->WriteSentinel(556598527);
}

auto ParamTraits<::mozilla::layers::OpUseRemoteTexture>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___textureId = IPC::ReadParam<::mozilla::layers::RemoteTextureId>(aReader);
    if (!maybe___textureId) {
        aReader->FatalError("Error deserializing 'textureId' (RemoteTextureId) member of 'OpUseRemoteTexture'");
        return {};

    }
    auto& _textureId = *maybe___textureId;
    // Sentinel = 'textureId'
    if ((!((aReader)->ReadSentinel(326828991)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'textureId' (RemoteTextureId) member of 'OpUseRemoteTexture'");
        return {};
    }
    auto maybe___ownerId = IPC::ReadParam<::mozilla::layers::RemoteTextureOwnerId>(aReader);
    if (!maybe___ownerId) {
        aReader->FatalError("Error deserializing 'ownerId' (RemoteTextureOwnerId) member of 'OpUseRemoteTexture'");
        return {};

    }
    auto& _ownerId = *maybe___ownerId;
    // Sentinel = 'ownerId'
    if ((!((aReader)->ReadSentinel(199230169)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ownerId' (RemoteTextureOwnerId) member of 'OpUseRemoteTexture'");
        return {};
    }
    auto maybe___size = IPC::ReadParam<::mozilla::gfx::IntSize>(aReader);
    if (!maybe___size) {
        aReader->FatalError("Error deserializing 'size' (IntSize) member of 'OpUseRemoteTexture'");
        return {};

    }
    auto& _size = *maybe___size;
    // Sentinel = 'size'
    if ((!((aReader)->ReadSentinel(73662908)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'OpUseRemoteTexture'");
        return {};
    }
    auto maybe___textureFlags = IPC::ReadParam<::mozilla::layers::TextureFlags>(aReader);
    if (!maybe___textureFlags) {
        aReader->FatalError("Error deserializing 'textureFlags' (TextureFlags) member of 'OpUseRemoteTexture'");
        return {};

    }
    auto& _textureFlags = *maybe___textureFlags;
    // Sentinel = 'textureFlags'
    if ((!((aReader)->ReadSentinel(556598527)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'textureFlags' (TextureFlags) member of 'OpUseRemoteTexture'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_textureId),
            std::move(_ownerId),
            std::move(_size),
            std::move(_textureFlags)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpEnableRemoteTexturePushCallback|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::OpEnableRemoteTexturePushCallback>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).ownerId());
    // Sentinel = 'ownerId'
    (aWriter)->WriteSentinel(199230169);
    IPC::WriteParam(aWriter, (aVar).size());
    // Sentinel = 'size'
    (aWriter)->WriteSentinel(73662908);
    IPC::WriteParam(aWriter, (aVar).textureFlags());
    // Sentinel = 'textureFlags'
    (aWriter)->WriteSentinel(556598527);
}

auto ParamTraits<::mozilla::layers::OpEnableRemoteTexturePushCallback>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___ownerId = IPC::ReadParam<::mozilla::layers::RemoteTextureOwnerId>(aReader);
    if (!maybe___ownerId) {
        aReader->FatalError("Error deserializing 'ownerId' (RemoteTextureOwnerId) member of 'OpEnableRemoteTexturePushCallback'");
        return {};

    }
    auto& _ownerId = *maybe___ownerId;
    // Sentinel = 'ownerId'
    if ((!((aReader)->ReadSentinel(199230169)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ownerId' (RemoteTextureOwnerId) member of 'OpEnableRemoteTexturePushCallback'");
        return {};
    }
    auto maybe___size = IPC::ReadParam<::mozilla::gfx::IntSize>(aReader);
    if (!maybe___size) {
        aReader->FatalError("Error deserializing 'size' (IntSize) member of 'OpEnableRemoteTexturePushCallback'");
        return {};

    }
    auto& _size = *maybe___size;
    // Sentinel = 'size'
    if ((!((aReader)->ReadSentinel(73662908)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'OpEnableRemoteTexturePushCallback'");
        return {};
    }
    auto maybe___textureFlags = IPC::ReadParam<::mozilla::layers::TextureFlags>(aReader);
    if (!maybe___textureFlags) {
        aReader->FatalError("Error deserializing 'textureFlags' (TextureFlags) member of 'OpEnableRemoteTexturePushCallback'");
        return {};

    }
    auto& _textureFlags = *maybe___textureFlags;
    // Sentinel = 'textureFlags'
    if ((!((aReader)->ReadSentinel(556598527)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'textureFlags' (TextureFlags) member of 'OpEnableRemoteTexturePushCallback'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_ownerId),
            std::move(_size),
            std::move(_textureFlags)};
    return result__;
}

} // namespace IPC

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

} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::OpNotifyNotUsed>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    (aWriter)->WriteBytes((&((aVar).TextureId())), 16);
    // Sentinel = 'TextureId | fwdTransactionId'
    (aWriter)->WriteSentinel(2613906127);
}

auto ParamTraits<::mozilla::layers::OpNotifyNotUsed>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::uint64_t{0},
            ::uint64_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->TextureId())), 16)))) {
        aReader->FatalError("Error bulk reading fields from uint64_t");
        return {};
    }
    // Sentinel = 'TextureId | fwdTransactionId'
    if ((!((aReader)->ReadSentinel(2613906127)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union CompositableOperationDetail|
//
namespace mozilla {
namespace layers {
auto CompositableOperationDetail::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TOpRemoveTexture:
        {
            (ptr_OpRemoveTexture())->~OpRemoveTexture__tdef();
            break;
        }
    case TOpClearImages:
        {
            (ptr_OpClearImages())->~OpClearImages__tdef();
            break;
        }
    case TOpUseTexture:
        {
            (ptr_OpUseTexture())->~OpUseTexture__tdef();
            break;
        }
    case TOpUseRemoteTexture:
        {
            (ptr_OpUseRemoteTexture())->~OpUseRemoteTexture__tdef();
            break;
        }
    case TOpEnableRemoteTexturePushCallback:
        {
            (ptr_OpEnableRemoteTexturePushCallback())->~OpEnableRemoteTexturePushCallback__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpRemoveTexture& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture(aOther);
    mType = TOpRemoveTexture;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(OpRemoveTexture&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture(std::move(aOther));
    mType = TOpRemoveTexture;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpClearImages& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpClearImages()) OpClearImages(aOther);
    mType = TOpClearImages;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(OpClearImages&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpClearImages()) OpClearImages(std::move(aOther));
    mType = TOpClearImages;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpUseTexture& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture(aOther);
    mType = TOpUseTexture;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(OpUseTexture&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture(std::move(aOther));
    mType = TOpUseTexture;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpUseRemoteTexture& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture(aOther);
    mType = TOpUseRemoteTexture;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(OpUseRemoteTexture&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture(std::move(aOther));
    mType = TOpUseRemoteTexture;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpEnableRemoteTexturePushCallback& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback(aOther);
    mType = TOpEnableRemoteTexturePushCallback;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(OpEnableRemoteTexturePushCallback&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback(std::move(aOther));
    mType = TOpEnableRemoteTexturePushCallback;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const CompositableOperationDetail& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TOpRemoveTexture:
        {
            new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture((aOther).get_OpRemoveTexture());
            break;
        }
    case TOpClearImages:
        {
            new (mozilla::KnownNotNull, ptr_OpClearImages()) OpClearImages((aOther).get_OpClearImages());
            break;
        }
    case TOpUseTexture:
        {
            new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture((aOther).get_OpUseTexture());
            break;
        }
    case TOpUseRemoteTexture:
        {
            new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture((aOther).get_OpUseRemoteTexture());
            break;
        }
    case TOpEnableRemoteTexturePushCallback:
        {
            new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback((aOther).get_OpEnableRemoteTexturePushCallback());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(CompositableOperationDetail&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TOpRemoveTexture:
        {
            new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture(std::move((aOther).get_OpRemoveTexture()));
            (aOther).MaybeDestroy();
            break;
        }
    case TOpClearImages:
        {
            new (mozilla::KnownNotNull, ptr_OpClearImages()) OpClearImages(std::move((aOther).get_OpClearImages()));
            (aOther).MaybeDestroy();
            break;
        }
    case TOpUseTexture:
        {
            new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture(std::move((aOther).get_OpUseTexture()));
            (aOther).MaybeDestroy();
            break;
        }
    case TOpUseRemoteTexture:
        {
            new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture(std::move((aOther).get_OpUseRemoteTexture()));
            (aOther).MaybeDestroy();
            break;
        }
    case TOpEnableRemoteTexturePushCallback:
        {
            new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback(std::move((aOther).get_OpEnableRemoteTexturePushCallback()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto CompositableOperationDetail::operator=(const OpRemoveTexture& aRhs) -> CompositableOperationDetail&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture(aRhs);
    mType = TOpRemoveTexture;
    return (*(this));
}

auto CompositableOperationDetail::operator=(OpRemoveTexture&& aRhs) -> CompositableOperationDetail&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture(std::move(aRhs));
    mType = TOpRemoveTexture;
    return (*(this));
}

auto CompositableOperationDetail::operator=(const OpClearImages& aRhs) -> CompositableOperationDetail&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_OpClearImages()) OpClearImages(aRhs);
    mType = TOpClearImages;
    return (*(this));
}

auto CompositableOperationDetail::operator=(OpClearImages&& aRhs) -> CompositableOperationDetail&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_OpClearImages()) OpClearImages(std::move(aRhs));
    mType = TOpClearImages;
    return (*(this));
}

auto CompositableOperationDetail::operator=(const OpUseTexture& aRhs) -> CompositableOperationDetail&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture(aRhs);
    mType = TOpUseTexture;
    return (*(this));
}

auto CompositableOperationDetail::operator=(OpUseTexture&& aRhs) -> CompositableOperationDetail&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture(std::move(aRhs));
    mType = TOpUseTexture;
    return (*(this));
}

auto CompositableOperationDetail::operator=(const OpUseRemoteTexture& aRhs) -> CompositableOperationDetail&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture(aRhs);
    mType = TOpUseRemoteTexture;
    return (*(this));
}

auto CompositableOperationDetail::operator=(OpUseRemoteTexture&& aRhs) -> CompositableOperationDetail&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture(std::move(aRhs));
    mType = TOpUseRemoteTexture;
    return (*(this));
}

auto CompositableOperationDetail::operator=(const OpEnableRemoteTexturePushCallback& aRhs) -> CompositableOperationDetail&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback(aRhs);
    mType = TOpEnableRemoteTexturePushCallback;
    return (*(this));
}

auto CompositableOperationDetail::operator=(OpEnableRemoteTexturePushCallback&& aRhs) -> CompositableOperationDetail&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback(std::move(aRhs));
    mType = TOpEnableRemoteTexturePushCallback;
    return (*(this));
}

auto CompositableOperationDetail::operator=(const CompositableOperationDetail& aRhs) -> CompositableOperationDetail&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TOpRemoveTexture:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture((aRhs).get_OpRemoveTexture());
            break;
        }
    case TOpClearImages:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_OpClearImages()) OpClearImages((aRhs).get_OpClearImages());
            break;
        }
    case TOpUseTexture:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture((aRhs).get_OpUseTexture());
            break;
        }
    case TOpUseRemoteTexture:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture((aRhs).get_OpUseRemoteTexture());
            break;
        }
    case TOpEnableRemoteTexturePushCallback:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback((aRhs).get_OpEnableRemoteTexturePushCallback());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto CompositableOperationDetail::operator=(CompositableOperationDetail&& aRhs) -> CompositableOperationDetail&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TOpRemoveTexture:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture(std::move((aRhs).get_OpRemoveTexture()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TOpClearImages:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_OpClearImages()) OpClearImages(std::move((aRhs).get_OpClearImages()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TOpUseTexture:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture(std::move((aRhs).get_OpUseTexture()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TOpUseRemoteTexture:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture(std::move((aRhs).get_OpUseRemoteTexture()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TOpEnableRemoteTexturePushCallback:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback(std::move((aRhs).get_OpEnableRemoteTexturePushCallback()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TOpRemoveTexture:
        {
            IPC::WriteParam(aWriter, (aVar).get_OpRemoveTexture());
            // Sentinel = 'TOpRemoveTexture'
            (aWriter)->WriteSentinel(885261939);
            return;
        }
    case union__::TOpClearImages:
        {
            IPC::WriteParam(aWriter, (aVar).get_OpClearImages());
            // Sentinel = 'TOpClearImages'
            (aWriter)->WriteSentinel(646055249);
            return;
        }
    case union__::TOpUseTexture:
        {
            IPC::WriteParam(aWriter, (aVar).get_OpUseTexture());
            // Sentinel = 'TOpUseTexture'
            (aWriter)->WriteSentinel(584320306);
            return;
        }
    case union__::TOpUseRemoteTexture:
        {
            IPC::WriteParam(aWriter, (aVar).get_OpUseRemoteTexture());
            // Sentinel = 'TOpUseRemoteTexture'
            (aWriter)->WriteSentinel(1233192862);
            return;
        }
    case union__::TOpEnableRemoteTexturePushCallback:
        {
            IPC::WriteParam(aWriter, (aVar).get_OpEnableRemoteTexturePushCallback());
            // Sentinel = 'TOpEnableRemoteTexturePushCallback'
            (aWriter)->WriteSentinel(3879472485);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union CompositableOperationDetail");
            return;
        }
    }
}

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

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

    switch (type) {
    case union__::TOpRemoveTexture:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::layers::OpRemoveTexture>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TOpRemoveTexture of union CompositableOperationDetail");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TOpRemoveTexture'
            if ((!((aReader)->ReadSentinel(885261939)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpRemoveTexture of union CompositableOperationDetail");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TOpClearImages:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::layers::OpClearImages>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TOpClearImages of union CompositableOperationDetail");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TOpClearImages'
            if ((!((aReader)->ReadSentinel(646055249)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpClearImages of union CompositableOperationDetail");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TOpUseTexture:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::layers::OpUseTexture>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TOpUseTexture of union CompositableOperationDetail");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TOpUseTexture'
            if ((!((aReader)->ReadSentinel(584320306)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpUseTexture of union CompositableOperationDetail");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TOpUseRemoteTexture:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::layers::OpUseRemoteTexture>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TOpUseRemoteTexture of union CompositableOperationDetail");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TOpUseRemoteTexture'
            if ((!((aReader)->ReadSentinel(1233192862)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpUseRemoteTexture of union CompositableOperationDetail");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TOpEnableRemoteTexturePushCallback:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::layers::OpEnableRemoteTexturePushCallback>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TOpEnableRemoteTexturePushCallback of union CompositableOperationDetail");
                return {};

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CompositableOperation|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::CompositableOperation>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).compositable());
    // Sentinel = 'compositable'
    (aWriter)->WriteSentinel(551879939);
    IPC::WriteParam(aWriter, (aVar).detail());
    // Sentinel = 'detail'
    (aWriter)->WriteSentinel(143131252);
}

auto ParamTraits<::mozilla::layers::CompositableOperation>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___compositable = IPC::ReadParam<::mozilla::layers::CompositableHandle>(aReader);
    if (!maybe___compositable) {
        aReader->FatalError("Error deserializing 'compositable' (CompositableHandle) member of 'CompositableOperation'");
        return {};

    }
    auto& _compositable = *maybe___compositable;
    // Sentinel = 'compositable'
    if ((!((aReader)->ReadSentinel(551879939)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'compositable' (CompositableHandle) member of 'CompositableOperation'");
        return {};
    }
    auto maybe___detail = IPC::ReadParam<::mozilla::layers::CompositableOperationDetail>(aReader);
    if (!maybe___detail) {
        aReader->FatalError("Error deserializing 'detail' (CompositableOperationDetail) member of 'CompositableOperation'");
        return {};

    }
    auto& _detail = *maybe___detail;
    // Sentinel = 'detail'
    if ((!((aReader)->ReadSentinel(143131252)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'detail' (CompositableOperationDetail) member of 'CompositableOperation'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_compositable),
            std::move(_detail)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union OpDestroy|
//
namespace mozilla {
namespace layers {
auto OpDestroy::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TPTexture:
        {
            (ptr_PTexture())->~PTexture__tdef();
            break;
        }
    case TCompositableHandle:
        {
            (ptr_CompositableHandle())->~CompositableHandle__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT OpDestroy::OpDestroy(const mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>& aOther)
{
    new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>(aOther);
    mType = TPTexture;
}

MOZ_IMPLICIT OpDestroy::OpDestroy(mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>&& aOther)
{
    new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>(std::move(aOther));
    mType = TPTexture;
}

MOZ_IMPLICIT OpDestroy::OpDestroy(const CompositableHandle& aOther)
{
    new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle(aOther);
    mType = TCompositableHandle;
}

MOZ_IMPLICIT OpDestroy::OpDestroy(CompositableHandle&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle(std::move(aOther));
    mType = TCompositableHandle;
}

MOZ_IMPLICIT OpDestroy::OpDestroy(const OpDestroy& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TPTexture:
        {
            new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>((aOther).get_PTexture());
            break;
        }
    case TCompositableHandle:
        {
            new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle((aOther).get_CompositableHandle());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT OpDestroy::OpDestroy(OpDestroy&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TPTexture:
        {
            new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>(std::move((aOther).get_PTexture()));
            (aOther).MaybeDestroy();
            break;
        }
    case TCompositableHandle:
        {
            new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle(std::move((aOther).get_CompositableHandle()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto OpDestroy::operator=(const mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>& aRhs) -> OpDestroy&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>(aRhs);
    mType = TPTexture;
    return (*(this));
}

auto OpDestroy::operator=(mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>&& aRhs) -> OpDestroy&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>(std::move(aRhs));
    mType = TPTexture;
    return (*(this));
}

auto OpDestroy::operator=(const CompositableHandle& aRhs) -> OpDestroy&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle(aRhs);
    mType = TCompositableHandle;
    return (*(this));
}

auto OpDestroy::operator=(CompositableHandle&& aRhs) -> OpDestroy&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle(std::move(aRhs));
    mType = TCompositableHandle;
    return (*(this));
}

auto OpDestroy::operator=(const OpDestroy& aRhs) -> OpDestroy&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TPTexture:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>((aRhs).get_PTexture());
            break;
        }
    case TCompositableHandle:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle((aRhs).get_CompositableHandle());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto OpDestroy::operator=(OpDestroy&& aRhs) -> OpDestroy&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TPTexture:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>(std::move((aRhs).get_PTexture()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TCompositableHandle:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle(std::move((aRhs).get_CompositableHandle()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TPTexture:
        {
            IPC::WriteParam(aWriter, (aVar).get_PTexture());
            // Sentinel = 'TPTexture'
            (aWriter)->WriteSentinel(284623766);
            return;
        }
    case union__::TCompositableHandle:
        {
            IPC::WriteParam(aWriter, (aVar).get_CompositableHandle());
            // Sentinel = 'TCompositableHandle'
            (aWriter)->WriteSentinel(1252657027);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union OpDestroy");
            return;
        }
    }
}

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

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

    switch (type) {
    case union__::TPTexture:
        {
            auto maybe__tmp = IPC::ReadParam<mozilla::NotNull<::mozilla::ipc::SideVariant<::mozilla::layers::PTextureParent*, ::mozilla::layers::PTextureChild*>>>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TPTexture of union OpDestroy");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TPTexture'
            if ((!((aReader)->ReadSentinel(284623766)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPTexture of union OpDestroy");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TCompositableHandle:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::layers::CompositableHandle>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TCompositableHandle of union OpDestroy");
                return {};

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpContentBufferSwap|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::OpContentBufferSwap>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).compositable());
    // Sentinel = 'compositable'
    (aWriter)->WriteSentinel(551879939);
    IPC::WriteParam(aWriter, (aVar).frontUpdatedRegion());
    // Sentinel = 'frontUpdatedRegion'
    (aWriter)->WriteSentinel(1177618261);
}

auto ParamTraits<::mozilla::layers::OpContentBufferSwap>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___compositable = IPC::ReadParam<::mozilla::layers::CompositableHandle>(aReader);
    if (!maybe___compositable) {
        aReader->FatalError("Error deserializing 'compositable' (CompositableHandle) member of 'OpContentBufferSwap'");
        return {};

    }
    auto& _compositable = *maybe___compositable;
    // Sentinel = 'compositable'
    if ((!((aReader)->ReadSentinel(551879939)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'compositable' (CompositableHandle) member of 'OpContentBufferSwap'");
        return {};
    }
    auto maybe___frontUpdatedRegion = IPC::ReadParam<::nsIntRegion>(aReader);
    if (!maybe___frontUpdatedRegion) {
        aReader->FatalError("Error deserializing 'frontUpdatedRegion' (nsIntRegion) member of 'OpContentBufferSwap'");
        return {};

    }
    auto& _frontUpdatedRegion = *maybe___frontUpdatedRegion;
    // Sentinel = 'frontUpdatedRegion'
    if ((!((aReader)->ReadSentinel(1177618261)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'frontUpdatedRegion' (nsIntRegion) member of 'OpContentBufferSwap'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_compositable),
            std::move(_frontUpdatedRegion)};
    return result__;
}

} // namespace IPC

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

} // namespace layers
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::layers::ImageCompositeNotification>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).compositable());
    // Sentinel = 'compositable'
    (aWriter)->WriteSentinel(551879939);
    IPC::WriteParam(aWriter, (aVar).imageTimeStamp());
    // Sentinel = 'imageTimeStamp'
    (aWriter)->WriteSentinel(699467160);
    IPC::WriteParam(aWriter, (aVar).firstCompositeTimeStamp());
    // Sentinel = 'firstCompositeTimeStamp'
    (aWriter)->WriteSentinel(1910638960);
    (aWriter)->WriteBytes((&((aVar).frameID())), 8);
    // Sentinel = 'frameID | producerID'
    (aWriter)->WriteSentinel(1286801222);
}

auto ParamTraits<::mozilla::layers::ImageCompositeNotification>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___compositable = IPC::ReadParam<::mozilla::layers::CompositableHandle>(aReader);
    if (!maybe___compositable) {
        aReader->FatalError("Error deserializing 'compositable' (CompositableHandle) member of 'ImageCompositeNotification'");
        return {};

    }
    auto& _compositable = *maybe___compositable;
    // Sentinel = 'compositable'
    if ((!((aReader)->ReadSentinel(551879939)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'compositable' (CompositableHandle) member of 'ImageCompositeNotification'");
        return {};
    }
    auto maybe___imageTimeStamp = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___imageTimeStamp) {
        aReader->FatalError("Error deserializing 'imageTimeStamp' (TimeStamp) member of 'ImageCompositeNotification'");
        return {};

    }
    auto& _imageTimeStamp = *maybe___imageTimeStamp;
    // Sentinel = 'imageTimeStamp'
    if ((!((aReader)->ReadSentinel(699467160)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'imageTimeStamp' (TimeStamp) member of 'ImageCompositeNotification'");
        return {};
    }
    auto maybe___firstCompositeTimeStamp = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___firstCompositeTimeStamp) {
        aReader->FatalError("Error deserializing 'firstCompositeTimeStamp' (TimeStamp) member of 'ImageCompositeNotification'");
        return {};

    }
    auto& _firstCompositeTimeStamp = *maybe___firstCompositeTimeStamp;
    // Sentinel = 'firstCompositeTimeStamp'
    if ((!((aReader)->ReadSentinel(1910638960)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'firstCompositeTimeStamp' (TimeStamp) member of 'ImageCompositeNotification'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_compositable),
            std::move(_imageTimeStamp),
            std::move(_firstCompositeTimeStamp),
            ::uint32_t{0},
            ::uint32_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->frameID())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'frameID | producerID'
    if ((!((aReader)->ReadSentinel(1286801222)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union AsyncParentMessageData|
//
namespace mozilla {
namespace layers {
auto AsyncParentMessageData::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TOpNotifyNotUsed:
        {
            (ptr_OpNotifyNotUsed())->~OpNotifyNotUsed__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT AsyncParentMessageData::AsyncParentMessageData(const OpNotifyNotUsed& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed(aOther);
    mType = TOpNotifyNotUsed;
}

MOZ_IMPLICIT AsyncParentMessageData::AsyncParentMessageData(OpNotifyNotUsed&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed(std::move(aOther));
    mType = TOpNotifyNotUsed;
}

MOZ_IMPLICIT AsyncParentMessageData::AsyncParentMessageData(const AsyncParentMessageData& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TOpNotifyNotUsed:
        {
            new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed((aOther).get_OpNotifyNotUsed());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT AsyncParentMessageData::AsyncParentMessageData(AsyncParentMessageData&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TOpNotifyNotUsed:
        {
            new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed(std::move((aOther).get_OpNotifyNotUsed()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto AsyncParentMessageData::operator=(const OpNotifyNotUsed& aRhs) -> AsyncParentMessageData&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed(aRhs);
    mType = TOpNotifyNotUsed;
    return (*(this));
}

auto AsyncParentMessageData::operator=(OpNotifyNotUsed&& aRhs) -> AsyncParentMessageData&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed(std::move(aRhs));
    mType = TOpNotifyNotUsed;
    return (*(this));
}

auto AsyncParentMessageData::operator=(const AsyncParentMessageData& aRhs) -> AsyncParentMessageData&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TOpNotifyNotUsed:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed((aRhs).get_OpNotifyNotUsed());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto AsyncParentMessageData::operator=(AsyncParentMessageData&& aRhs) -> AsyncParentMessageData&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TOpNotifyNotUsed:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed(std::move((aRhs).get_OpNotifyNotUsed()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TOpNotifyNotUsed:
        {
            IPC::WriteParam(aWriter, (aVar).get_OpNotifyNotUsed());
            // Sentinel = 'TOpNotifyNotUsed'
            (aWriter)->WriteSentinel(881460815);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union AsyncParentMessageData");
            return;
        }
    }
}

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

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

    switch (type) {
    case union__::TOpNotifyNotUsed:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::layers::OpNotifyNotUsed>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TOpNotifyNotUsed of union AsyncParentMessageData");
                return {};

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union OMTAValue|
//
namespace mozilla {
namespace layers {
auto OMTAValue::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tnull_t:
        {
            (ptr_null_t())->~null_t__tdef();
            break;
        }
    case Tnscolor:
        {
            (ptr_nscolor())->~nscolor__tdef();
            break;
        }
    case Tfloat:
        {
            (ptr_float())->~float__tdef();
            break;
        }
    case TMatrix4x4:
        {
            (ptr_Matrix4x4())->~Matrix4x4__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

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

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

MOZ_IMPLICIT OMTAValue::OMTAValue(const nscolor& aOther)
{
    new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(aOther);
    mType = Tnscolor;
}

MOZ_IMPLICIT OMTAValue::OMTAValue(nscolor&& aOther)
{
    new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move(aOther));
    mType = Tnscolor;
}

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

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

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

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

MOZ_IMPLICIT OMTAValue::OMTAValue(const OMTAValue& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case Tnscolor:
        {
            new (mozilla::KnownNotNull, ptr_nscolor()) nscolor((aOther).get_nscolor());
            break;
        }
    case Tfloat:
        {
            new (mozilla::KnownNotNull, ptr_float()) float((aOther).get_float());
            break;
        }
    case TMatrix4x4:
        {
            new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4((aOther).get_Matrix4x4());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT OMTAValue::OMTAValue(OMTAValue&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tnscolor:
        {
            new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move((aOther).get_nscolor()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tfloat:
        {
            new (mozilla::KnownNotNull, ptr_float()) float(std::move((aOther).get_float()));
            (aOther).MaybeDestroy();
            break;
        }
    case TMatrix4x4:
        {
            new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4(std::move((aOther).get_Matrix4x4()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto OMTAValue::operator=(const nscolor& aRhs) -> OMTAValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(aRhs);
    mType = Tnscolor;
    return (*(this));
}

auto OMTAValue::operator=(nscolor&& aRhs) -> OMTAValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move(aRhs));
    mType = Tnscolor;
    return (*(this));
}

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

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

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

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

auto OMTAValue::operator=(const OMTAValue& aRhs) -> OMTAValue&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnull_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aRhs).get_null_t());
            break;
        }
    case Tnscolor:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nscolor()) nscolor((aRhs).get_nscolor());
            break;
        }
    case Tfloat:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_float()) float((aRhs).get_float());
            break;
        }
    case TMatrix4x4:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4((aRhs).get_Matrix4x4());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto OMTAValue::operator=(OMTAValue&& aRhs) -> OMTAValue&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnull_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aRhs).get_null_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tnscolor:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move((aRhs).get_nscolor()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tfloat:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_float()) float(std::move((aRhs).get_float()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TMatrix4x4:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4(std::move((aRhs).get_Matrix4x4()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::Tnull_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aWriter)->WriteSentinel(190186211);
            return;
        }
    case union__::Tnscolor:
        {
            IPC::WriteParam(aWriter, (aVar).get_nscolor());
            // Sentinel = 'Tnscolor'
            (aWriter)->WriteSentinel(245039957);
            return;
        }
    case union__::Tfloat:
        {
            IPC::WriteParam(aWriter, (aVar).get_float());
            // Sentinel = 'Tfloat'
            (aWriter)->WriteSentinel(137298539);
            return;
        }
    case union__::TMatrix4x4:
        {
            IPC::WriteParam(aWriter, (aVar).get_Matrix4x4());
            // Sentinel = 'TMatrix4x4'
            (aWriter)->WriteSentinel(345244586);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union OMTAValue");
            return;
        }
    }
}

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

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

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

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tnull_t'
            if ((!((aReader)->ReadSentinel(190186211)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union OMTAValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tnscolor:
        {
            auto maybe__tmp = IPC::ReadParam<::nscolor>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tnscolor of union OMTAValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tnscolor'
            if ((!((aReader)->ReadSentinel(245039957)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnscolor of union OMTAValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tfloat:
        {
            auto maybe__tmp = IPC::ReadParam<float>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tfloat of union OMTAValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tfloat'
            if ((!((aReader)->ReadSentinel(137298539)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tfloat of union OMTAValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TMatrix4x4:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::gfx::Matrix4x4>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TMatrix4x4 of union OMTAValue");
                return {};

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

} // namespace IPC
