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


#include "mozilla/GfxMessageUtils.h"
#include "mozilla/gfx/GraphicsMessages.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 D3D11DeviceStatus|
//
namespace mozilla {
namespace gfx {
auto D3D11DeviceStatus::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(D3D11DeviceStatus, sequenceNumber_) - offsetof(D3D11DeviceStatus, featureLevel_)) == 4,
        "Bad assumptions about field layout!");
}

} // namespace gfx
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::gfx::D3D11DeviceStatus>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).isWARP());
    // Sentinel = 'isWARP'
    (aWriter)->WriteSentinel(130941463);
    IPC::WriteParam(aWriter, (aVar).textureSharingWorks());
    // Sentinel = 'textureSharingWorks'
    (aWriter)->WriteSentinel(1344473076);
    IPC::WriteParam(aWriter, (aVar).adapter());
    // Sentinel = 'adapter'
    (aWriter)->WriteSentinel(188941026);
    IPC::WriteParam(aWriter, (aVar).formatOptions());
    // Sentinel = 'formatOptions'
    (aWriter)->WriteSentinel(636290422);
    (aWriter)->WriteBytes((&((aVar).featureLevel())), 8);
    // Sentinel = 'featureLevel | sequenceNumber'
    (aWriter)->WriteSentinel(2858814307);
}

auto ParamTraits<::mozilla::gfx::D3D11DeviceStatus>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___isWARP = IPC::ReadParam<bool>(aReader);
    if (!maybe___isWARP) {
        aReader->FatalError("Error deserializing 'isWARP' (bool) member of 'D3D11DeviceStatus'");
        return {};

    }
    auto& _isWARP = *maybe___isWARP;
    // Sentinel = 'isWARP'
    if ((!((aReader)->ReadSentinel(130941463)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isWARP' (bool) member of 'D3D11DeviceStatus'");
        return {};
    }
    auto maybe___textureSharingWorks = IPC::ReadParam<bool>(aReader);
    if (!maybe___textureSharingWorks) {
        aReader->FatalError("Error deserializing 'textureSharingWorks' (bool) member of 'D3D11DeviceStatus'");
        return {};

    }
    auto& _textureSharingWorks = *maybe___textureSharingWorks;
    // Sentinel = 'textureSharingWorks'
    if ((!((aReader)->ReadSentinel(1344473076)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'textureSharingWorks' (bool) member of 'D3D11DeviceStatus'");
        return {};
    }
    auto maybe___adapter = IPC::ReadParam<::DxgiAdapterDesc>(aReader);
    if (!maybe___adapter) {
        aReader->FatalError("Error deserializing 'adapter' (DxgiAdapterDesc) member of 'D3D11DeviceStatus'");
        return {};

    }
    auto& _adapter = *maybe___adapter;
    // Sentinel = 'adapter'
    if ((!((aReader)->ReadSentinel(188941026)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'adapter' (DxgiAdapterDesc) member of 'D3D11DeviceStatus'");
        return {};
    }
    auto maybe___formatOptions = IPC::ReadParam<::mozilla::gfx::D3D11Checks::VideoFormatOptionSet>(aReader);
    if (!maybe___formatOptions) {
        aReader->FatalError("Error deserializing 'formatOptions' (VideoFormatOptionSet) member of 'D3D11DeviceStatus'");
        return {};

    }
    auto& _formatOptions = *maybe___formatOptions;
    // Sentinel = 'formatOptions'
    if ((!((aReader)->ReadSentinel(636290422)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'formatOptions' (VideoFormatOptionSet) member of 'D3D11DeviceStatus'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_isWARP),
            std::move(_textureSharingWorks),
            ::uint32_t{0},
            std::move(_adapter),
            ::int32_t{0},
            std::move(_formatOptions)};
    if ((!((aReader)->ReadBytesInto((&((result__)->featureLevel())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'featureLevel | sequenceNumber'
    if ((!((aReader)->ReadSentinel(2858814307)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct DevicePrefs|
//
namespace mozilla {
namespace gfx {
} // namespace gfx
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::gfx::DevicePrefs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).hwCompositing());
    // Sentinel = 'hwCompositing'
    (aWriter)->WriteSentinel(629867884);
    IPC::WriteParam(aWriter, (aVar).d3d11Compositing());
    // Sentinel = 'd3d11Compositing'
    (aWriter)->WriteSentinel(774899178);
    IPC::WriteParam(aWriter, (aVar).oglCompositing());
    // Sentinel = 'oglCompositing'
    (aWriter)->WriteSentinel(722273743);
    IPC::WriteParam(aWriter, (aVar).d3d11HwAngle());
    // Sentinel = 'd3d11HwAngle'
    (aWriter)->WriteSentinel(407307268);
}

auto ParamTraits<::mozilla::gfx::DevicePrefs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___hwCompositing = IPC::ReadParam<::mozilla::gfx::FeatureStatus>(aReader);
    if (!maybe___hwCompositing) {
        aReader->FatalError("Error deserializing 'hwCompositing' (FeatureStatus) member of 'DevicePrefs'");
        return {};

    }
    auto& _hwCompositing = *maybe___hwCompositing;
    // Sentinel = 'hwCompositing'
    if ((!((aReader)->ReadSentinel(629867884)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hwCompositing' (FeatureStatus) member of 'DevicePrefs'");
        return {};
    }
    auto maybe___d3d11Compositing = IPC::ReadParam<::mozilla::gfx::FeatureStatus>(aReader);
    if (!maybe___d3d11Compositing) {
        aReader->FatalError("Error deserializing 'd3d11Compositing' (FeatureStatus) member of 'DevicePrefs'");
        return {};

    }
    auto& _d3d11Compositing = *maybe___d3d11Compositing;
    // Sentinel = 'd3d11Compositing'
    if ((!((aReader)->ReadSentinel(774899178)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'd3d11Compositing' (FeatureStatus) member of 'DevicePrefs'");
        return {};
    }
    auto maybe___oglCompositing = IPC::ReadParam<::mozilla::gfx::FeatureStatus>(aReader);
    if (!maybe___oglCompositing) {
        aReader->FatalError("Error deserializing 'oglCompositing' (FeatureStatus) member of 'DevicePrefs'");
        return {};

    }
    auto& _oglCompositing = *maybe___oglCompositing;
    // Sentinel = 'oglCompositing'
    if ((!((aReader)->ReadSentinel(722273743)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'oglCompositing' (FeatureStatus) member of 'DevicePrefs'");
        return {};
    }
    auto maybe___d3d11HwAngle = IPC::ReadParam<::mozilla::gfx::FeatureStatus>(aReader);
    if (!maybe___d3d11HwAngle) {
        aReader->FatalError("Error deserializing 'd3d11HwAngle' (FeatureStatus) member of 'DevicePrefs'");
        return {};

    }
    auto& _d3d11HwAngle = *maybe___d3d11HwAngle;
    // Sentinel = 'd3d11HwAngle'
    if ((!((aReader)->ReadSentinel(407307268)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'd3d11HwAngle' (FeatureStatus) member of 'DevicePrefs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_hwCompositing),
            std::move(_d3d11Compositing),
            std::move(_oglCompositing),
            std::move(_d3d11HwAngle)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ContentDeviceData|
//
namespace mozilla {
namespace gfx {
} // namespace gfx
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::gfx::ContentDeviceData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).prefs());
    // Sentinel = 'prefs'
    (aWriter)->WriteSentinel(107676193);
    IPC::WriteParam(aWriter, (aVar).d3d11());
    // Sentinel = 'd3d11'
    (aWriter)->WriteSentinel(75759966);
    IPC::WriteParam(aWriter, (aVar).cmsOutputProfileData());
    // Sentinel = 'cmsOutputProfileData'
    (aWriter)->WriteSentinel(1454376992);
}

auto ParamTraits<::mozilla::gfx::ContentDeviceData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___prefs = IPC::ReadParam<::mozilla::gfx::DevicePrefs>(aReader);
    if (!maybe___prefs) {
        aReader->FatalError("Error deserializing 'prefs' (DevicePrefs) member of 'ContentDeviceData'");
        return {};

    }
    auto& _prefs = *maybe___prefs;
    // Sentinel = 'prefs'
    if ((!((aReader)->ReadSentinel(107676193)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'prefs' (DevicePrefs) member of 'ContentDeviceData'");
        return {};
    }
    auto maybe___d3d11 = IPC::ReadParam<::mozilla::gfx::D3D11DeviceStatus>(aReader);
    if (!maybe___d3d11) {
        aReader->FatalError("Error deserializing 'd3d11' (D3D11DeviceStatus) member of 'ContentDeviceData'");
        return {};

    }
    auto& _d3d11 = *maybe___d3d11;
    // Sentinel = 'd3d11'
    if ((!((aReader)->ReadSentinel(75759966)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'd3d11' (D3D11DeviceStatus) member of 'ContentDeviceData'");
        return {};
    }
    auto maybe___cmsOutputProfileData = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___cmsOutputProfileData) {
        aReader->FatalError("Error deserializing 'cmsOutputProfileData' (uint8_t[]) member of 'ContentDeviceData'");
        return {};

    }
    auto& _cmsOutputProfileData = *maybe___cmsOutputProfileData;
    // Sentinel = 'cmsOutputProfileData'
    if ((!((aReader)->ReadSentinel(1454376992)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cmsOutputProfileData' (uint8_t[]) member of 'ContentDeviceData'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_prefs),
            std::move(_d3d11),
            std::move(_cmsOutputProfileData)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FeatureFailure|
//
namespace mozilla {
namespace gfx {
} // namespace gfx
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::gfx::FeatureFailure>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).status());
    // Sentinel = 'status'
    (aWriter)->WriteSentinel(154731173);
    IPC::WriteParam(aWriter, (aVar).message());
    // Sentinel = 'message'
    (aWriter)->WriteSentinel(197198566);
    IPC::WriteParam(aWriter, (aVar).failureId());
    // Sentinel = 'failureId'
    (aWriter)->WriteSentinel(306447254);
}

auto ParamTraits<::mozilla::gfx::FeatureFailure>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___status = IPC::ReadParam<::mozilla::gfx::FeatureStatus>(aReader);
    if (!maybe___status) {
        aReader->FatalError("Error deserializing 'status' (FeatureStatus) member of 'FeatureFailure'");
        return {};

    }
    auto& _status = *maybe___status;
    // Sentinel = 'status'
    if ((!((aReader)->ReadSentinel(154731173)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'status' (FeatureStatus) member of 'FeatureFailure'");
        return {};
    }
    auto maybe___message = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___message) {
        aReader->FatalError("Error deserializing 'message' (nsCString) member of 'FeatureFailure'");
        return {};

    }
    auto& _message = *maybe___message;
    // Sentinel = 'message'
    if ((!((aReader)->ReadSentinel(197198566)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'message' (nsCString) member of 'FeatureFailure'");
        return {};
    }
    auto maybe___failureId = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___failureId) {
        aReader->FatalError("Error deserializing 'failureId' (nsCString) member of 'FeatureFailure'");
        return {};

    }
    auto& _failureId = *maybe___failureId;
    // Sentinel = 'failureId'
    if ((!((aReader)->ReadSentinel(306447254)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'failureId' (nsCString) member of 'FeatureFailure'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_status),
            std::move(_message),
            std::move(_failureId)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct GPUDeviceData|
//
namespace mozilla {
namespace gfx {
} // namespace gfx
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::gfx::GPUDeviceData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).d3d11Compositing());
    // Sentinel = 'd3d11Compositing'
    (aWriter)->WriteSentinel(774899178);
    IPC::WriteParam(aWriter, (aVar).oglCompositing());
    // Sentinel = 'oglCompositing'
    (aWriter)->WriteSentinel(722273743);
    IPC::WriteParam(aWriter, (aVar).gpuDevice());
    // Sentinel = 'gpuDevice'
    (aWriter)->WriteSentinel(304743325);
}

auto ParamTraits<::mozilla::gfx::GPUDeviceData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___d3d11Compositing = IPC::ReadParam<mozilla::Maybe<::mozilla::gfx::FeatureFailure>>(aReader);
    if (!maybe___d3d11Compositing) {
        aReader->FatalError("Error deserializing 'd3d11Compositing' (FeatureFailure?) member of 'GPUDeviceData'");
        return {};

    }
    auto& _d3d11Compositing = *maybe___d3d11Compositing;
    // Sentinel = 'd3d11Compositing'
    if ((!((aReader)->ReadSentinel(774899178)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'd3d11Compositing' (FeatureFailure?) member of 'GPUDeviceData'");
        return {};
    }
    auto maybe___oglCompositing = IPC::ReadParam<mozilla::Maybe<::mozilla::gfx::FeatureFailure>>(aReader);
    if (!maybe___oglCompositing) {
        aReader->FatalError("Error deserializing 'oglCompositing' (FeatureFailure?) member of 'GPUDeviceData'");
        return {};

    }
    auto& _oglCompositing = *maybe___oglCompositing;
    // Sentinel = 'oglCompositing'
    if ((!((aReader)->ReadSentinel(722273743)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'oglCompositing' (FeatureFailure?) member of 'GPUDeviceData'");
        return {};
    }
    auto maybe___gpuDevice = IPC::ReadParam<mozilla::Maybe<::mozilla::gfx::D3D11DeviceStatus>>(aReader);
    if (!maybe___gpuDevice) {
        aReader->FatalError("Error deserializing 'gpuDevice' (D3D11DeviceStatus?) member of 'GPUDeviceData'");
        return {};

    }
    auto& _gpuDevice = *maybe___gpuDevice;
    // Sentinel = 'gpuDevice'
    if ((!((aReader)->ReadSentinel(304743325)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'gpuDevice' (D3D11DeviceStatus?) member of 'GPUDeviceData'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_d3d11Compositing),
            std::move(_oglCompositing),
            std::move(_gpuDevice)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union GfxVarValue|
//
namespace mozilla {
namespace gfx {
auto GfxVarValue::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TBackendType:
        {
            (ptr_BackendType())->~BackendType__tdef();
            break;
        }
    case Tbool:
        {
            (ptr_bool())->~bool__tdef();
            break;
        }
    case TgfxImageFormat:
        {
            (ptr_gfxImageFormat())->~gfxImageFormat__tdef();
            break;
        }
    case TIntSize:
        {
            (ptr_IntSize())->~IntSize__tdef();
            break;
        }
    case TnsCString:
        {
            (ptr_nsCString())->~nsCString__tdef();
            break;
        }
    case TnsString:
        {
            (ptr_nsString())->~nsString__tdef();
            break;
        }
    case Tint32_t:
        {
            (ptr_int32_t())->~int32_t__tdef();
            break;
        }
    case Tuint64_t:
        {
            (ptr_uint64_t())->~uint64_t__tdef();
            break;
        }
    case Tfloat:
        {
            (ptr_float())->~float__tdef();
            break;
        }
    case TArrayOfuint64_t:
        {
            (ptr_ArrayOfuint64_t())->~ArrayOfuint64_t__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(const BackendType& aOther)
{
    new (mozilla::KnownNotNull, ptr_BackendType()) BackendType(aOther);
    mType = TBackendType;
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(BackendType&& aOther)
{
    new (mozilla::KnownNotNull, ptr_BackendType()) BackendType(std::move(aOther));
    mType = TBackendType;
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(const bool& aOther)
{
    new (mozilla::KnownNotNull, ptr_bool()) bool(aOther);
    mType = Tbool;
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(bool&& aOther)
{
    new (mozilla::KnownNotNull, ptr_bool()) bool(std::move(aOther));
    mType = Tbool;
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(const gfxImageFormat& aOther)
{
    new (mozilla::KnownNotNull, ptr_gfxImageFormat()) gfxImageFormat(aOther);
    mType = TgfxImageFormat;
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(gfxImageFormat&& aOther)
{
    new (mozilla::KnownNotNull, ptr_gfxImageFormat()) gfxImageFormat(std::move(aOther));
    mType = TgfxImageFormat;
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(const IntSize& aOther)
{
    new (mozilla::KnownNotNull, ptr_IntSize()) IntSize(aOther);
    mType = TIntSize;
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(IntSize&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IntSize()) IntSize(std::move(aOther));
    mType = TIntSize;
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(const nsCString& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(aOther);
    mType = TnsCString;
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(nsCString&& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move(aOther));
    mType = TnsCString;
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(const nsString& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsString()) nsString(aOther);
    mType = TnsString;
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(nsString&& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsString()) nsString(std::move(aOther));
    mType = TnsString;
}

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

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

MOZ_IMPLICIT GfxVarValue::GfxVarValue(const uint64_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(aOther);
    mType = Tuint64_t;
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(uint64_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(std::move(aOther));
    mType = Tuint64_t;
}

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

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

MOZ_IMPLICIT GfxVarValue::GfxVarValue(const nsTArray<uint64_t>& aOther)
{
    new (mozilla::KnownNotNull, ptr_ArrayOfuint64_t()) nsTArray<uint64_t>((aOther).Clone());
    mType = TArrayOfuint64_t;
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(nsTArray<uint64_t>&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ArrayOfuint64_t()) nsTArray<uint64_t>(std::move(aOther));
    mType = TArrayOfuint64_t;
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(const GfxVarValue& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TBackendType:
        {
            new (mozilla::KnownNotNull, ptr_BackendType()) BackendType((aOther).get_BackendType());
            break;
        }
    case Tbool:
        {
            new (mozilla::KnownNotNull, ptr_bool()) bool((aOther).get_bool());
            break;
        }
    case TgfxImageFormat:
        {
            new (mozilla::KnownNotNull, ptr_gfxImageFormat()) gfxImageFormat((aOther).get_gfxImageFormat());
            break;
        }
    case TIntSize:
        {
            new (mozilla::KnownNotNull, ptr_IntSize()) IntSize((aOther).get_IntSize());
            break;
        }
    case TnsCString:
        {
            new (mozilla::KnownNotNull, ptr_nsCString()) nsCString((aOther).get_nsCString());
            break;
        }
    case TnsString:
        {
            new (mozilla::KnownNotNull, ptr_nsString()) nsString((aOther).get_nsString());
            break;
        }
    case Tint32_t:
        {
            new (mozilla::KnownNotNull, ptr_int32_t()) int32_t((aOther).get_int32_t());
            break;
        }
    case Tuint64_t:
        {
            new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t((aOther).get_uint64_t());
            break;
        }
    case Tfloat:
        {
            new (mozilla::KnownNotNull, ptr_float()) float((aOther).get_float());
            break;
        }
    case TArrayOfuint64_t:
        {
            new (mozilla::KnownNotNull, ptr_ArrayOfuint64_t()) nsTArray<uint64_t>(((aOther).get_ArrayOfuint64_t()).Clone());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT GfxVarValue::GfxVarValue(GfxVarValue&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TBackendType:
        {
            new (mozilla::KnownNotNull, ptr_BackendType()) BackendType(std::move((aOther).get_BackendType()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tbool:
        {
            new (mozilla::KnownNotNull, ptr_bool()) bool(std::move((aOther).get_bool()));
            (aOther).MaybeDestroy();
            break;
        }
    case TgfxImageFormat:
        {
            new (mozilla::KnownNotNull, ptr_gfxImageFormat()) gfxImageFormat(std::move((aOther).get_gfxImageFormat()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIntSize:
        {
            new (mozilla::KnownNotNull, ptr_IntSize()) IntSize(std::move((aOther).get_IntSize()));
            (aOther).MaybeDestroy();
            break;
        }
    case TnsCString:
        {
            new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move((aOther).get_nsCString()));
            (aOther).MaybeDestroy();
            break;
        }
    case TnsString:
        {
            new (mozilla::KnownNotNull, ptr_nsString()) nsString(std::move((aOther).get_nsString()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tint32_t:
        {
            new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move((aOther).get_int32_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tuint64_t:
        {
            new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(std::move((aOther).get_uint64_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tfloat:
        {
            new (mozilla::KnownNotNull, ptr_float()) float(std::move((aOther).get_float()));
            (aOther).MaybeDestroy();
            break;
        }
    case TArrayOfuint64_t:
        {
            new (mozilla::KnownNotNull, ptr_ArrayOfuint64_t()) nsTArray<uint64_t>(std::move((aOther).get_ArrayOfuint64_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto GfxVarValue::operator=(const BackendType& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_BackendType()) BackendType(aRhs);
    mType = TBackendType;
    return (*(this));
}

auto GfxVarValue::operator=(BackendType&& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_BackendType()) BackendType(std::move(aRhs));
    mType = TBackendType;
    return (*(this));
}

auto GfxVarValue::operator=(const bool& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_bool()) bool(aRhs);
    mType = Tbool;
    return (*(this));
}

auto GfxVarValue::operator=(bool&& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_bool()) bool(std::move(aRhs));
    mType = Tbool;
    return (*(this));
}

auto GfxVarValue::operator=(const gfxImageFormat& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_gfxImageFormat()) gfxImageFormat(aRhs);
    mType = TgfxImageFormat;
    return (*(this));
}

auto GfxVarValue::operator=(gfxImageFormat&& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_gfxImageFormat()) gfxImageFormat(std::move(aRhs));
    mType = TgfxImageFormat;
    return (*(this));
}

auto GfxVarValue::operator=(const IntSize& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IntSize()) IntSize(aRhs);
    mType = TIntSize;
    return (*(this));
}

auto GfxVarValue::operator=(IntSize&& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IntSize()) IntSize(std::move(aRhs));
    mType = TIntSize;
    return (*(this));
}

auto GfxVarValue::operator=(const nsCString& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(aRhs);
    mType = TnsCString;
    return (*(this));
}

auto GfxVarValue::operator=(nsCString&& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move(aRhs));
    mType = TnsCString;
    return (*(this));
}

auto GfxVarValue::operator=(const nsString& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsString()) nsString(aRhs);
    mType = TnsString;
    return (*(this));
}

auto GfxVarValue::operator=(nsString&& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsString()) nsString(std::move(aRhs));
    mType = TnsString;
    return (*(this));
}

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

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

auto GfxVarValue::operator=(const uint64_t& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(aRhs);
    mType = Tuint64_t;
    return (*(this));
}

auto GfxVarValue::operator=(uint64_t&& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(std::move(aRhs));
    mType = Tuint64_t;
    return (*(this));
}

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

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

auto GfxVarValue::operator=(const nsTArray<uint64_t>& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ArrayOfuint64_t()) nsTArray<uint64_t>((aRhs).Clone());
    mType = TArrayOfuint64_t;
    return (*(this));
}

auto GfxVarValue::operator=(nsTArray<uint64_t>&& aRhs) -> GfxVarValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ArrayOfuint64_t()) nsTArray<uint64_t>(std::move(aRhs));
    mType = TArrayOfuint64_t;
    return (*(this));
}

auto GfxVarValue::operator=(const GfxVarValue& aRhs) -> GfxVarValue&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TBackendType:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_BackendType()) BackendType((aRhs).get_BackendType());
            break;
        }
    case Tbool:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_bool()) bool((aRhs).get_bool());
            break;
        }
    case TgfxImageFormat:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_gfxImageFormat()) gfxImageFormat((aRhs).get_gfxImageFormat());
            break;
        }
    case TIntSize:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IntSize()) IntSize((aRhs).get_IntSize());
            break;
        }
    case TnsCString:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsCString()) nsCString((aRhs).get_nsCString());
            break;
        }
    case TnsString:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsString()) nsString((aRhs).get_nsString());
            break;
        }
    case Tint32_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_int32_t()) int32_t((aRhs).get_int32_t());
            break;
        }
    case Tuint64_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t((aRhs).get_uint64_t());
            break;
        }
    case Tfloat:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_float()) float((aRhs).get_float());
            break;
        }
    case TArrayOfuint64_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ArrayOfuint64_t()) nsTArray<uint64_t>(((aRhs).get_ArrayOfuint64_t()).Clone());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto GfxVarValue::operator=(GfxVarValue&& aRhs) -> GfxVarValue&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TBackendType:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_BackendType()) BackendType(std::move((aRhs).get_BackendType()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tbool:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_bool()) bool(std::move((aRhs).get_bool()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TgfxImageFormat:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_gfxImageFormat()) gfxImageFormat(std::move((aRhs).get_gfxImageFormat()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIntSize:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IntSize()) IntSize(std::move((aRhs).get_IntSize()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TnsCString:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move((aRhs).get_nsCString()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TnsString:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsString()) nsString(std::move((aRhs).get_nsString()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tint32_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move((aRhs).get_int32_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tuint64_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(std::move((aRhs).get_uint64_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tfloat:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_float()) float(std::move((aRhs).get_float()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TArrayOfuint64_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ArrayOfuint64_t()) nsTArray<uint64_t>(std::move((aRhs).get_ArrayOfuint64_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace gfx
} // namespace mozilla

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

    switch (type) {
    case union__::TBackendType:
        {
            IPC::WriteParam(aWriter, (aVar).get_BackendType());
            // Sentinel = 'TBackendType'
            (aWriter)->WriteSentinel(481952927);
            return;
        }
    case union__::Tbool:
        {
            IPC::WriteParam(aWriter, (aVar).get_bool());
            // Sentinel = 'Tbool'
            (aWriter)->WriteSentinel(96993793);
            return;
        }
    case union__::TgfxImageFormat:
        {
            IPC::WriteParam(aWriter, (aVar).get_gfxImageFormat());
            // Sentinel = 'TgfxImageFormat'
            (aWriter)->WriteSentinel(776472038);
            return;
        }
    case union__::TIntSize:
        {
            IPC::WriteParam(aWriter, (aVar).get_IntSize());
            // Sentinel = 'TIntSize'
            (aWriter)->WriteSentinel(224330523);
            return;
        }
    case union__::TnsCString:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsCString());
            // Sentinel = 'TnsCString'
            (aWriter)->WriteSentinel(353960944);
            return;
        }
    case union__::TnsString:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsString());
            // Sentinel = 'TnsString'
            (aWriter)->WriteSentinel(302908333);
            return;
        }
    case union__::Tint32_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_int32_t());
            // Sentinel = 'Tint32_t'
            (aWriter)->WriteSentinel(217252568);
            return;
        }
    case union__::Tuint64_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_uint64_t());
            // Sentinel = 'Tuint64_t'
            (aWriter)->WriteSentinel(285344594);
            return;
        }
    case union__::Tfloat:
        {
            IPC::WriteParam(aWriter, (aVar).get_float());
            // Sentinel = 'Tfloat'
            (aWriter)->WriteSentinel(137298539);
            return;
        }
    case union__::TArrayOfuint64_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_ArrayOfuint64_t());
            // Sentinel = 'TArrayOfuint64_t'
            (aWriter)->WriteSentinel(865404422);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union GfxVarValue");
            return;
        }
    }
}

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

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

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

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TBackendType'
            if ((!((aReader)->ReadSentinel(481952927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TBackendType of union GfxVarValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tbool:
        {
            auto maybe__tmp = IPC::ReadParam<bool>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tbool of union GfxVarValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tbool'
            if ((!((aReader)->ReadSentinel(96993793)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tbool of union GfxVarValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TgfxImageFormat:
        {
            auto maybe__tmp = IPC::ReadParam<::gfxImageFormat>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TgfxImageFormat of union GfxVarValue");
                return {};

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

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIntSize'
            if ((!((aReader)->ReadSentinel(224330523)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIntSize of union GfxVarValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TnsCString:
        {
            auto maybe__tmp = IPC::ReadParam<::nsCString>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TnsCString of union GfxVarValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TnsCString'
            if ((!((aReader)->ReadSentinel(353960944)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TnsCString of union GfxVarValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TnsString:
        {
            auto maybe__tmp = IPC::ReadParam<::nsString>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TnsString of union GfxVarValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TnsString'
            if ((!((aReader)->ReadSentinel(302908333)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TnsString of union GfxVarValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tint32_t:
        {
            auto maybe__tmp = IPC::ReadParam<::int32_t>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tint32_t of union GfxVarValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tint32_t'
            if ((!((aReader)->ReadSentinel(217252568)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tint32_t of union GfxVarValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tuint64_t:
        {
            auto maybe__tmp = IPC::ReadParam<::uint64_t>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tuint64_t of union GfxVarValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tuint64_t'
            if ((!((aReader)->ReadSentinel(285344594)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tuint64_t of union GfxVarValue");
                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 GfxVarValue");
                return {};

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

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct GfxVarUpdate|
//
namespace mozilla {
namespace gfx {
} // namespace gfx
} // namespace mozilla

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

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

    }
    auto& _value = *maybe___value;
    // Sentinel = 'value'
    if ((!((aReader)->ReadSentinel(107610654)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'value' (GfxVarValue) member of 'GfxVarUpdate'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::uint32_t{0},
            std::move(_value)};
    if ((!((aReader)->ReadBytesInto((&((result__)->index())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'index'
    if ((!((aReader)->ReadSentinel(104333849)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

} // namespace gfx
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::gfx::GfxInfoFeatureStatus>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).failureId());
    // Sentinel = 'failureId'
    (aWriter)->WriteSentinel(306447254);
    (aWriter)->WriteBytes((&((aVar).feature())), 8);
    // Sentinel = 'feature | status'
    (aWriter)->WriteSentinel(888407629);
}

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

    }
    auto& _failureId = *maybe___failureId;
    // Sentinel = 'failureId'
    if ((!((aReader)->ReadSentinel(306447254)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'failureId' (nsCString) member of 'GfxInfoFeatureStatus'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int32_t{0},
            ::int32_t{0},
            std::move(_failureId)};
    if ((!((aReader)->ReadBytesInto((&((result__)->feature())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int32_t");
        return {};
    }
    // Sentinel = 'feature | status'
    if ((!((aReader)->ReadSentinel(888407629)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int32_t");
        return {};
    }
    return result__;
}

} // namespace IPC
