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

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


#include "gfxipc/ShadowLayerUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "ImageLayers.h"
#include "mozilla/layers/PCompositorBridgeParent.h"
#include "mozilla/layers/PCompositorBridgeChild.h"
#include "mozilla/layout/PRenderFrameParent.h"
#include "mozilla/layout/PRenderFrameChild.h"
#include "mozilla/layers/PTextureParent.h"
#include "mozilla/layers/PTextureChild.h"
#include "mozilla/layers/LayersMessages.h"


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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::TargetConfig>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).naturalBounds());
    // Sentinel = 'naturalBounds'
    (aMsg)->WriteSentinel(2065643689);
    WriteIPDLParam(aMsg, aActor, (aVar).rotation());
    // Sentinel = 'rotation'
    (aMsg)->WriteSentinel(289872474);
    WriteIPDLParam(aMsg, aActor, (aVar).orientation());
    // Sentinel = 'orientation'
    (aMsg)->WriteSentinel(759639429);
    WriteIPDLParam(aMsg, aActor, (aVar).clearRegion());
    // Sentinel = 'clearRegion'
    (aMsg)->WriteSentinel(2731638988);
}

auto IPDLParamTraits<mozilla::layers::TargetConfig>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->naturalBounds())))))) {
        (aActor)->FatalError("Error deserializing 'naturalBounds' (IntRect) member of 'TargetConfig'");
        return false;
    }
    // Sentinel = 'naturalBounds'
    if ((!((aMsg)->ReadSentinel(aIter, 2065643689)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'naturalBounds' (IntRect) member of 'TargetConfig'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->rotation())))))) {
        (aActor)->FatalError("Error deserializing 'rotation' (ScreenRotation) member of 'TargetConfig'");
        return false;
    }
    // Sentinel = 'rotation'
    if ((!((aMsg)->ReadSentinel(aIter, 289872474)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'rotation' (ScreenRotation) member of 'TargetConfig'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->orientation())))))) {
        (aActor)->FatalError("Error deserializing 'orientation' (ScreenOrientation) member of 'TargetConfig'");
        return false;
    }
    // Sentinel = 'orientation'
    if ((!((aMsg)->ReadSentinel(aIter, 759639429)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'orientation' (ScreenOrientation) member of 'TargetConfig'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->clearRegion())))))) {
        (aActor)->FatalError("Error deserializing 'clearRegion' (nsIntRegion) member of 'TargetConfig'");
        return false;
    }
    // Sentinel = 'clearRegion'
    if ((!((aMsg)->ReadSentinel(aIter, 2731638988)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'clearRegion' (nsIntRegion) member of 'TargetConfig'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::CubicBezierFunction>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).x1());
    // Sentinel = 'x1'
    (aMsg)->WriteSentinel(739453787);
    WriteIPDLParam(aMsg, aActor, (aVar).y1());
    // Sentinel = 'y1'
    (aMsg)->WriteSentinel(2893099544);
    WriteIPDLParam(aMsg, aActor, (aVar).x2());
    // Sentinel = 'x2'
    (aMsg)->WriteSentinel(739453784);
    WriteIPDLParam(aMsg, aActor, (aVar).y2());
    // Sentinel = 'y2'
    (aMsg)->WriteSentinel(2893099547);
}

auto IPDLParamTraits<mozilla::layers::CubicBezierFunction>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->x1())))))) {
        (aActor)->FatalError("Error deserializing 'x1' (float) member of 'CubicBezierFunction'");
        return false;
    }
    // Sentinel = 'x1'
    if ((!((aMsg)->ReadSentinel(aIter, 739453787)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'x1' (float) member of 'CubicBezierFunction'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->y1())))))) {
        (aActor)->FatalError("Error deserializing 'y1' (float) member of 'CubicBezierFunction'");
        return false;
    }
    // Sentinel = 'y1'
    if ((!((aMsg)->ReadSentinel(aIter, 2893099544)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'y1' (float) member of 'CubicBezierFunction'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->x2())))))) {
        (aActor)->FatalError("Error deserializing 'x2' (float) member of 'CubicBezierFunction'");
        return false;
    }
    // Sentinel = 'x2'
    if ((!((aMsg)->ReadSentinel(aIter, 739453784)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'x2' (float) member of 'CubicBezierFunction'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->y2())))))) {
        (aActor)->FatalError("Error deserializing 'y2' (float) member of 'CubicBezierFunction'");
        return false;
    }
    // Sentinel = 'y2'
    if ((!((aMsg)->ReadSentinel(aIter, 2893099547)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'y2' (float) member of 'CubicBezierFunction'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union TimingFunction|
//
namespace mozilla {
namespace layers {
auto TimingFunction::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case Tnull_t:
        {
            (ptr_null_t())->~null_t__tdef();
            break;
        }
    case TCubicBezierFunction:
        {
            (ptr_CubicBezierFunction())->~CubicBezierFunction__tdef();
            break;
        }
    case TStepFunction:
        {
            (ptr_StepFunction())->~StepFunction__tdef();
            break;
        }
    case TFramesFunction:
        {
            (ptr_FramesFunction())->~FramesFunction__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

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

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

MOZ_IMPLICIT TimingFunction::TimingFunction(const CubicBezierFunction& aOther)
{
    new (mozilla::KnownNotNull, ptr_CubicBezierFunction()) CubicBezierFunction(aOther);
    mType = TCubicBezierFunction;
}

MOZ_IMPLICIT TimingFunction::TimingFunction(CubicBezierFunction&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CubicBezierFunction()) CubicBezierFunction(std::move(aOther));
    mType = TCubicBezierFunction;
}

MOZ_IMPLICIT TimingFunction::TimingFunction(const StepFunction& aOther)
{
    new (mozilla::KnownNotNull, ptr_StepFunction()) StepFunction(aOther);
    mType = TStepFunction;
}

MOZ_IMPLICIT TimingFunction::TimingFunction(StepFunction&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StepFunction()) StepFunction(std::move(aOther));
    mType = TStepFunction;
}

MOZ_IMPLICIT TimingFunction::TimingFunction(const FramesFunction& aOther)
{
    new (mozilla::KnownNotNull, ptr_FramesFunction()) FramesFunction(aOther);
    mType = TFramesFunction;
}

MOZ_IMPLICIT TimingFunction::TimingFunction(FramesFunction&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FramesFunction()) FramesFunction(std::move(aOther));
    mType = TFramesFunction;
}

MOZ_IMPLICIT TimingFunction::TimingFunction(const TimingFunction& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case TCubicBezierFunction:
        {
            new (mozilla::KnownNotNull, ptr_CubicBezierFunction()) CubicBezierFunction((aOther).get_CubicBezierFunction());
            break;
        }
    case TStepFunction:
        {
            new (mozilla::KnownNotNull, ptr_StepFunction()) StepFunction((aOther).get_StepFunction());
            break;
        }
    case TFramesFunction:
        {
            new (mozilla::KnownNotNull, ptr_FramesFunction()) FramesFunction((aOther).get_FramesFunction());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT TimingFunction::TimingFunction(TimingFunction&& 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()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TCubicBezierFunction:
        {
            new (mozilla::KnownNotNull, ptr_CubicBezierFunction()) CubicBezierFunction(std::move((aOther).get_CubicBezierFunction()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TStepFunction:
        {
            new (mozilla::KnownNotNull, ptr_StepFunction()) StepFunction(std::move((aOther).get_StepFunction()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TFramesFunction:
        {
            new (mozilla::KnownNotNull, ptr_FramesFunction()) FramesFunction(std::move((aOther).get_FramesFunction()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto TimingFunction::operator=(const CubicBezierFunction& aRhs) -> TimingFunction&
{
    if (MaybeDestroy(TCubicBezierFunction)) {
        new (mozilla::KnownNotNull, ptr_CubicBezierFunction()) CubicBezierFunction;
    }
    (*(ptr_CubicBezierFunction())) = aRhs;
    mType = TCubicBezierFunction;
    return (*(this));
}

auto TimingFunction::operator=(CubicBezierFunction&& aRhs) -> TimingFunction&
{
    if (MaybeDestroy(TCubicBezierFunction)) {
        new (mozilla::KnownNotNull, ptr_CubicBezierFunction()) CubicBezierFunction;
    }
    (*(ptr_CubicBezierFunction())) = std::move(aRhs);
    mType = TCubicBezierFunction;
    return (*(this));
}

auto TimingFunction::operator=(const StepFunction& aRhs) -> TimingFunction&
{
    if (MaybeDestroy(TStepFunction)) {
        new (mozilla::KnownNotNull, ptr_StepFunction()) StepFunction;
    }
    (*(ptr_StepFunction())) = aRhs;
    mType = TStepFunction;
    return (*(this));
}

auto TimingFunction::operator=(StepFunction&& aRhs) -> TimingFunction&
{
    if (MaybeDestroy(TStepFunction)) {
        new (mozilla::KnownNotNull, ptr_StepFunction()) StepFunction;
    }
    (*(ptr_StepFunction())) = std::move(aRhs);
    mType = TStepFunction;
    return (*(this));
}

auto TimingFunction::operator=(const FramesFunction& aRhs) -> TimingFunction&
{
    if (MaybeDestroy(TFramesFunction)) {
        new (mozilla::KnownNotNull, ptr_FramesFunction()) FramesFunction;
    }
    (*(ptr_FramesFunction())) = aRhs;
    mType = TFramesFunction;
    return (*(this));
}

auto TimingFunction::operator=(FramesFunction&& aRhs) -> TimingFunction&
{
    if (MaybeDestroy(TFramesFunction)) {
        new (mozilla::KnownNotNull, ptr_FramesFunction()) FramesFunction;
    }
    (*(ptr_FramesFunction())) = std::move(aRhs);
    mType = TFramesFunction;
    return (*(this));
}

auto TimingFunction::operator=(const TimingFunction& aRhs) -> TimingFunction&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = (aRhs).get_null_t();
            break;
        }
    case TCubicBezierFunction:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_CubicBezierFunction()) CubicBezierFunction;
            }
            (*(ptr_CubicBezierFunction())) = (aRhs).get_CubicBezierFunction();
            break;
        }
    case TStepFunction:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_StepFunction()) StepFunction;
            }
            (*(ptr_StepFunction())) = (aRhs).get_StepFunction();
            break;
        }
    case TFramesFunction:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FramesFunction()) FramesFunction;
            }
            (*(ptr_FramesFunction())) = (aRhs).get_FramesFunction();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto TimingFunction::operator=(TimingFunction&& aRhs) -> TimingFunction&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = std::move((aRhs).get_null_t());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TCubicBezierFunction:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_CubicBezierFunction()) CubicBezierFunction;
            }
            (*(ptr_CubicBezierFunction())) = std::move((aRhs).get_CubicBezierFunction());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TStepFunction:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_StepFunction()) StepFunction;
            }
            (*(ptr_StepFunction())) = std::move((aRhs).get_StepFunction());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TFramesFunction:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FramesFunction()) FramesFunction;
            }
            (*(ptr_FramesFunction())) = std::move((aRhs).get_FramesFunction());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

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

auto TimingFunction::operator==(const CubicBezierFunction& aRhs) const -> bool
{
    return (get_CubicBezierFunction()) == (aRhs);
}

auto TimingFunction::operator==(const StepFunction& aRhs) const -> bool
{
    return (get_StepFunction()) == (aRhs);
}

auto TimingFunction::operator==(const FramesFunction& aRhs) const -> bool
{
    return (get_FramesFunction()) == (aRhs);
}

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

    switch (type()) {
    case Tnull_t:
        {
            return (get_null_t()) == ((aRhs).get_null_t());
        }
    case TCubicBezierFunction:
        {
            return (get_CubicBezierFunction()) == ((aRhs).get_CubicBezierFunction());
        }
    case TStepFunction:
        {
            return (get_StepFunction()) == ((aRhs).get_StepFunction());
        }
    case TFramesFunction:
        {
            return (get_FramesFunction()) == ((aRhs).get_FramesFunction());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

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

auto TimingFunction::get(CubicBezierFunction* aOutValue) const -> void
{
    (*(aOutValue)) = get_CubicBezierFunction();
}

auto TimingFunction::get(StepFunction* aOutValue) const -> void
{
    (*(aOutValue)) = get_StepFunction();
}

auto TimingFunction::get(FramesFunction* aOutValue) const -> void
{
    (*(aOutValue)) = get_FramesFunction();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::Tnull_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aMsg)->WriteSentinel(3731137201);
            return;
        }
    case union__::TCubicBezierFunction:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_CubicBezierFunction());
            // Sentinel = 'TCubicBezierFunction'
            (aMsg)->WriteSentinel(258133495);
            return;
        }
    case union__::TStepFunction:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_StepFunction());
            // Sentinel = 'TStepFunction'
            (aMsg)->WriteSentinel(2005731339);
            return;
        }
    case union__::TFramesFunction:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FramesFunction());
            // Sentinel = 'TFramesFunction'
            (aMsg)->WriteSentinel(492999321);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::Tnull_t:
        {
            mozilla::null_t tmp = mozilla::null_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_null_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tnull_t of union TimingFunction");
                return false;
            }
            // Sentinel = 'Tnull_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3731137201)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union TimingFunction");
                return false;
            }
            return true;
        }
    case union__::TCubicBezierFunction:
        {
            mozilla::layers::CubicBezierFunction tmp = mozilla::layers::CubicBezierFunction();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_CubicBezierFunction())))))) {
                (aActor)->FatalError("Error deserializing variant TCubicBezierFunction of union TimingFunction");
                return false;
            }
            // Sentinel = 'TCubicBezierFunction'
            if ((!((aMsg)->ReadSentinel(aIter, 258133495)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCubicBezierFunction of union TimingFunction");
                return false;
            }
            return true;
        }
    case union__::TStepFunction:
        {
            mozilla::layers::StepFunction tmp = mozilla::layers::StepFunction();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_StepFunction())))))) {
                (aActor)->FatalError("Error deserializing variant TStepFunction of union TimingFunction");
                return false;
            }
            // Sentinel = 'TStepFunction'
            if ((!((aMsg)->ReadSentinel(aIter, 2005731339)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStepFunction of union TimingFunction");
                return false;
            }
            return true;
        }
    case union__::TFramesFunction:
        {
            mozilla::layers::FramesFunction tmp = mozilla::layers::FramesFunction();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FramesFunction())))))) {
                (aActor)->FatalError("Error deserializing variant TFramesFunction of union TimingFunction");
                return false;
            }
            // Sentinel = 'TFramesFunction'
            if ((!((aMsg)->ReadSentinel(aIter, 492999321)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFramesFunction of union TimingFunction");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::Rotation3D>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).x());
    // Sentinel = 'x'
    (aMsg)->WriteSentinel(2475144313);
    WriteIPDLParam(aMsg, aActor, (aVar).y());
    // Sentinel = 'y'
    (aMsg)->WriteSentinel(2603144696);
    WriteIPDLParam(aMsg, aActor, (aVar).z());
    // Sentinel = 'z'
    (aMsg)->WriteSentinel(2731145083);
    WriteIPDLParam(aMsg, aActor, (aVar).angle());
    // Sentinel = 'angle'
    (aMsg)->WriteSentinel(3388308388);
}

auto IPDLParamTraits<mozilla::layers::Rotation3D>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->x())))))) {
        (aActor)->FatalError("Error deserializing 'x' (float) member of 'Rotation3D'");
        return false;
    }
    // Sentinel = 'x'
    if ((!((aMsg)->ReadSentinel(aIter, 2475144313)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'x' (float) member of 'Rotation3D'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->y())))))) {
        (aActor)->FatalError("Error deserializing 'y' (float) member of 'Rotation3D'");
        return false;
    }
    // Sentinel = 'y'
    if ((!((aMsg)->ReadSentinel(aIter, 2603144696)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'y' (float) member of 'Rotation3D'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->z())))))) {
        (aActor)->FatalError("Error deserializing 'z' (float) member of 'Rotation3D'");
        return false;
    }
    // Sentinel = 'z'
    if ((!((aMsg)->ReadSentinel(aIter, 2731145083)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'z' (float) member of 'Rotation3D'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->angle())))))) {
        (aActor)->FatalError("Error deserializing 'angle' (CSSAngle) member of 'Rotation3D'");
        return false;
    }
    // Sentinel = 'angle'
    if ((!((aMsg)->ReadSentinel(aIter, 3388308388)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'angle' (CSSAngle) member of 'Rotation3D'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::Scale>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).x());
    // Sentinel = 'x'
    (aMsg)->WriteSentinel(2475144313);
    WriteIPDLParam(aMsg, aActor, (aVar).y());
    // Sentinel = 'y'
    (aMsg)->WriteSentinel(2603144696);
    WriteIPDLParam(aMsg, aActor, (aVar).z());
    // Sentinel = 'z'
    (aMsg)->WriteSentinel(2731145083);
}

auto IPDLParamTraits<mozilla::layers::Scale>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->x())))))) {
        (aActor)->FatalError("Error deserializing 'x' (float) member of 'Scale'");
        return false;
    }
    // Sentinel = 'x'
    if ((!((aMsg)->ReadSentinel(aIter, 2475144313)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'x' (float) member of 'Scale'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->y())))))) {
        (aActor)->FatalError("Error deserializing 'y' (float) member of 'Scale'");
        return false;
    }
    // Sentinel = 'y'
    if ((!((aMsg)->ReadSentinel(aIter, 2603144696)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'y' (float) member of 'Scale'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->z())))))) {
        (aActor)->FatalError("Error deserializing 'z' (float) member of 'Scale'");
        return false;
    }
    // Sentinel = 'z'
    if ((!((aMsg)->ReadSentinel(aIter, 2731145083)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'z' (float) member of 'Scale'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::Translation>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).x());
    // Sentinel = 'x'
    (aMsg)->WriteSentinel(2475144313);
    WriteIPDLParam(aMsg, aActor, (aVar).y());
    // Sentinel = 'y'
    (aMsg)->WriteSentinel(2603144696);
    WriteIPDLParam(aMsg, aActor, (aVar).z());
    // Sentinel = 'z'
    (aMsg)->WriteSentinel(2731145083);
}

auto IPDLParamTraits<mozilla::layers::Translation>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->x())))))) {
        (aActor)->FatalError("Error deserializing 'x' (float) member of 'Translation'");
        return false;
    }
    // Sentinel = 'x'
    if ((!((aMsg)->ReadSentinel(aIter, 2475144313)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'x' (float) member of 'Translation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->y())))))) {
        (aActor)->FatalError("Error deserializing 'y' (float) member of 'Translation'");
        return false;
    }
    // Sentinel = 'y'
    if ((!((aMsg)->ReadSentinel(aIter, 2603144696)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'y' (float) member of 'Translation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->z())))))) {
        (aActor)->FatalError("Error deserializing 'z' (float) member of 'Translation'");
        return false;
    }
    // Sentinel = 'z'
    if ((!((aMsg)->ReadSentinel(aIter, 2731145083)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'z' (float) member of 'Translation'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union TransformFunction|
//
namespace mozilla {
namespace layers {
auto TransformFunction::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TPerspective:
        {
            (ptr_Perspective())->~Perspective__tdef();
            break;
        }
    case TRotationX:
        {
            (ptr_RotationX())->~RotationX__tdef();
            break;
        }
    case TRotationY:
        {
            (ptr_RotationY())->~RotationY__tdef();
            break;
        }
    case TRotationZ:
        {
            (ptr_RotationZ())->~RotationZ__tdef();
            break;
        }
    case TRotation:
        {
            (ptr_Rotation())->~Rotation__tdef();
            break;
        }
    case TRotation3D:
        {
            (ptr_Rotation3D())->~Rotation3D__tdef();
            break;
        }
    case TScale:
        {
            (ptr_Scale())->~Scale__tdef();
            break;
        }
    case TSkew:
        {
            (ptr_Skew())->~Skew__tdef();
            break;
        }
    case TSkewX:
        {
            (ptr_SkewX())->~SkewX__tdef();
            break;
        }
    case TSkewY:
        {
            (ptr_SkewY())->~SkewY__tdef();
            break;
        }
    case TTranslation:
        {
            (ptr_Translation())->~Translation__tdef();
            break;
        }
    case TTransformMatrix:
        {
            (ptr_TransformMatrix())->~TransformMatrix__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(const Perspective& aOther)
{
    new (mozilla::KnownNotNull, ptr_Perspective()) Perspective(aOther);
    mType = TPerspective;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(Perspective&& aOther)
{
    new (mozilla::KnownNotNull, ptr_Perspective()) Perspective(std::move(aOther));
    mType = TPerspective;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(const RotationX& aOther)
{
    new (mozilla::KnownNotNull, ptr_RotationX()) RotationX(aOther);
    mType = TRotationX;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(RotationX&& aOther)
{
    new (mozilla::KnownNotNull, ptr_RotationX()) RotationX(std::move(aOther));
    mType = TRotationX;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(const RotationY& aOther)
{
    new (mozilla::KnownNotNull, ptr_RotationY()) RotationY(aOther);
    mType = TRotationY;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(RotationY&& aOther)
{
    new (mozilla::KnownNotNull, ptr_RotationY()) RotationY(std::move(aOther));
    mType = TRotationY;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(const RotationZ& aOther)
{
    new (mozilla::KnownNotNull, ptr_RotationZ()) RotationZ(aOther);
    mType = TRotationZ;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(RotationZ&& aOther)
{
    new (mozilla::KnownNotNull, ptr_RotationZ()) RotationZ(std::move(aOther));
    mType = TRotationZ;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(const Rotation& aOther)
{
    new (mozilla::KnownNotNull, ptr_Rotation()) Rotation(aOther);
    mType = TRotation;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(Rotation&& aOther)
{
    new (mozilla::KnownNotNull, ptr_Rotation()) Rotation(std::move(aOther));
    mType = TRotation;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(const Rotation3D& aOther)
{
    new (mozilla::KnownNotNull, ptr_Rotation3D()) Rotation3D(aOther);
    mType = TRotation3D;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(Rotation3D&& aOther)
{
    new (mozilla::KnownNotNull, ptr_Rotation3D()) Rotation3D(std::move(aOther));
    mType = TRotation3D;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(const Scale& aOther)
{
    new (mozilla::KnownNotNull, ptr_Scale()) Scale(aOther);
    mType = TScale;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(Scale&& aOther)
{
    new (mozilla::KnownNotNull, ptr_Scale()) Scale(std::move(aOther));
    mType = TScale;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(const Skew& aOther)
{
    new (mozilla::KnownNotNull, ptr_Skew()) Skew(aOther);
    mType = TSkew;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(Skew&& aOther)
{
    new (mozilla::KnownNotNull, ptr_Skew()) Skew(std::move(aOther));
    mType = TSkew;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(const SkewX& aOther)
{
    new (mozilla::KnownNotNull, ptr_SkewX()) SkewX(aOther);
    mType = TSkewX;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(SkewX&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SkewX()) SkewX(std::move(aOther));
    mType = TSkewX;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(const SkewY& aOther)
{
    new (mozilla::KnownNotNull, ptr_SkewY()) SkewY(aOther);
    mType = TSkewY;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(SkewY&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SkewY()) SkewY(std::move(aOther));
    mType = TSkewY;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(const Translation& aOther)
{
    new (mozilla::KnownNotNull, ptr_Translation()) Translation(aOther);
    mType = TTranslation;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(Translation&& aOther)
{
    new (mozilla::KnownNotNull, ptr_Translation()) Translation(std::move(aOther));
    mType = TTranslation;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(const TransformMatrix& aOther)
{
    new (mozilla::KnownNotNull, ptr_TransformMatrix()) TransformMatrix(aOther);
    mType = TTransformMatrix;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(TransformMatrix&& aOther)
{
    new (mozilla::KnownNotNull, ptr_TransformMatrix()) TransformMatrix(std::move(aOther));
    mType = TTransformMatrix;
}

MOZ_IMPLICIT TransformFunction::TransformFunction(const TransformFunction& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TPerspective:
        {
            new (mozilla::KnownNotNull, ptr_Perspective()) Perspective((aOther).get_Perspective());
            break;
        }
    case TRotationX:
        {
            new (mozilla::KnownNotNull, ptr_RotationX()) RotationX((aOther).get_RotationX());
            break;
        }
    case TRotationY:
        {
            new (mozilla::KnownNotNull, ptr_RotationY()) RotationY((aOther).get_RotationY());
            break;
        }
    case TRotationZ:
        {
            new (mozilla::KnownNotNull, ptr_RotationZ()) RotationZ((aOther).get_RotationZ());
            break;
        }
    case TRotation:
        {
            new (mozilla::KnownNotNull, ptr_Rotation()) Rotation((aOther).get_Rotation());
            break;
        }
    case TRotation3D:
        {
            new (mozilla::KnownNotNull, ptr_Rotation3D()) Rotation3D((aOther).get_Rotation3D());
            break;
        }
    case TScale:
        {
            new (mozilla::KnownNotNull, ptr_Scale()) Scale((aOther).get_Scale());
            break;
        }
    case TSkew:
        {
            new (mozilla::KnownNotNull, ptr_Skew()) Skew((aOther).get_Skew());
            break;
        }
    case TSkewX:
        {
            new (mozilla::KnownNotNull, ptr_SkewX()) SkewX((aOther).get_SkewX());
            break;
        }
    case TSkewY:
        {
            new (mozilla::KnownNotNull, ptr_SkewY()) SkewY((aOther).get_SkewY());
            break;
        }
    case TTranslation:
        {
            new (mozilla::KnownNotNull, ptr_Translation()) Translation((aOther).get_Translation());
            break;
        }
    case TTransformMatrix:
        {
            new (mozilla::KnownNotNull, ptr_TransformMatrix()) TransformMatrix((aOther).get_TransformMatrix());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT TransformFunction::TransformFunction(TransformFunction&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TPerspective:
        {
            new (mozilla::KnownNotNull, ptr_Perspective()) Perspective(std::move((aOther).get_Perspective()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TRotationX:
        {
            new (mozilla::KnownNotNull, ptr_RotationX()) RotationX(std::move((aOther).get_RotationX()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TRotationY:
        {
            new (mozilla::KnownNotNull, ptr_RotationY()) RotationY(std::move((aOther).get_RotationY()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TRotationZ:
        {
            new (mozilla::KnownNotNull, ptr_RotationZ()) RotationZ(std::move((aOther).get_RotationZ()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TRotation:
        {
            new (mozilla::KnownNotNull, ptr_Rotation()) Rotation(std::move((aOther).get_Rotation()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TRotation3D:
        {
            new (mozilla::KnownNotNull, ptr_Rotation3D()) Rotation3D(std::move((aOther).get_Rotation3D()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TScale:
        {
            new (mozilla::KnownNotNull, ptr_Scale()) Scale(std::move((aOther).get_Scale()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TSkew:
        {
            new (mozilla::KnownNotNull, ptr_Skew()) Skew(std::move((aOther).get_Skew()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TSkewX:
        {
            new (mozilla::KnownNotNull, ptr_SkewX()) SkewX(std::move((aOther).get_SkewX()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TSkewY:
        {
            new (mozilla::KnownNotNull, ptr_SkewY()) SkewY(std::move((aOther).get_SkewY()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TTranslation:
        {
            new (mozilla::KnownNotNull, ptr_Translation()) Translation(std::move((aOther).get_Translation()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TTransformMatrix:
        {
            new (mozilla::KnownNotNull, ptr_TransformMatrix()) TransformMatrix(std::move((aOther).get_TransformMatrix()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto TransformFunction::operator=(const Perspective& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TPerspective)) {
        new (mozilla::KnownNotNull, ptr_Perspective()) Perspective;
    }
    (*(ptr_Perspective())) = aRhs;
    mType = TPerspective;
    return (*(this));
}

auto TransformFunction::operator=(Perspective&& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TPerspective)) {
        new (mozilla::KnownNotNull, ptr_Perspective()) Perspective;
    }
    (*(ptr_Perspective())) = std::move(aRhs);
    mType = TPerspective;
    return (*(this));
}

auto TransformFunction::operator=(const RotationX& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TRotationX)) {
        new (mozilla::KnownNotNull, ptr_RotationX()) RotationX;
    }
    (*(ptr_RotationX())) = aRhs;
    mType = TRotationX;
    return (*(this));
}

auto TransformFunction::operator=(RotationX&& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TRotationX)) {
        new (mozilla::KnownNotNull, ptr_RotationX()) RotationX;
    }
    (*(ptr_RotationX())) = std::move(aRhs);
    mType = TRotationX;
    return (*(this));
}

auto TransformFunction::operator=(const RotationY& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TRotationY)) {
        new (mozilla::KnownNotNull, ptr_RotationY()) RotationY;
    }
    (*(ptr_RotationY())) = aRhs;
    mType = TRotationY;
    return (*(this));
}

auto TransformFunction::operator=(RotationY&& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TRotationY)) {
        new (mozilla::KnownNotNull, ptr_RotationY()) RotationY;
    }
    (*(ptr_RotationY())) = std::move(aRhs);
    mType = TRotationY;
    return (*(this));
}

auto TransformFunction::operator=(const RotationZ& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TRotationZ)) {
        new (mozilla::KnownNotNull, ptr_RotationZ()) RotationZ;
    }
    (*(ptr_RotationZ())) = aRhs;
    mType = TRotationZ;
    return (*(this));
}

auto TransformFunction::operator=(RotationZ&& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TRotationZ)) {
        new (mozilla::KnownNotNull, ptr_RotationZ()) RotationZ;
    }
    (*(ptr_RotationZ())) = std::move(aRhs);
    mType = TRotationZ;
    return (*(this));
}

auto TransformFunction::operator=(const Rotation& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TRotation)) {
        new (mozilla::KnownNotNull, ptr_Rotation()) Rotation;
    }
    (*(ptr_Rotation())) = aRhs;
    mType = TRotation;
    return (*(this));
}

auto TransformFunction::operator=(Rotation&& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TRotation)) {
        new (mozilla::KnownNotNull, ptr_Rotation()) Rotation;
    }
    (*(ptr_Rotation())) = std::move(aRhs);
    mType = TRotation;
    return (*(this));
}

auto TransformFunction::operator=(const Rotation3D& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TRotation3D)) {
        new (mozilla::KnownNotNull, ptr_Rotation3D()) Rotation3D;
    }
    (*(ptr_Rotation3D())) = aRhs;
    mType = TRotation3D;
    return (*(this));
}

auto TransformFunction::operator=(Rotation3D&& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TRotation3D)) {
        new (mozilla::KnownNotNull, ptr_Rotation3D()) Rotation3D;
    }
    (*(ptr_Rotation3D())) = std::move(aRhs);
    mType = TRotation3D;
    return (*(this));
}

auto TransformFunction::operator=(const Scale& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TScale)) {
        new (mozilla::KnownNotNull, ptr_Scale()) Scale;
    }
    (*(ptr_Scale())) = aRhs;
    mType = TScale;
    return (*(this));
}

auto TransformFunction::operator=(Scale&& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TScale)) {
        new (mozilla::KnownNotNull, ptr_Scale()) Scale;
    }
    (*(ptr_Scale())) = std::move(aRhs);
    mType = TScale;
    return (*(this));
}

auto TransformFunction::operator=(const Skew& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TSkew)) {
        new (mozilla::KnownNotNull, ptr_Skew()) Skew;
    }
    (*(ptr_Skew())) = aRhs;
    mType = TSkew;
    return (*(this));
}

auto TransformFunction::operator=(Skew&& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TSkew)) {
        new (mozilla::KnownNotNull, ptr_Skew()) Skew;
    }
    (*(ptr_Skew())) = std::move(aRhs);
    mType = TSkew;
    return (*(this));
}

auto TransformFunction::operator=(const SkewX& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TSkewX)) {
        new (mozilla::KnownNotNull, ptr_SkewX()) SkewX;
    }
    (*(ptr_SkewX())) = aRhs;
    mType = TSkewX;
    return (*(this));
}

auto TransformFunction::operator=(SkewX&& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TSkewX)) {
        new (mozilla::KnownNotNull, ptr_SkewX()) SkewX;
    }
    (*(ptr_SkewX())) = std::move(aRhs);
    mType = TSkewX;
    return (*(this));
}

auto TransformFunction::operator=(const SkewY& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TSkewY)) {
        new (mozilla::KnownNotNull, ptr_SkewY()) SkewY;
    }
    (*(ptr_SkewY())) = aRhs;
    mType = TSkewY;
    return (*(this));
}

auto TransformFunction::operator=(SkewY&& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TSkewY)) {
        new (mozilla::KnownNotNull, ptr_SkewY()) SkewY;
    }
    (*(ptr_SkewY())) = std::move(aRhs);
    mType = TSkewY;
    return (*(this));
}

auto TransformFunction::operator=(const Translation& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TTranslation)) {
        new (mozilla::KnownNotNull, ptr_Translation()) Translation;
    }
    (*(ptr_Translation())) = aRhs;
    mType = TTranslation;
    return (*(this));
}

auto TransformFunction::operator=(Translation&& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TTranslation)) {
        new (mozilla::KnownNotNull, ptr_Translation()) Translation;
    }
    (*(ptr_Translation())) = std::move(aRhs);
    mType = TTranslation;
    return (*(this));
}

auto TransformFunction::operator=(const TransformMatrix& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TTransformMatrix)) {
        new (mozilla::KnownNotNull, ptr_TransformMatrix()) TransformMatrix;
    }
    (*(ptr_TransformMatrix())) = aRhs;
    mType = TTransformMatrix;
    return (*(this));
}

auto TransformFunction::operator=(TransformMatrix&& aRhs) -> TransformFunction&
{
    if (MaybeDestroy(TTransformMatrix)) {
        new (mozilla::KnownNotNull, ptr_TransformMatrix()) TransformMatrix;
    }
    (*(ptr_TransformMatrix())) = std::move(aRhs);
    mType = TTransformMatrix;
    return (*(this));
}

auto TransformFunction::operator=(const TransformFunction& aRhs) -> TransformFunction&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TPerspective:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Perspective()) Perspective;
            }
            (*(ptr_Perspective())) = (aRhs).get_Perspective();
            break;
        }
    case TRotationX:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_RotationX()) RotationX;
            }
            (*(ptr_RotationX())) = (aRhs).get_RotationX();
            break;
        }
    case TRotationY:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_RotationY()) RotationY;
            }
            (*(ptr_RotationY())) = (aRhs).get_RotationY();
            break;
        }
    case TRotationZ:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_RotationZ()) RotationZ;
            }
            (*(ptr_RotationZ())) = (aRhs).get_RotationZ();
            break;
        }
    case TRotation:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Rotation()) Rotation;
            }
            (*(ptr_Rotation())) = (aRhs).get_Rotation();
            break;
        }
    case TRotation3D:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Rotation3D()) Rotation3D;
            }
            (*(ptr_Rotation3D())) = (aRhs).get_Rotation3D();
            break;
        }
    case TScale:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Scale()) Scale;
            }
            (*(ptr_Scale())) = (aRhs).get_Scale();
            break;
        }
    case TSkew:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Skew()) Skew;
            }
            (*(ptr_Skew())) = (aRhs).get_Skew();
            break;
        }
    case TSkewX:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SkewX()) SkewX;
            }
            (*(ptr_SkewX())) = (aRhs).get_SkewX();
            break;
        }
    case TSkewY:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SkewY()) SkewY;
            }
            (*(ptr_SkewY())) = (aRhs).get_SkewY();
            break;
        }
    case TTranslation:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Translation()) Translation;
            }
            (*(ptr_Translation())) = (aRhs).get_Translation();
            break;
        }
    case TTransformMatrix:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_TransformMatrix()) TransformMatrix;
            }
            (*(ptr_TransformMatrix())) = (aRhs).get_TransformMatrix();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto TransformFunction::operator=(TransformFunction&& aRhs) -> TransformFunction&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TPerspective:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Perspective()) Perspective;
            }
            (*(ptr_Perspective())) = std::move((aRhs).get_Perspective());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TRotationX:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_RotationX()) RotationX;
            }
            (*(ptr_RotationX())) = std::move((aRhs).get_RotationX());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TRotationY:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_RotationY()) RotationY;
            }
            (*(ptr_RotationY())) = std::move((aRhs).get_RotationY());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TRotationZ:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_RotationZ()) RotationZ;
            }
            (*(ptr_RotationZ())) = std::move((aRhs).get_RotationZ());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TRotation:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Rotation()) Rotation;
            }
            (*(ptr_Rotation())) = std::move((aRhs).get_Rotation());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TRotation3D:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Rotation3D()) Rotation3D;
            }
            (*(ptr_Rotation3D())) = std::move((aRhs).get_Rotation3D());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TScale:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Scale()) Scale;
            }
            (*(ptr_Scale())) = std::move((aRhs).get_Scale());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TSkew:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Skew()) Skew;
            }
            (*(ptr_Skew())) = std::move((aRhs).get_Skew());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TSkewX:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SkewX()) SkewX;
            }
            (*(ptr_SkewX())) = std::move((aRhs).get_SkewX());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TSkewY:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SkewY()) SkewY;
            }
            (*(ptr_SkewY())) = std::move((aRhs).get_SkewY());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TTranslation:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Translation()) Translation;
            }
            (*(ptr_Translation())) = std::move((aRhs).get_Translation());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TTransformMatrix:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_TransformMatrix()) TransformMatrix;
            }
            (*(ptr_TransformMatrix())) = std::move((aRhs).get_TransformMatrix());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto TransformFunction::operator==(const Perspective& aRhs) const -> bool
{
    return (get_Perspective()) == (aRhs);
}

auto TransformFunction::operator==(const RotationX& aRhs) const -> bool
{
    return (get_RotationX()) == (aRhs);
}

auto TransformFunction::operator==(const RotationY& aRhs) const -> bool
{
    return (get_RotationY()) == (aRhs);
}

auto TransformFunction::operator==(const RotationZ& aRhs) const -> bool
{
    return (get_RotationZ()) == (aRhs);
}

auto TransformFunction::operator==(const Rotation& aRhs) const -> bool
{
    return (get_Rotation()) == (aRhs);
}

auto TransformFunction::operator==(const Rotation3D& aRhs) const -> bool
{
    return (get_Rotation3D()) == (aRhs);
}

auto TransformFunction::operator==(const Scale& aRhs) const -> bool
{
    return (get_Scale()) == (aRhs);
}

auto TransformFunction::operator==(const Skew& aRhs) const -> bool
{
    return (get_Skew()) == (aRhs);
}

auto TransformFunction::operator==(const SkewX& aRhs) const -> bool
{
    return (get_SkewX()) == (aRhs);
}

auto TransformFunction::operator==(const SkewY& aRhs) const -> bool
{
    return (get_SkewY()) == (aRhs);
}

auto TransformFunction::operator==(const Translation& aRhs) const -> bool
{
    return (get_Translation()) == (aRhs);
}

auto TransformFunction::operator==(const TransformMatrix& aRhs) const -> bool
{
    return (get_TransformMatrix()) == (aRhs);
}

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

    switch (type()) {
    case TPerspective:
        {
            return (get_Perspective()) == ((aRhs).get_Perspective());
        }
    case TRotationX:
        {
            return (get_RotationX()) == ((aRhs).get_RotationX());
        }
    case TRotationY:
        {
            return (get_RotationY()) == ((aRhs).get_RotationY());
        }
    case TRotationZ:
        {
            return (get_RotationZ()) == ((aRhs).get_RotationZ());
        }
    case TRotation:
        {
            return (get_Rotation()) == ((aRhs).get_Rotation());
        }
    case TRotation3D:
        {
            return (get_Rotation3D()) == ((aRhs).get_Rotation3D());
        }
    case TScale:
        {
            return (get_Scale()) == ((aRhs).get_Scale());
        }
    case TSkew:
        {
            return (get_Skew()) == ((aRhs).get_Skew());
        }
    case TSkewX:
        {
            return (get_SkewX()) == ((aRhs).get_SkewX());
        }
    case TSkewY:
        {
            return (get_SkewY()) == ((aRhs).get_SkewY());
        }
    case TTranslation:
        {
            return (get_Translation()) == ((aRhs).get_Translation());
        }
    case TTransformMatrix:
        {
            return (get_TransformMatrix()) == ((aRhs).get_TransformMatrix());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto TransformFunction::get(Perspective* aOutValue) const -> void
{
    (*(aOutValue)) = get_Perspective();
}

auto TransformFunction::get(RotationX* aOutValue) const -> void
{
    (*(aOutValue)) = get_RotationX();
}

auto TransformFunction::get(RotationY* aOutValue) const -> void
{
    (*(aOutValue)) = get_RotationY();
}

auto TransformFunction::get(RotationZ* aOutValue) const -> void
{
    (*(aOutValue)) = get_RotationZ();
}

auto TransformFunction::get(Rotation* aOutValue) const -> void
{
    (*(aOutValue)) = get_Rotation();
}

auto TransformFunction::get(Rotation3D* aOutValue) const -> void
{
    (*(aOutValue)) = get_Rotation3D();
}

auto TransformFunction::get(Scale* aOutValue) const -> void
{
    (*(aOutValue)) = get_Scale();
}

auto TransformFunction::get(Skew* aOutValue) const -> void
{
    (*(aOutValue)) = get_Skew();
}

auto TransformFunction::get(SkewX* aOutValue) const -> void
{
    (*(aOutValue)) = get_SkewX();
}

auto TransformFunction::get(SkewY* aOutValue) const -> void
{
    (*(aOutValue)) = get_SkewY();
}

auto TransformFunction::get(Translation* aOutValue) const -> void
{
    (*(aOutValue)) = get_Translation();
}

auto TransformFunction::get(TransformMatrix* aOutValue) const -> void
{
    (*(aOutValue)) = get_TransformMatrix();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TPerspective:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_Perspective());
            // Sentinel = 'TPerspective'
            (aMsg)->WriteSentinel(536769614);
            return;
        }
    case union__::TRotationX:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_RotationX());
            // Sentinel = 'TRotationX'
            (aMsg)->WriteSentinel(3076537720);
            return;
        }
    case union__::TRotationY:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_RotationY());
            // Sentinel = 'TRotationY'
            (aMsg)->WriteSentinel(3076537721);
            return;
        }
    case union__::TRotationZ:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_RotationZ());
            // Sentinel = 'TRotationZ'
            (aMsg)->WriteSentinel(3076537722);
            return;
        }
    case union__::TRotation:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_Rotation());
            // Sentinel = 'TRotation'
            (aMsg)->WriteSentinel(204395655);
            return;
        }
    case union__::TRotation3D:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_Rotation3D());
            // Sentinel = 'TRotation3D'
            (aMsg)->WriteSentinel(1650945988);
            return;
        }
    case union__::TScale:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_Scale());
            // Sentinel = 'TScale'
            (aMsg)->WriteSentinel(4188009060);
            return;
        }
    case union__::TSkew:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_Skew());
            // Sentinel = 'TSkew'
            (aMsg)->WriteSentinel(398444919);
            return;
        }
    case union__::TSkewX:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SkewX());
            // Sentinel = 'TSkewX'
            (aMsg)->WriteSentinel(1993284744);
            return;
        }
    case union__::TSkewY:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SkewY());
            // Sentinel = 'TSkewY'
            (aMsg)->WriteSentinel(1993284745);
            return;
        }
    case union__::TTranslation:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_Translation());
            // Sentinel = 'TTranslation'
            (aMsg)->WriteSentinel(2021428737);
            return;
        }
    case union__::TTransformMatrix:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_TransformMatrix());
            // Sentinel = 'TTransformMatrix'
            (aMsg)->WriteSentinel(2585816443);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TPerspective:
        {
            mozilla::layers::Perspective tmp = mozilla::layers::Perspective();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_Perspective())))))) {
                (aActor)->FatalError("Error deserializing variant TPerspective of union TransformFunction");
                return false;
            }
            // Sentinel = 'TPerspective'
            if ((!((aMsg)->ReadSentinel(aIter, 536769614)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPerspective of union TransformFunction");
                return false;
            }
            return true;
        }
    case union__::TRotationX:
        {
            mozilla::layers::RotationX tmp = mozilla::layers::RotationX();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_RotationX())))))) {
                (aActor)->FatalError("Error deserializing variant TRotationX of union TransformFunction");
                return false;
            }
            // Sentinel = 'TRotationX'
            if ((!((aMsg)->ReadSentinel(aIter, 3076537720)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TRotationX of union TransformFunction");
                return false;
            }
            return true;
        }
    case union__::TRotationY:
        {
            mozilla::layers::RotationY tmp = mozilla::layers::RotationY();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_RotationY())))))) {
                (aActor)->FatalError("Error deserializing variant TRotationY of union TransformFunction");
                return false;
            }
            // Sentinel = 'TRotationY'
            if ((!((aMsg)->ReadSentinel(aIter, 3076537721)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TRotationY of union TransformFunction");
                return false;
            }
            return true;
        }
    case union__::TRotationZ:
        {
            mozilla::layers::RotationZ tmp = mozilla::layers::RotationZ();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_RotationZ())))))) {
                (aActor)->FatalError("Error deserializing variant TRotationZ of union TransformFunction");
                return false;
            }
            // Sentinel = 'TRotationZ'
            if ((!((aMsg)->ReadSentinel(aIter, 3076537722)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TRotationZ of union TransformFunction");
                return false;
            }
            return true;
        }
    case union__::TRotation:
        {
            mozilla::layers::Rotation tmp = mozilla::layers::Rotation();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_Rotation())))))) {
                (aActor)->FatalError("Error deserializing variant TRotation of union TransformFunction");
                return false;
            }
            // Sentinel = 'TRotation'
            if ((!((aMsg)->ReadSentinel(aIter, 204395655)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TRotation of union TransformFunction");
                return false;
            }
            return true;
        }
    case union__::TRotation3D:
        {
            mozilla::layers::Rotation3D tmp = mozilla::layers::Rotation3D();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_Rotation3D())))))) {
                (aActor)->FatalError("Error deserializing variant TRotation3D of union TransformFunction");
                return false;
            }
            // Sentinel = 'TRotation3D'
            if ((!((aMsg)->ReadSentinel(aIter, 1650945988)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TRotation3D of union TransformFunction");
                return false;
            }
            return true;
        }
    case union__::TScale:
        {
            mozilla::layers::Scale tmp = mozilla::layers::Scale();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_Scale())))))) {
                (aActor)->FatalError("Error deserializing variant TScale of union TransformFunction");
                return false;
            }
            // Sentinel = 'TScale'
            if ((!((aMsg)->ReadSentinel(aIter, 4188009060)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TScale of union TransformFunction");
                return false;
            }
            return true;
        }
    case union__::TSkew:
        {
            mozilla::layers::Skew tmp = mozilla::layers::Skew();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_Skew())))))) {
                (aActor)->FatalError("Error deserializing variant TSkew of union TransformFunction");
                return false;
            }
            // Sentinel = 'TSkew'
            if ((!((aMsg)->ReadSentinel(aIter, 398444919)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSkew of union TransformFunction");
                return false;
            }
            return true;
        }
    case union__::TSkewX:
        {
            mozilla::layers::SkewX tmp = mozilla::layers::SkewX();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SkewX())))))) {
                (aActor)->FatalError("Error deserializing variant TSkewX of union TransformFunction");
                return false;
            }
            // Sentinel = 'TSkewX'
            if ((!((aMsg)->ReadSentinel(aIter, 1993284744)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSkewX of union TransformFunction");
                return false;
            }
            return true;
        }
    case union__::TSkewY:
        {
            mozilla::layers::SkewY tmp = mozilla::layers::SkewY();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SkewY())))))) {
                (aActor)->FatalError("Error deserializing variant TSkewY of union TransformFunction");
                return false;
            }
            // Sentinel = 'TSkewY'
            if ((!((aMsg)->ReadSentinel(aIter, 1993284745)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSkewY of union TransformFunction");
                return false;
            }
            return true;
        }
    case union__::TTranslation:
        {
            mozilla::layers::Translation tmp = mozilla::layers::Translation();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_Translation())))))) {
                (aActor)->FatalError("Error deserializing variant TTranslation of union TransformFunction");
                return false;
            }
            // Sentinel = 'TTranslation'
            if ((!((aMsg)->ReadSentinel(aIter, 2021428737)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TTranslation of union TransformFunction");
                return false;
            }
            return true;
        }
    case union__::TTransformMatrix:
        {
            mozilla::layers::TransformMatrix tmp = mozilla::layers::TransformMatrix();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_TransformMatrix())))))) {
                (aActor)->FatalError("Error deserializing variant TTransformMatrix of union TransformFunction");
                return false;
            }
            // Sentinel = 'TTransformMatrix'
            if ((!((aMsg)->ReadSentinel(aIter, 2585816443)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TTransformMatrix of union TransformFunction");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

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

MOZ_IMPLICIT MaybeTimeDuration::MaybeTimeDuration(const TimeDuration& aOther)
{
    new (mozilla::KnownNotNull, ptr_TimeDuration()) TimeDuration(aOther);
    mType = TTimeDuration;
}

MOZ_IMPLICIT MaybeTimeDuration::MaybeTimeDuration(TimeDuration&& aOther)
{
    new (mozilla::KnownNotNull, ptr_TimeDuration()) TimeDuration(std::move(aOther));
    mType = TTimeDuration;
}

MOZ_IMPLICIT MaybeTimeDuration::MaybeTimeDuration(const MaybeTimeDuration& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case TTimeDuration:
        {
            new (mozilla::KnownNotNull, ptr_TimeDuration()) TimeDuration((aOther).get_TimeDuration());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT MaybeTimeDuration::MaybeTimeDuration(MaybeTimeDuration&& 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()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TTimeDuration:
        {
            new (mozilla::KnownNotNull, ptr_TimeDuration()) TimeDuration(std::move((aOther).get_TimeDuration()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto MaybeTimeDuration::operator=(const TimeDuration& aRhs) -> MaybeTimeDuration&
{
    if (MaybeDestroy(TTimeDuration)) {
        new (mozilla::KnownNotNull, ptr_TimeDuration()) TimeDuration;
    }
    (*(ptr_TimeDuration())) = aRhs;
    mType = TTimeDuration;
    return (*(this));
}

auto MaybeTimeDuration::operator=(TimeDuration&& aRhs) -> MaybeTimeDuration&
{
    if (MaybeDestroy(TTimeDuration)) {
        new (mozilla::KnownNotNull, ptr_TimeDuration()) TimeDuration;
    }
    (*(ptr_TimeDuration())) = std::move(aRhs);
    mType = TTimeDuration;
    return (*(this));
}

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

auto MaybeTimeDuration::operator=(MaybeTimeDuration&& aRhs) -> MaybeTimeDuration&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = std::move((aRhs).get_null_t());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TTimeDuration:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_TimeDuration()) TimeDuration;
            }
            (*(ptr_TimeDuration())) = std::move((aRhs).get_TimeDuration());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

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

auto MaybeTimeDuration::operator==(const TimeDuration& aRhs) const -> bool
{
    return (get_TimeDuration()) == (aRhs);
}

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

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

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

auto MaybeTimeDuration::get(TimeDuration* aOutValue) const -> void
{
    (*(aOutValue)) = get_TimeDuration();
}

} // namespace layers
} // namespace mozilla

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

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

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

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

} // namespace ipc
} // namespace mozilla

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

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 nsTArray<TransformFunction>& aOther)
{
    new (mozilla::KnownNotNull, ptr_ArrayOfTransformFunction()) nsTArray<TransformFunction>(aOther);
    mType = TArrayOfTransformFunction;
}

MOZ_IMPLICIT Animatable::Animatable(nsTArray<TransformFunction>&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ArrayOfTransformFunction()) nsTArray<TransformFunction>(std::move(aOther));
    mType = TArrayOfTransformFunction;
}

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 TArrayOfTransformFunction:
        {
            new (mozilla::KnownNotNull, ptr_ArrayOfTransformFunction()) nsTArray<TransformFunction>((aOther).get_ArrayOfTransformFunction());
            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()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case Tfloat:
        {
            new (mozilla::KnownNotNull, ptr_float()) float(std::move((aOther).get_float()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TArrayOfTransformFunction:
        {
            new (mozilla::KnownNotNull, ptr_ArrayOfTransformFunction()) nsTArray<TransformFunction>(std::move((aOther).get_ArrayOfTransformFunction()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

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

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

auto Animatable::operator=(const nsTArray<TransformFunction>& aRhs) -> Animatable&
{
    if (MaybeDestroy(TArrayOfTransformFunction)) {
        new (mozilla::KnownNotNull, ptr_ArrayOfTransformFunction()) nsTArray<TransformFunction>;
    }
    (*(ptr_ArrayOfTransformFunction())) = aRhs;
    mType = TArrayOfTransformFunction;
    return (*(this));
}

auto Animatable::operator=(nsTArray<TransformFunction>&& aRhs) -> Animatable&
{
    if (MaybeDestroy(TArrayOfTransformFunction)) {
        new (mozilla::KnownNotNull, ptr_ArrayOfTransformFunction()) nsTArray<TransformFunction>;
    }
    (*(ptr_ArrayOfTransformFunction())) = std::move(aRhs);
    mType = TArrayOfTransformFunction;
    return (*(this));
}

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

auto 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 nsTArray<TransformFunction>& aRhs) const -> bool
{
    return (get_ArrayOfTransformFunction()) == (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 TArrayOfTransformFunction:
        {
            return (get_ArrayOfTransformFunction()) == ((aRhs).get_ArrayOfTransformFunction());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

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

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

auto Animatable::get(nsTArray<TransformFunction>* aOutValue) const -> void
{
    (*(aOutValue)) = get_ArrayOfTransformFunction();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::Tnull_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aMsg)->WriteSentinel(3731137201);
            return;
        }
    case union__::Tfloat:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_float());
            // Sentinel = 'Tfloat'
            (aMsg)->WriteSentinel(2693237468);
            return;
        }
    case union__::TArrayOfTransformFunction:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ArrayOfTransformFunction());
            // Sentinel = 'TArrayOfTransformFunction'
            (aMsg)->WriteSentinel(2388656529);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::Tnull_t:
        {
            mozilla::null_t tmp = mozilla::null_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_null_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tnull_t of union Animatable");
                return false;
            }
            // Sentinel = 'Tnull_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3731137201)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union Animatable");
                return false;
            }
            return true;
        }
    case union__::Tfloat:
        {
            float tmp = float();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_float())))))) {
                (aActor)->FatalError("Error deserializing variant Tfloat of union Animatable");
                return false;
            }
            // Sentinel = 'Tfloat'
            if ((!((aMsg)->ReadSentinel(aIter, 2693237468)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tfloat of union Animatable");
                return false;
            }
            return true;
        }
    case union__::TArrayOfTransformFunction:
        {
            nsTArray<mozilla::layers::TransformFunction> tmp;
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ArrayOfTransformFunction())))))) {
                (aActor)->FatalError("Error deserializing variant TArrayOfTransformFunction of union Animatable");
                return false;
            }
            // Sentinel = 'TArrayOfTransformFunction'
            if ((!((aMsg)->ReadSentinel(aIter, 2388656529)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TArrayOfTransformFunction of union Animatable");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct AnimationSegment|
//
namespace mozilla {
namespace layers {
auto AnimationSegment::operator==(const AnimationSegment& _o) const -> bool
{
    if ((!((startState()) == ((_o).startState())))) {
        return false;
    }
    if ((!((endState()) == ((_o).endState())))) {
        return false;
    }
    if ((!((startPortion()) == ((_o).startPortion())))) {
        return false;
    }
    if ((!((endPortion()) == ((_o).endPortion())))) {
        return false;
    }
    if ((!((startComposite()) == ((_o).startComposite())))) {
        return false;
    }
    if ((!((endComposite()) == ((_o).endComposite())))) {
        return false;
    }
    if ((!((sampleFn()) == ((_o).sampleFn())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::AnimationSegment>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).startState());
    // Sentinel = 'startState'
    (aMsg)->WriteSentinel(4108886385);
    WriteIPDLParam(aMsg, aActor, (aVar).endState());
    // Sentinel = 'endState'
    (aMsg)->WriteSentinel(1429422250);
    WriteIPDLParam(aMsg, aActor, (aVar).startPortion());
    // Sentinel = 'startPortion'
    (aMsg)->WriteSentinel(3719513325);
    WriteIPDLParam(aMsg, aActor, (aVar).endPortion());
    // Sentinel = 'endPortion'
    (aMsg)->WriteSentinel(2820069090);
    WriteIPDLParam(aMsg, aActor, (aVar).startComposite());
    // Sentinel = 'startComposite'
    (aMsg)->WriteSentinel(293778843);
    WriteIPDLParam(aMsg, aActor, (aVar).endComposite());
    // Sentinel = 'endComposite'
    (aMsg)->WriteSentinel(734492384);
    WriteIPDLParam(aMsg, aActor, (aVar).sampleFn());
    // Sentinel = 'sampleFn'
    (aMsg)->WriteSentinel(939676522);
}

auto IPDLParamTraits<mozilla::layers::AnimationSegment>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->startState())))))) {
        (aActor)->FatalError("Error deserializing 'startState' (Animatable) member of 'AnimationSegment'");
        return false;
    }
    // Sentinel = 'startState'
    if ((!((aMsg)->ReadSentinel(aIter, 4108886385)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'startState' (Animatable) member of 'AnimationSegment'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->endState())))))) {
        (aActor)->FatalError("Error deserializing 'endState' (Animatable) member of 'AnimationSegment'");
        return false;
    }
    // Sentinel = 'endState'
    if ((!((aMsg)->ReadSentinel(aIter, 1429422250)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'endState' (Animatable) member of 'AnimationSegment'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->startPortion())))))) {
        (aActor)->FatalError("Error deserializing 'startPortion' (float) member of 'AnimationSegment'");
        return false;
    }
    // Sentinel = 'startPortion'
    if ((!((aMsg)->ReadSentinel(aIter, 3719513325)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'startPortion' (float) member of 'AnimationSegment'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->endPortion())))))) {
        (aActor)->FatalError("Error deserializing 'endPortion' (float) member of 'AnimationSegment'");
        return false;
    }
    // Sentinel = 'endPortion'
    if ((!((aMsg)->ReadSentinel(aIter, 2820069090)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'endPortion' (float) member of 'AnimationSegment'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->startComposite())))))) {
        (aActor)->FatalError("Error deserializing 'startComposite' (uint8_t) member of 'AnimationSegment'");
        return false;
    }
    // Sentinel = 'startComposite'
    if ((!((aMsg)->ReadSentinel(aIter, 293778843)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'startComposite' (uint8_t) member of 'AnimationSegment'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->endComposite())))))) {
        (aActor)->FatalError("Error deserializing 'endComposite' (uint8_t) member of 'AnimationSegment'");
        return false;
    }
    // Sentinel = 'endComposite'
    if ((!((aMsg)->ReadSentinel(aIter, 734492384)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'endComposite' (uint8_t) member of 'AnimationSegment'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->sampleFn())))))) {
        (aActor)->FatalError("Error deserializing 'sampleFn' (TimingFunction) member of 'AnimationSegment'");
        return false;
    }
    // Sentinel = 'sampleFn'
    if ((!((aMsg)->ReadSentinel(aIter, 939676522)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'sampleFn' (TimingFunction) member of 'AnimationSegment'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// 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 ((!((inheritedXScale()) == ((_o).inheritedXScale())))) {
        return false;
    }
    if ((!((inheritedYScale()) == ((_o).inheritedYScale())))) {
        return false;
    }
    if ((!((hasPerspectiveParent()) == ((_o).hasPerspectiveParent())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::TransformData>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).origin());
    // Sentinel = 'origin'
    (aMsg)->WriteSentinel(1429924608);
    WriteIPDLParam(aMsg, aActor, (aVar).transformOrigin());
    // Sentinel = 'transformOrigin'
    (aMsg)->WriteSentinel(466321709);
    WriteIPDLParam(aMsg, aActor, (aVar).bounds());
    // Sentinel = 'bounds'
    (aMsg)->WriteSentinel(809584493);
    WriteIPDLParam(aMsg, aActor, (aVar).appUnitsPerDevPixel());
    // Sentinel = 'appUnitsPerDevPixel'
    (aMsg)->WriteSentinel(2226875639);
    WriteIPDLParam(aMsg, aActor, (aVar).inheritedXScale());
    // Sentinel = 'inheritedXScale'
    (aMsg)->WriteSentinel(1285237395);
    WriteIPDLParam(aMsg, aActor, (aVar).inheritedYScale());
    // Sentinel = 'inheritedYScale'
    (aMsg)->WriteSentinel(3724217552);
    WriteIPDLParam(aMsg, aActor, (aVar).hasPerspectiveParent());
    // Sentinel = 'hasPerspectiveParent'
    (aMsg)->WriteSentinel(1340430378);
}

auto IPDLParamTraits<mozilla::layers::TransformData>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->origin())))))) {
        (aActor)->FatalError("Error deserializing 'origin' (nsPoint) member of 'TransformData'");
        return false;
    }
    // Sentinel = 'origin'
    if ((!((aMsg)->ReadSentinel(aIter, 1429924608)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'origin' (nsPoint) member of 'TransformData'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->transformOrigin())))))) {
        (aActor)->FatalError("Error deserializing 'transformOrigin' (Point3D) member of 'TransformData'");
        return false;
    }
    // Sentinel = 'transformOrigin'
    if ((!((aMsg)->ReadSentinel(aIter, 466321709)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'transformOrigin' (Point3D) member of 'TransformData'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->bounds())))))) {
        (aActor)->FatalError("Error deserializing 'bounds' (nsRect) member of 'TransformData'");
        return false;
    }
    // Sentinel = 'bounds'
    if ((!((aMsg)->ReadSentinel(aIter, 809584493)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bounds' (nsRect) member of 'TransformData'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->appUnitsPerDevPixel())))))) {
        (aActor)->FatalError("Error deserializing 'appUnitsPerDevPixel' (int32_t) member of 'TransformData'");
        return false;
    }
    // Sentinel = 'appUnitsPerDevPixel'
    if ((!((aMsg)->ReadSentinel(aIter, 2226875639)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'appUnitsPerDevPixel' (int32_t) member of 'TransformData'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->inheritedXScale())))))) {
        (aActor)->FatalError("Error deserializing 'inheritedXScale' (float) member of 'TransformData'");
        return false;
    }
    // Sentinel = 'inheritedXScale'
    if ((!((aMsg)->ReadSentinel(aIter, 1285237395)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'inheritedXScale' (float) member of 'TransformData'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->inheritedYScale())))))) {
        (aActor)->FatalError("Error deserializing 'inheritedYScale' (float) member of 'TransformData'");
        return false;
    }
    // Sentinel = 'inheritedYScale'
    if ((!((aMsg)->ReadSentinel(aIter, 3724217552)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'inheritedYScale' (float) member of 'TransformData'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->hasPerspectiveParent())))))) {
        (aActor)->FatalError("Error deserializing 'hasPerspectiveParent' (bool) member of 'TransformData'");
        return false;
    }
    // Sentinel = 'hasPerspectiveParent'
    if ((!((aMsg)->ReadSentinel(aIter, 1340430378)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hasPerspectiveParent' (bool) member of 'TransformData'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

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

MOZ_IMPLICIT AnimationData::AnimationData(const TransformData& aOther)
{
    new (mozilla::KnownNotNull, ptr_TransformData()) TransformData(aOther);
    mType = TTransformData;
}

MOZ_IMPLICIT AnimationData::AnimationData(TransformData&& aOther)
{
    new (mozilla::KnownNotNull, ptr_TransformData()) TransformData(std::move(aOther));
    mType = TTransformData;
}

MOZ_IMPLICIT AnimationData::AnimationData(const AnimationData& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case TTransformData:
        {
            new (mozilla::KnownNotNull, ptr_TransformData()) TransformData((aOther).get_TransformData());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT AnimationData::AnimationData(AnimationData&& 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()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TTransformData:
        {
            new (mozilla::KnownNotNull, ptr_TransformData()) TransformData(std::move((aOther).get_TransformData()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto AnimationData::operator=(const TransformData& aRhs) -> AnimationData&
{
    if (MaybeDestroy(TTransformData)) {
        new (mozilla::KnownNotNull, ptr_TransformData()) TransformData;
    }
    (*(ptr_TransformData())) = aRhs;
    mType = TTransformData;
    return (*(this));
}

auto AnimationData::operator=(TransformData&& aRhs) -> AnimationData&
{
    if (MaybeDestroy(TTransformData)) {
        new (mozilla::KnownNotNull, ptr_TransformData()) TransformData;
    }
    (*(ptr_TransformData())) = std::move(aRhs);
    mType = TTransformData;
    return (*(this));
}

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

auto AnimationData::operator=(AnimationData&& aRhs) -> AnimationData&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = std::move((aRhs).get_null_t());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TTransformData:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_TransformData()) TransformData;
            }
            (*(ptr_TransformData())) = std::move((aRhs).get_TransformData());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

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

auto AnimationData::operator==(const TransformData& aRhs) const -> bool
{
    return (get_TransformData()) == (aRhs);
}

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

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

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

auto AnimationData::get(TransformData* aOutValue) const -> void
{
    (*(aOutValue)) = get_TransformData();
}

} // namespace layers
} // namespace mozilla

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

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

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct Animation|
//
namespace mozilla {
namespace layers {
auto Animation::operator==(const Animation& _o) const -> bool
{
    if ((!((originTime()) == ((_o).originTime())))) {
        return false;
    }
    if ((!((startTime()) == ((_o).startTime())))) {
        return false;
    }
    if ((!((delay()) == ((_o).delay())))) {
        return false;
    }
    if ((!((endDelay()) == ((_o).endDelay())))) {
        return false;
    }
    if ((!((holdTime()) == ((_o).holdTime())))) {
        return false;
    }
    if ((!((duration()) == ((_o).duration())))) {
        return false;
    }
    if ((!((segments()) == ((_o).segments())))) {
        return false;
    }
    if ((!((iterations()) == ((_o).iterations())))) {
        return false;
    }
    if ((!((iterationStart()) == ((_o).iterationStart())))) {
        return false;
    }
    if ((!((direction()) == ((_o).direction())))) {
        return false;
    }
    if ((!((fillMode()) == ((_o).fillMode())))) {
        return false;
    }
    if ((!((property()) == ((_o).property())))) {
        return false;
    }
    if ((!((data()) == ((_o).data())))) {
        return false;
    }
    if ((!((playbackRate()) == ((_o).playbackRate())))) {
        return false;
    }
    if ((!((previousPlaybackRate()) == ((_o).previousPlaybackRate())))) {
        return false;
    }
    if ((!((easingFunction()) == ((_o).easingFunction())))) {
        return false;
    }
    if ((!((iterationComposite()) == ((_o).iterationComposite())))) {
        return false;
    }
    if ((!((isNotPlaying()) == ((_o).isNotPlaying())))) {
        return false;
    }
    if ((!((baseStyle()) == ((_o).baseStyle())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::Animation>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).originTime());
    // Sentinel = 'originTime'
    (aMsg)->WriteSentinel(1478411195);
    WriteIPDLParam(aMsg, aActor, (aVar).startTime());
    // Sentinel = 'startTime'
    (aMsg)->WriteSentinel(2351600086);
    WriteIPDLParam(aMsg, aActor, (aVar).delay());
    // Sentinel = 'delay'
    (aMsg)->WriteSentinel(1275664816);
    WriteIPDLParam(aMsg, aActor, (aVar).endDelay());
    // Sentinel = 'endDelay'
    (aMsg)->WriteSentinel(3866533328);
    WriteIPDLParam(aMsg, aActor, (aVar).holdTime());
    // Sentinel = 'holdTime'
    (aMsg)->WriteSentinel(1802005980);
    WriteIPDLParam(aMsg, aActor, (aVar).duration());
    // Sentinel = 'duration'
    (aMsg)->WriteSentinel(1938599576);
    WriteIPDLParam(aMsg, aActor, (aVar).segments());
    // Sentinel = 'segments'
    (aMsg)->WriteSentinel(2098446378);
    WriteIPDLParam(aMsg, aActor, (aVar).iterations());
    // Sentinel = 'iterations'
    (aMsg)->WriteSentinel(3248319766);
    WriteIPDLParam(aMsg, aActor, (aVar).iterationStart());
    // Sentinel = 'iterationStart'
    (aMsg)->WriteSentinel(335770313);
    WriteIPDLParam(aMsg, aActor, (aVar).direction());
    // Sentinel = 'direction'
    (aMsg)->WriteSentinel(1283484994);
    WriteIPDLParam(aMsg, aActor, (aVar).fillMode());
    // Sentinel = 'fillMode'
    (aMsg)->WriteSentinel(319252690);
    WriteIPDLParam(aMsg, aActor, (aVar).property());
    // Sentinel = 'property'
    (aMsg)->WriteSentinel(1482237307);
    WriteIPDLParam(aMsg, aActor, (aVar).data());
    // Sentinel = 'data'
    (aMsg)->WriteSentinel(843352540);
    WriteIPDLParam(aMsg, aActor, (aVar).playbackRate());
    // Sentinel = 'playbackRate'
    (aMsg)->WriteSentinel(1664611053);
    WriteIPDLParam(aMsg, aActor, (aVar).previousPlaybackRate());
    // Sentinel = 'previousPlaybackRate'
    (aMsg)->WriteSentinel(1096565390);
    WriteIPDLParam(aMsg, aActor, (aVar).easingFunction());
    // Sentinel = 'easingFunction'
    (aMsg)->WriteSentinel(2740589013);
    WriteIPDLParam(aMsg, aActor, (aVar).iterationComposite());
    // Sentinel = 'iterationComposite'
    (aMsg)->WriteSentinel(3806204580);
    WriteIPDLParam(aMsg, aActor, (aVar).isNotPlaying());
    // Sentinel = 'isNotPlaying'
    (aMsg)->WriteSentinel(3910541071);
    WriteIPDLParam(aMsg, aActor, (aVar).baseStyle());
    // Sentinel = 'baseStyle'
    (aMsg)->WriteSentinel(2514776219);
}

auto IPDLParamTraits<mozilla::layers::Animation>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->originTime())))))) {
        (aActor)->FatalError("Error deserializing 'originTime' (TimeStamp) member of 'Animation'");
        return false;
    }
    // Sentinel = 'originTime'
    if ((!((aMsg)->ReadSentinel(aIter, 1478411195)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'originTime' (TimeStamp) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->startTime())))))) {
        (aActor)->FatalError("Error deserializing 'startTime' (MaybeTimeDuration) member of 'Animation'");
        return false;
    }
    // Sentinel = 'startTime'
    if ((!((aMsg)->ReadSentinel(aIter, 2351600086)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'startTime' (MaybeTimeDuration) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->delay())))))) {
        (aActor)->FatalError("Error deserializing 'delay' (TimeDuration) member of 'Animation'");
        return false;
    }
    // Sentinel = 'delay'
    if ((!((aMsg)->ReadSentinel(aIter, 1275664816)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'delay' (TimeDuration) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->endDelay())))))) {
        (aActor)->FatalError("Error deserializing 'endDelay' (TimeDuration) member of 'Animation'");
        return false;
    }
    // Sentinel = 'endDelay'
    if ((!((aMsg)->ReadSentinel(aIter, 3866533328)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'endDelay' (TimeDuration) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->holdTime())))))) {
        (aActor)->FatalError("Error deserializing 'holdTime' (TimeDuration) member of 'Animation'");
        return false;
    }
    // Sentinel = 'holdTime'
    if ((!((aMsg)->ReadSentinel(aIter, 1802005980)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'holdTime' (TimeDuration) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->duration())))))) {
        (aActor)->FatalError("Error deserializing 'duration' (TimeDuration) member of 'Animation'");
        return false;
    }
    // Sentinel = 'duration'
    if ((!((aMsg)->ReadSentinel(aIter, 1938599576)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'duration' (TimeDuration) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->segments())))))) {
        (aActor)->FatalError("Error deserializing 'segments' (AnimationSegment[]) member of 'Animation'");
        return false;
    }
    // Sentinel = 'segments'
    if ((!((aMsg)->ReadSentinel(aIter, 2098446378)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'segments' (AnimationSegment[]) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->iterations())))))) {
        (aActor)->FatalError("Error deserializing 'iterations' (float) member of 'Animation'");
        return false;
    }
    // Sentinel = 'iterations'
    if ((!((aMsg)->ReadSentinel(aIter, 3248319766)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'iterations' (float) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->iterationStart())))))) {
        (aActor)->FatalError("Error deserializing 'iterationStart' (float) member of 'Animation'");
        return false;
    }
    // Sentinel = 'iterationStart'
    if ((!((aMsg)->ReadSentinel(aIter, 335770313)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'iterationStart' (float) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->direction())))))) {
        (aActor)->FatalError("Error deserializing 'direction' (uint8_t) member of 'Animation'");
        return false;
    }
    // Sentinel = 'direction'
    if ((!((aMsg)->ReadSentinel(aIter, 1283484994)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'direction' (uint8_t) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->fillMode())))))) {
        (aActor)->FatalError("Error deserializing 'fillMode' (uint8_t) member of 'Animation'");
        return false;
    }
    // Sentinel = 'fillMode'
    if ((!((aMsg)->ReadSentinel(aIter, 319252690)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fillMode' (uint8_t) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->property())))))) {
        (aActor)->FatalError("Error deserializing 'property' (nsCSSPropertyID) member of 'Animation'");
        return false;
    }
    // Sentinel = 'property'
    if ((!((aMsg)->ReadSentinel(aIter, 1482237307)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'property' (nsCSSPropertyID) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->data())))))) {
        (aActor)->FatalError("Error deserializing 'data' (AnimationData) member of 'Animation'");
        return false;
    }
    // Sentinel = 'data'
    if ((!((aMsg)->ReadSentinel(aIter, 843352540)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'data' (AnimationData) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->playbackRate())))))) {
        (aActor)->FatalError("Error deserializing 'playbackRate' (float) member of 'Animation'");
        return false;
    }
    // Sentinel = 'playbackRate'
    if ((!((aMsg)->ReadSentinel(aIter, 1664611053)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'playbackRate' (float) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->previousPlaybackRate())))))) {
        (aActor)->FatalError("Error deserializing 'previousPlaybackRate' (float) member of 'Animation'");
        return false;
    }
    // Sentinel = 'previousPlaybackRate'
    if ((!((aMsg)->ReadSentinel(aIter, 1096565390)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'previousPlaybackRate' (float) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->easingFunction())))))) {
        (aActor)->FatalError("Error deserializing 'easingFunction' (TimingFunction) member of 'Animation'");
        return false;
    }
    // Sentinel = 'easingFunction'
    if ((!((aMsg)->ReadSentinel(aIter, 2740589013)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'easingFunction' (TimingFunction) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->iterationComposite())))))) {
        (aActor)->FatalError("Error deserializing 'iterationComposite' (uint8_t) member of 'Animation'");
        return false;
    }
    // Sentinel = 'iterationComposite'
    if ((!((aMsg)->ReadSentinel(aIter, 3806204580)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'iterationComposite' (uint8_t) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->isNotPlaying())))))) {
        (aActor)->FatalError("Error deserializing 'isNotPlaying' (bool) member of 'Animation'");
        return false;
    }
    // Sentinel = 'isNotPlaying'
    if ((!((aMsg)->ReadSentinel(aIter, 3910541071)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isNotPlaying' (bool) member of 'Animation'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->baseStyle())))))) {
        (aActor)->FatalError("Error deserializing 'baseStyle' (Animatable) member of 'Animation'");
        return false;
    }
    // Sentinel = 'baseStyle'
    if ((!((aMsg)->ReadSentinel(aIter, 2514776219)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'baseStyle' (Animatable) member of 'Animation'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CommonLayerAttributes|
//
namespace mozilla {
namespace layers {
auto CommonLayerAttributes::operator==(const CommonLayerAttributes& _o) const -> bool
{
    if ((!((visibleRegion()) == ((_o).visibleRegion())))) {
        return false;
    }
    if ((!((eventRegions()) == ((_o).eventRegions())))) {
        return false;
    }
    if ((!((useClipRect()) == ((_o).useClipRect())))) {
        return false;
    }
    if ((!((clipRect()) == ((_o).clipRect())))) {
        return false;
    }
    if ((!((maskLayer()) == ((_o).maskLayer())))) {
        return false;
    }
    if ((!((ancestorMaskLayers()) == ((_o).ancestorMaskLayers())))) {
        return false;
    }
    if ((!((compositorAnimations()) == ((_o).compositorAnimations())))) {
        return false;
    }
    if ((!((invalidRegion()) == ((_o).invalidRegion())))) {
        return false;
    }
    if ((!((scrollMetadata()) == ((_o).scrollMetadata())))) {
        return false;
    }
    if ((!((displayListLog()) == ((_o).displayListLog())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::CommonLayerAttributes>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).visibleRegion());
    // Sentinel = 'visibleRegion'
    (aMsg)->WriteSentinel(2676991175);
    WriteIPDLParam(aMsg, aActor, (aVar).eventRegions());
    // Sentinel = 'eventRegions'
    (aMsg)->WriteSentinel(438949443);
    WriteIPDLParam(aMsg, aActor, (aVar).useClipRect());
    // Sentinel = 'useClipRect'
    (aMsg)->WriteSentinel(677378102);
    WriteIPDLParam(aMsg, aActor, (aVar).clipRect());
    // Sentinel = 'clipRect'
    (aMsg)->WriteSentinel(1242385220);
    WriteIPDLParam(aMsg, aActor, (aVar).maskLayer());
    // Sentinel = 'maskLayer'
    (aMsg)->WriteSentinel(1412766294);
    WriteIPDLParam(aMsg, aActor, (aVar).ancestorMaskLayers());
    // Sentinel = 'ancestorMaskLayers'
    (aMsg)->WriteSentinel(2851099655);
    WriteIPDLParam(aMsg, aActor, (aVar).compositorAnimations());
    // Sentinel = 'compositorAnimations'
    (aMsg)->WriteSentinel(1016284326);
    WriteIPDLParam(aMsg, aActor, (aVar).invalidRegion());
    // Sentinel = 'invalidRegion'
    (aMsg)->WriteSentinel(3857779772);
    WriteIPDLParam(aMsg, aActor, (aVar).scrollMetadata());
    // Sentinel = 'scrollMetadata'
    (aMsg)->WriteSentinel(257252514);
    WriteIPDLParam(aMsg, aActor, (aVar).displayListLog());
    // Sentinel = 'displayListLog'
    (aMsg)->WriteSentinel(1994382750);
}

auto IPDLParamTraits<mozilla::layers::CommonLayerAttributes>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->visibleRegion())))))) {
        (aActor)->FatalError("Error deserializing 'visibleRegion' (LayerIntRegion) member of 'CommonLayerAttributes'");
        return false;
    }
    // Sentinel = 'visibleRegion'
    if ((!((aMsg)->ReadSentinel(aIter, 2676991175)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'visibleRegion' (LayerIntRegion) member of 'CommonLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->eventRegions())))))) {
        (aActor)->FatalError("Error deserializing 'eventRegions' (EventRegions) member of 'CommonLayerAttributes'");
        return false;
    }
    // Sentinel = 'eventRegions'
    if ((!((aMsg)->ReadSentinel(aIter, 438949443)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'eventRegions' (EventRegions) member of 'CommonLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->useClipRect())))))) {
        (aActor)->FatalError("Error deserializing 'useClipRect' (bool) member of 'CommonLayerAttributes'");
        return false;
    }
    // Sentinel = 'useClipRect'
    if ((!((aMsg)->ReadSentinel(aIter, 677378102)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'useClipRect' (bool) member of 'CommonLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->clipRect())))))) {
        (aActor)->FatalError("Error deserializing 'clipRect' (ParentLayerIntRect) member of 'CommonLayerAttributes'");
        return false;
    }
    // Sentinel = 'clipRect'
    if ((!((aMsg)->ReadSentinel(aIter, 1242385220)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'clipRect' (ParentLayerIntRect) member of 'CommonLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->maskLayer())))))) {
        (aActor)->FatalError("Error deserializing 'maskLayer' (LayerHandle) member of 'CommonLayerAttributes'");
        return false;
    }
    // Sentinel = 'maskLayer'
    if ((!((aMsg)->ReadSentinel(aIter, 1412766294)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'maskLayer' (LayerHandle) member of 'CommonLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->ancestorMaskLayers())))))) {
        (aActor)->FatalError("Error deserializing 'ancestorMaskLayers' (LayerHandle[]) member of 'CommonLayerAttributes'");
        return false;
    }
    // Sentinel = 'ancestorMaskLayers'
    if ((!((aMsg)->ReadSentinel(aIter, 2851099655)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ancestorMaskLayers' (LayerHandle[]) member of 'CommonLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->compositorAnimations())))))) {
        (aActor)->FatalError("Error deserializing 'compositorAnimations' (CompositorAnimations) member of 'CommonLayerAttributes'");
        return false;
    }
    // Sentinel = 'compositorAnimations'
    if ((!((aMsg)->ReadSentinel(aIter, 1016284326)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'compositorAnimations' (CompositorAnimations) member of 'CommonLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->invalidRegion())))))) {
        (aActor)->FatalError("Error deserializing 'invalidRegion' (nsIntRegion) member of 'CommonLayerAttributes'");
        return false;
    }
    // Sentinel = 'invalidRegion'
    if ((!((aMsg)->ReadSentinel(aIter, 3857779772)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'invalidRegion' (nsIntRegion) member of 'CommonLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->scrollMetadata())))))) {
        (aActor)->FatalError("Error deserializing 'scrollMetadata' (ScrollMetadata[]) member of 'CommonLayerAttributes'");
        return false;
    }
    // Sentinel = 'scrollMetadata'
    if ((!((aMsg)->ReadSentinel(aIter, 257252514)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scrollMetadata' (ScrollMetadata[]) member of 'CommonLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->displayListLog())))))) {
        (aActor)->FatalError("Error deserializing 'displayListLog' (nsCString) member of 'CommonLayerAttributes'");
        return false;
    }
    // Sentinel = 'displayListLog'
    if ((!((aMsg)->ReadSentinel(aIter, 1994382750)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'displayListLog' (nsCString) member of 'CommonLayerAttributes'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ContainerLayerAttributes|
//
namespace mozilla {
namespace layers {
auto ContainerLayerAttributes::operator==(const ContainerLayerAttributes& _o) const -> bool
{
    if ((!((preXScale()) == ((_o).preXScale())))) {
        return false;
    }
    if ((!((preYScale()) == ((_o).preYScale())))) {
        return false;
    }
    if ((!((inheritedXScale()) == ((_o).inheritedXScale())))) {
        return false;
    }
    if ((!((inheritedYScale()) == ((_o).inheritedYScale())))) {
        return false;
    }
    if ((!((presShellResolution()) == ((_o).presShellResolution())))) {
        return false;
    }
    if ((!((scaleToResolution()) == ((_o).scaleToResolution())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::ContainerLayerAttributes>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).preXScale());
    // Sentinel = 'preXScale'
    (aMsg)->WriteSentinel(2584362704);
    WriteIPDLParam(aMsg, aActor, (aVar).preYScale());
    // Sentinel = 'preYScale'
    (aMsg)->WriteSentinel(970268767);
    WriteIPDLParam(aMsg, aActor, (aVar).inheritedXScale());
    // Sentinel = 'inheritedXScale'
    (aMsg)->WriteSentinel(1285237395);
    WriteIPDLParam(aMsg, aActor, (aVar).inheritedYScale());
    // Sentinel = 'inheritedYScale'
    (aMsg)->WriteSentinel(3724217552);
    WriteIPDLParam(aMsg, aActor, (aVar).presShellResolution());
    // Sentinel = 'presShellResolution'
    (aMsg)->WriteSentinel(526924453);
    WriteIPDLParam(aMsg, aActor, (aVar).scaleToResolution());
    // Sentinel = 'scaleToResolution'
    (aMsg)->WriteSentinel(2681979286);
}

auto IPDLParamTraits<mozilla::layers::ContainerLayerAttributes>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->preXScale())))))) {
        (aActor)->FatalError("Error deserializing 'preXScale' (float) member of 'ContainerLayerAttributes'");
        return false;
    }
    // Sentinel = 'preXScale'
    if ((!((aMsg)->ReadSentinel(aIter, 2584362704)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'preXScale' (float) member of 'ContainerLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->preYScale())))))) {
        (aActor)->FatalError("Error deserializing 'preYScale' (float) member of 'ContainerLayerAttributes'");
        return false;
    }
    // Sentinel = 'preYScale'
    if ((!((aMsg)->ReadSentinel(aIter, 970268767)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'preYScale' (float) member of 'ContainerLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->inheritedXScale())))))) {
        (aActor)->FatalError("Error deserializing 'inheritedXScale' (float) member of 'ContainerLayerAttributes'");
        return false;
    }
    // Sentinel = 'inheritedXScale'
    if ((!((aMsg)->ReadSentinel(aIter, 1285237395)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'inheritedXScale' (float) member of 'ContainerLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->inheritedYScale())))))) {
        (aActor)->FatalError("Error deserializing 'inheritedYScale' (float) member of 'ContainerLayerAttributes'");
        return false;
    }
    // Sentinel = 'inheritedYScale'
    if ((!((aMsg)->ReadSentinel(aIter, 3724217552)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'inheritedYScale' (float) member of 'ContainerLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->presShellResolution())))))) {
        (aActor)->FatalError("Error deserializing 'presShellResolution' (float) member of 'ContainerLayerAttributes'");
        return false;
    }
    // Sentinel = 'presShellResolution'
    if ((!((aMsg)->ReadSentinel(aIter, 526924453)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'presShellResolution' (float) member of 'ContainerLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->scaleToResolution())))))) {
        (aActor)->FatalError("Error deserializing 'scaleToResolution' (bool) member of 'ContainerLayerAttributes'");
        return false;
    }
    // Sentinel = 'scaleToResolution'
    if ((!((aMsg)->ReadSentinel(aIter, 2681979286)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scaleToResolution' (bool) member of 'ContainerLayerAttributes'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

auto IPDLParamTraits<mozilla::layers::GlyphArray>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->color())))))) {
        (aActor)->FatalError("Error deserializing 'color' (LayerColor) member of 'GlyphArray'");
        return false;
    }
    // Sentinel = 'color'
    if ((!((aMsg)->ReadSentinel(aIter, 2703551752)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'color' (LayerColor) member of 'GlyphArray'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->glyphs())))))) {
        (aActor)->FatalError("Error deserializing 'glyphs' (Glyph[]) member of 'GlyphArray'");
        return false;
    }
    // Sentinel = 'glyphs'
    if ((!((aMsg)->ReadSentinel(aIter, 2497623611)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'glyphs' (Glyph[]) member of 'GlyphArray'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::ImageLayerAttributes>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).samplingFilter());
    // Sentinel = 'samplingFilter'
    (aMsg)->WriteSentinel(2274374003);
    WriteIPDLParam(aMsg, aActor, (aVar).scaleToSize());
    // Sentinel = 'scaleToSize'
    (aMsg)->WriteSentinel(1078440273);
    WriteIPDLParam(aMsg, aActor, (aVar).scaleMode());
    // Sentinel = 'scaleMode'
    (aMsg)->WriteSentinel(1807422362);
}

auto IPDLParamTraits<mozilla::layers::ImageLayerAttributes>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->samplingFilter())))))) {
        (aActor)->FatalError("Error deserializing 'samplingFilter' (SamplingFilter) member of 'ImageLayerAttributes'");
        return false;
    }
    // Sentinel = 'samplingFilter'
    if ((!((aMsg)->ReadSentinel(aIter, 2274374003)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'samplingFilter' (SamplingFilter) member of 'ImageLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->scaleToSize())))))) {
        (aActor)->FatalError("Error deserializing 'scaleToSize' (IntSize) member of 'ImageLayerAttributes'");
        return false;
    }
    // Sentinel = 'scaleToSize'
    if ((!((aMsg)->ReadSentinel(aIter, 1078440273)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scaleToSize' (IntSize) member of 'ImageLayerAttributes'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->scaleMode())))))) {
        (aActor)->FatalError("Error deserializing 'scaleMode' (ScaleMode) member of 'ImageLayerAttributes'");
        return false;
    }
    // Sentinel = 'scaleMode'
    if ((!((aMsg)->ReadSentinel(aIter, 1807422362)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scaleMode' (ScaleMode) member of 'ImageLayerAttributes'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union SpecificLayerAttributes|
//
namespace mozilla {
namespace layers {
auto SpecificLayerAttributes::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case Tnull_t:
        {
            (ptr_null_t())->~null_t__tdef();
            break;
        }
    case TPaintedLayerAttributes:
        {
            (ptr_PaintedLayerAttributes())->~PaintedLayerAttributes__tdef();
            break;
        }
    case TContainerLayerAttributes:
        {
            (ptr_ContainerLayerAttributes())->~ContainerLayerAttributes__tdef();
            break;
        }
    case TColorLayerAttributes:
        {
            (ptr_ColorLayerAttributes())->~ColorLayerAttributes__tdef();
            break;
        }
    case TCanvasLayerAttributes:
        {
            (ptr_CanvasLayerAttributes())->~CanvasLayerAttributes__tdef();
            break;
        }
    case TRefLayerAttributes:
        {
            (ptr_RefLayerAttributes())->~RefLayerAttributes__tdef();
            break;
        }
    case TImageLayerAttributes:
        {
            (ptr_ImageLayerAttributes())->~ImageLayerAttributes__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

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

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

MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const PaintedLayerAttributes& aOther)
{
    new (mozilla::KnownNotNull, ptr_PaintedLayerAttributes()) PaintedLayerAttributes(aOther);
    mType = TPaintedLayerAttributes;
}

MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(PaintedLayerAttributes&& aOther)
{
    new (mozilla::KnownNotNull, ptr_PaintedLayerAttributes()) PaintedLayerAttributes(std::move(aOther));
    mType = TPaintedLayerAttributes;
}

MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const ContainerLayerAttributes& aOther)
{
    new (mozilla::KnownNotNull, ptr_ContainerLayerAttributes()) ContainerLayerAttributes(aOther);
    mType = TContainerLayerAttributes;
}

MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(ContainerLayerAttributes&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ContainerLayerAttributes()) ContainerLayerAttributes(std::move(aOther));
    mType = TContainerLayerAttributes;
}

MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const ColorLayerAttributes& aOther)
{
    new (mozilla::KnownNotNull, ptr_ColorLayerAttributes()) ColorLayerAttributes(aOther);
    mType = TColorLayerAttributes;
}

MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(ColorLayerAttributes&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ColorLayerAttributes()) ColorLayerAttributes(std::move(aOther));
    mType = TColorLayerAttributes;
}

MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const CanvasLayerAttributes& aOther)
{
    new (mozilla::KnownNotNull, ptr_CanvasLayerAttributes()) CanvasLayerAttributes(aOther);
    mType = TCanvasLayerAttributes;
}

MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(CanvasLayerAttributes&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CanvasLayerAttributes()) CanvasLayerAttributes(std::move(aOther));
    mType = TCanvasLayerAttributes;
}

MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const RefLayerAttributes& aOther)
{
    new (mozilla::KnownNotNull, ptr_RefLayerAttributes()) RefLayerAttributes(aOther);
    mType = TRefLayerAttributes;
}

MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(RefLayerAttributes&& aOther)
{
    new (mozilla::KnownNotNull, ptr_RefLayerAttributes()) RefLayerAttributes(std::move(aOther));
    mType = TRefLayerAttributes;
}

MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const ImageLayerAttributes& aOther)
{
    new (mozilla::KnownNotNull, ptr_ImageLayerAttributes()) ImageLayerAttributes(aOther);
    mType = TImageLayerAttributes;
}

MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(ImageLayerAttributes&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ImageLayerAttributes()) ImageLayerAttributes(std::move(aOther));
    mType = TImageLayerAttributes;
}

MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const SpecificLayerAttributes& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case TPaintedLayerAttributes:
        {
            new (mozilla::KnownNotNull, ptr_PaintedLayerAttributes()) PaintedLayerAttributes((aOther).get_PaintedLayerAttributes());
            break;
        }
    case TContainerLayerAttributes:
        {
            new (mozilla::KnownNotNull, ptr_ContainerLayerAttributes()) ContainerLayerAttributes((aOther).get_ContainerLayerAttributes());
            break;
        }
    case TColorLayerAttributes:
        {
            new (mozilla::KnownNotNull, ptr_ColorLayerAttributes()) ColorLayerAttributes((aOther).get_ColorLayerAttributes());
            break;
        }
    case TCanvasLayerAttributes:
        {
            new (mozilla::KnownNotNull, ptr_CanvasLayerAttributes()) CanvasLayerAttributes((aOther).get_CanvasLayerAttributes());
            break;
        }
    case TRefLayerAttributes:
        {
            new (mozilla::KnownNotNull, ptr_RefLayerAttributes()) RefLayerAttributes((aOther).get_RefLayerAttributes());
            break;
        }
    case TImageLayerAttributes:
        {
            new (mozilla::KnownNotNull, ptr_ImageLayerAttributes()) ImageLayerAttributes((aOther).get_ImageLayerAttributes());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(SpecificLayerAttributes&& 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()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPaintedLayerAttributes:
        {
            new (mozilla::KnownNotNull, ptr_PaintedLayerAttributes()) PaintedLayerAttributes(std::move((aOther).get_PaintedLayerAttributes()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TContainerLayerAttributes:
        {
            new (mozilla::KnownNotNull, ptr_ContainerLayerAttributes()) ContainerLayerAttributes(std::move((aOther).get_ContainerLayerAttributes()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TColorLayerAttributes:
        {
            new (mozilla::KnownNotNull, ptr_ColorLayerAttributes()) ColorLayerAttributes(std::move((aOther).get_ColorLayerAttributes()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TCanvasLayerAttributes:
        {
            new (mozilla::KnownNotNull, ptr_CanvasLayerAttributes()) CanvasLayerAttributes(std::move((aOther).get_CanvasLayerAttributes()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TRefLayerAttributes:
        {
            new (mozilla::KnownNotNull, ptr_RefLayerAttributes()) RefLayerAttributes(std::move((aOther).get_RefLayerAttributes()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TImageLayerAttributes:
        {
            new (mozilla::KnownNotNull, ptr_ImageLayerAttributes()) ImageLayerAttributes(std::move((aOther).get_ImageLayerAttributes()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto SpecificLayerAttributes::operator=(const PaintedLayerAttributes& aRhs) -> SpecificLayerAttributes&
{
    if (MaybeDestroy(TPaintedLayerAttributes)) {
        new (mozilla::KnownNotNull, ptr_PaintedLayerAttributes()) PaintedLayerAttributes;
    }
    (*(ptr_PaintedLayerAttributes())) = aRhs;
    mType = TPaintedLayerAttributes;
    return (*(this));
}

auto SpecificLayerAttributes::operator=(PaintedLayerAttributes&& aRhs) -> SpecificLayerAttributes&
{
    if (MaybeDestroy(TPaintedLayerAttributes)) {
        new (mozilla::KnownNotNull, ptr_PaintedLayerAttributes()) PaintedLayerAttributes;
    }
    (*(ptr_PaintedLayerAttributes())) = std::move(aRhs);
    mType = TPaintedLayerAttributes;
    return (*(this));
}

auto SpecificLayerAttributes::operator=(const ContainerLayerAttributes& aRhs) -> SpecificLayerAttributes&
{
    if (MaybeDestroy(TContainerLayerAttributes)) {
        new (mozilla::KnownNotNull, ptr_ContainerLayerAttributes()) ContainerLayerAttributes;
    }
    (*(ptr_ContainerLayerAttributes())) = aRhs;
    mType = TContainerLayerAttributes;
    return (*(this));
}

auto SpecificLayerAttributes::operator=(ContainerLayerAttributes&& aRhs) -> SpecificLayerAttributes&
{
    if (MaybeDestroy(TContainerLayerAttributes)) {
        new (mozilla::KnownNotNull, ptr_ContainerLayerAttributes()) ContainerLayerAttributes;
    }
    (*(ptr_ContainerLayerAttributes())) = std::move(aRhs);
    mType = TContainerLayerAttributes;
    return (*(this));
}

auto SpecificLayerAttributes::operator=(const ColorLayerAttributes& aRhs) -> SpecificLayerAttributes&
{
    if (MaybeDestroy(TColorLayerAttributes)) {
        new (mozilla::KnownNotNull, ptr_ColorLayerAttributes()) ColorLayerAttributes;
    }
    (*(ptr_ColorLayerAttributes())) = aRhs;
    mType = TColorLayerAttributes;
    return (*(this));
}

auto SpecificLayerAttributes::operator=(ColorLayerAttributes&& aRhs) -> SpecificLayerAttributes&
{
    if (MaybeDestroy(TColorLayerAttributes)) {
        new (mozilla::KnownNotNull, ptr_ColorLayerAttributes()) ColorLayerAttributes;
    }
    (*(ptr_ColorLayerAttributes())) = std::move(aRhs);
    mType = TColorLayerAttributes;
    return (*(this));
}

auto SpecificLayerAttributes::operator=(const CanvasLayerAttributes& aRhs) -> SpecificLayerAttributes&
{
    if (MaybeDestroy(TCanvasLayerAttributes)) {
        new (mozilla::KnownNotNull, ptr_CanvasLayerAttributes()) CanvasLayerAttributes;
    }
    (*(ptr_CanvasLayerAttributes())) = aRhs;
    mType = TCanvasLayerAttributes;
    return (*(this));
}

auto SpecificLayerAttributes::operator=(CanvasLayerAttributes&& aRhs) -> SpecificLayerAttributes&
{
    if (MaybeDestroy(TCanvasLayerAttributes)) {
        new (mozilla::KnownNotNull, ptr_CanvasLayerAttributes()) CanvasLayerAttributes;
    }
    (*(ptr_CanvasLayerAttributes())) = std::move(aRhs);
    mType = TCanvasLayerAttributes;
    return (*(this));
}

auto SpecificLayerAttributes::operator=(const RefLayerAttributes& aRhs) -> SpecificLayerAttributes&
{
    if (MaybeDestroy(TRefLayerAttributes)) {
        new (mozilla::KnownNotNull, ptr_RefLayerAttributes()) RefLayerAttributes;
    }
    (*(ptr_RefLayerAttributes())) = aRhs;
    mType = TRefLayerAttributes;
    return (*(this));
}

auto SpecificLayerAttributes::operator=(RefLayerAttributes&& aRhs) -> SpecificLayerAttributes&
{
    if (MaybeDestroy(TRefLayerAttributes)) {
        new (mozilla::KnownNotNull, ptr_RefLayerAttributes()) RefLayerAttributes;
    }
    (*(ptr_RefLayerAttributes())) = std::move(aRhs);
    mType = TRefLayerAttributes;
    return (*(this));
}

auto SpecificLayerAttributes::operator=(const ImageLayerAttributes& aRhs) -> SpecificLayerAttributes&
{
    if (MaybeDestroy(TImageLayerAttributes)) {
        new (mozilla::KnownNotNull, ptr_ImageLayerAttributes()) ImageLayerAttributes;
    }
    (*(ptr_ImageLayerAttributes())) = aRhs;
    mType = TImageLayerAttributes;
    return (*(this));
}

auto SpecificLayerAttributes::operator=(ImageLayerAttributes&& aRhs) -> SpecificLayerAttributes&
{
    if (MaybeDestroy(TImageLayerAttributes)) {
        new (mozilla::KnownNotNull, ptr_ImageLayerAttributes()) ImageLayerAttributes;
    }
    (*(ptr_ImageLayerAttributes())) = std::move(aRhs);
    mType = TImageLayerAttributes;
    return (*(this));
}

auto SpecificLayerAttributes::operator=(const SpecificLayerAttributes& aRhs) -> SpecificLayerAttributes&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = (aRhs).get_null_t();
            break;
        }
    case TPaintedLayerAttributes:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PaintedLayerAttributes()) PaintedLayerAttributes;
            }
            (*(ptr_PaintedLayerAttributes())) = (aRhs).get_PaintedLayerAttributes();
            break;
        }
    case TContainerLayerAttributes:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ContainerLayerAttributes()) ContainerLayerAttributes;
            }
            (*(ptr_ContainerLayerAttributes())) = (aRhs).get_ContainerLayerAttributes();
            break;
        }
    case TColorLayerAttributes:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ColorLayerAttributes()) ColorLayerAttributes;
            }
            (*(ptr_ColorLayerAttributes())) = (aRhs).get_ColorLayerAttributes();
            break;
        }
    case TCanvasLayerAttributes:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_CanvasLayerAttributes()) CanvasLayerAttributes;
            }
            (*(ptr_CanvasLayerAttributes())) = (aRhs).get_CanvasLayerAttributes();
            break;
        }
    case TRefLayerAttributes:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_RefLayerAttributes()) RefLayerAttributes;
            }
            (*(ptr_RefLayerAttributes())) = (aRhs).get_RefLayerAttributes();
            break;
        }
    case TImageLayerAttributes:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ImageLayerAttributes()) ImageLayerAttributes;
            }
            (*(ptr_ImageLayerAttributes())) = (aRhs).get_ImageLayerAttributes();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto SpecificLayerAttributes::operator=(SpecificLayerAttributes&& aRhs) -> SpecificLayerAttributes&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = std::move((aRhs).get_null_t());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPaintedLayerAttributes:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PaintedLayerAttributes()) PaintedLayerAttributes;
            }
            (*(ptr_PaintedLayerAttributes())) = std::move((aRhs).get_PaintedLayerAttributes());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TContainerLayerAttributes:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ContainerLayerAttributes()) ContainerLayerAttributes;
            }
            (*(ptr_ContainerLayerAttributes())) = std::move((aRhs).get_ContainerLayerAttributes());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TColorLayerAttributes:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ColorLayerAttributes()) ColorLayerAttributes;
            }
            (*(ptr_ColorLayerAttributes())) = std::move((aRhs).get_ColorLayerAttributes());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TCanvasLayerAttributes:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_CanvasLayerAttributes()) CanvasLayerAttributes;
            }
            (*(ptr_CanvasLayerAttributes())) = std::move((aRhs).get_CanvasLayerAttributes());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TRefLayerAttributes:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_RefLayerAttributes()) RefLayerAttributes;
            }
            (*(ptr_RefLayerAttributes())) = std::move((aRhs).get_RefLayerAttributes());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TImageLayerAttributes:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ImageLayerAttributes()) ImageLayerAttributes;
            }
            (*(ptr_ImageLayerAttributes())) = std::move((aRhs).get_ImageLayerAttributes());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

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

auto SpecificLayerAttributes::operator==(const PaintedLayerAttributes& aRhs) const -> bool
{
    return (get_PaintedLayerAttributes()) == (aRhs);
}

auto SpecificLayerAttributes::operator==(const ContainerLayerAttributes& aRhs) const -> bool
{
    return (get_ContainerLayerAttributes()) == (aRhs);
}

auto SpecificLayerAttributes::operator==(const ColorLayerAttributes& aRhs) const -> bool
{
    return (get_ColorLayerAttributes()) == (aRhs);
}

auto SpecificLayerAttributes::operator==(const CanvasLayerAttributes& aRhs) const -> bool
{
    return (get_CanvasLayerAttributes()) == (aRhs);
}

auto SpecificLayerAttributes::operator==(const RefLayerAttributes& aRhs) const -> bool
{
    return (get_RefLayerAttributes()) == (aRhs);
}

auto SpecificLayerAttributes::operator==(const ImageLayerAttributes& aRhs) const -> bool
{
    return (get_ImageLayerAttributes()) == (aRhs);
}

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

    switch (type()) {
    case Tnull_t:
        {
            return (get_null_t()) == ((aRhs).get_null_t());
        }
    case TPaintedLayerAttributes:
        {
            return (get_PaintedLayerAttributes()) == ((aRhs).get_PaintedLayerAttributes());
        }
    case TContainerLayerAttributes:
        {
            return (get_ContainerLayerAttributes()) == ((aRhs).get_ContainerLayerAttributes());
        }
    case TColorLayerAttributes:
        {
            return (get_ColorLayerAttributes()) == ((aRhs).get_ColorLayerAttributes());
        }
    case TCanvasLayerAttributes:
        {
            return (get_CanvasLayerAttributes()) == ((aRhs).get_CanvasLayerAttributes());
        }
    case TRefLayerAttributes:
        {
            return (get_RefLayerAttributes()) == ((aRhs).get_RefLayerAttributes());
        }
    case TImageLayerAttributes:
        {
            return (get_ImageLayerAttributes()) == ((aRhs).get_ImageLayerAttributes());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

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

auto SpecificLayerAttributes::get(PaintedLayerAttributes* aOutValue) const -> void
{
    (*(aOutValue)) = get_PaintedLayerAttributes();
}

auto SpecificLayerAttributes::get(ContainerLayerAttributes* aOutValue) const -> void
{
    (*(aOutValue)) = get_ContainerLayerAttributes();
}

auto SpecificLayerAttributes::get(ColorLayerAttributes* aOutValue) const -> void
{
    (*(aOutValue)) = get_ColorLayerAttributes();
}

auto SpecificLayerAttributes::get(CanvasLayerAttributes* aOutValue) const -> void
{
    (*(aOutValue)) = get_CanvasLayerAttributes();
}

auto SpecificLayerAttributes::get(RefLayerAttributes* aOutValue) const -> void
{
    (*(aOutValue)) = get_RefLayerAttributes();
}

auto SpecificLayerAttributes::get(ImageLayerAttributes* aOutValue) const -> void
{
    (*(aOutValue)) = get_ImageLayerAttributes();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::Tnull_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aMsg)->WriteSentinel(3731137201);
            return;
        }
    case union__::TPaintedLayerAttributes:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_PaintedLayerAttributes());
            // Sentinel = 'TPaintedLayerAttributes'
            (aMsg)->WriteSentinel(299542338);
            return;
        }
    case union__::TContainerLayerAttributes:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ContainerLayerAttributes());
            // Sentinel = 'TContainerLayerAttributes'
            (aMsg)->WriteSentinel(2707677910);
            return;
        }
    case union__::TColorLayerAttributes:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ColorLayerAttributes());
            // Sentinel = 'TColorLayerAttributes'
            (aMsg)->WriteSentinel(1741074522);
            return;
        }
    case union__::TCanvasLayerAttributes:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_CanvasLayerAttributes());
            // Sentinel = 'TCanvasLayerAttributes'
            (aMsg)->WriteSentinel(1471416018);
            return;
        }
    case union__::TRefLayerAttributes:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_RefLayerAttributes());
            // Sentinel = 'TRefLayerAttributes'
            (aMsg)->WriteSentinel(3960711078);
            return;
        }
    case union__::TImageLayerAttributes:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ImageLayerAttributes());
            // Sentinel = 'TImageLayerAttributes'
            (aMsg)->WriteSentinel(1391450712);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::Tnull_t:
        {
            mozilla::null_t tmp = mozilla::null_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_null_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tnull_t of union SpecificLayerAttributes");
                return false;
            }
            // Sentinel = 'Tnull_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3731137201)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union SpecificLayerAttributes");
                return false;
            }
            return true;
        }
    case union__::TPaintedLayerAttributes:
        {
            mozilla::layers::PaintedLayerAttributes tmp = mozilla::layers::PaintedLayerAttributes();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PaintedLayerAttributes())))))) {
                (aActor)->FatalError("Error deserializing variant TPaintedLayerAttributes of union SpecificLayerAttributes");
                return false;
            }
            // Sentinel = 'TPaintedLayerAttributes'
            if ((!((aMsg)->ReadSentinel(aIter, 299542338)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPaintedLayerAttributes of union SpecificLayerAttributes");
                return false;
            }
            return true;
        }
    case union__::TContainerLayerAttributes:
        {
            mozilla::layers::ContainerLayerAttributes tmp = mozilla::layers::ContainerLayerAttributes();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ContainerLayerAttributes())))))) {
                (aActor)->FatalError("Error deserializing variant TContainerLayerAttributes of union SpecificLayerAttributes");
                return false;
            }
            // Sentinel = 'TContainerLayerAttributes'
            if ((!((aMsg)->ReadSentinel(aIter, 2707677910)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TContainerLayerAttributes of union SpecificLayerAttributes");
                return false;
            }
            return true;
        }
    case union__::TColorLayerAttributes:
        {
            mozilla::layers::ColorLayerAttributes tmp = mozilla::layers::ColorLayerAttributes();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ColorLayerAttributes())))))) {
                (aActor)->FatalError("Error deserializing variant TColorLayerAttributes of union SpecificLayerAttributes");
                return false;
            }
            // Sentinel = 'TColorLayerAttributes'
            if ((!((aMsg)->ReadSentinel(aIter, 1741074522)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TColorLayerAttributes of union SpecificLayerAttributes");
                return false;
            }
            return true;
        }
    case union__::TCanvasLayerAttributes:
        {
            mozilla::layers::CanvasLayerAttributes tmp = mozilla::layers::CanvasLayerAttributes();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_CanvasLayerAttributes())))))) {
                (aActor)->FatalError("Error deserializing variant TCanvasLayerAttributes of union SpecificLayerAttributes");
                return false;
            }
            // Sentinel = 'TCanvasLayerAttributes'
            if ((!((aMsg)->ReadSentinel(aIter, 1471416018)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCanvasLayerAttributes of union SpecificLayerAttributes");
                return false;
            }
            return true;
        }
    case union__::TRefLayerAttributes:
        {
            mozilla::layers::RefLayerAttributes tmp = mozilla::layers::RefLayerAttributes();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_RefLayerAttributes())))))) {
                (aActor)->FatalError("Error deserializing variant TRefLayerAttributes of union SpecificLayerAttributes");
                return false;
            }
            // Sentinel = 'TRefLayerAttributes'
            if ((!((aMsg)->ReadSentinel(aIter, 3960711078)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TRefLayerAttributes of union SpecificLayerAttributes");
                return false;
            }
            return true;
        }
    case union__::TImageLayerAttributes:
        {
            mozilla::layers::ImageLayerAttributes tmp = mozilla::layers::ImageLayerAttributes();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ImageLayerAttributes())))))) {
                (aActor)->FatalError("Error deserializing variant TImageLayerAttributes of union SpecificLayerAttributes");
                return false;
            }
            // Sentinel = 'TImageLayerAttributes'
            if ((!((aMsg)->ReadSentinel(aIter, 1391450712)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TImageLayerAttributes of union SpecificLayerAttributes");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::PluginWindowData>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).windowId());
    // Sentinel = 'windowId'
    (aMsg)->WriteSentinel(719502035);
    WriteIPDLParam(aMsg, aActor, (aVar).clip());
    // Sentinel = 'clip'
    (aMsg)->WriteSentinel(3899292550);
    WriteIPDLParam(aMsg, aActor, (aVar).bounds());
    // Sentinel = 'bounds'
    (aMsg)->WriteSentinel(809584493);
    WriteIPDLParam(aMsg, aActor, (aVar).visible());
    // Sentinel = 'visible'
    (aMsg)->WriteSentinel(1037099281);
}

auto IPDLParamTraits<mozilla::layers::PluginWindowData>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->windowId())))))) {
        (aActor)->FatalError("Error deserializing 'windowId' (uintptr_t) member of 'PluginWindowData'");
        return false;
    }
    // Sentinel = 'windowId'
    if ((!((aMsg)->ReadSentinel(aIter, 719502035)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'windowId' (uintptr_t) member of 'PluginWindowData'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->clip())))))) {
        (aActor)->FatalError("Error deserializing 'clip' (LayoutDeviceIntRect[]) member of 'PluginWindowData'");
        return false;
    }
    // Sentinel = 'clip'
    if ((!((aMsg)->ReadSentinel(aIter, 3899292550)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'clip' (LayoutDeviceIntRect[]) member of 'PluginWindowData'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->bounds())))))) {
        (aActor)->FatalError("Error deserializing 'bounds' (LayoutDeviceIntRect) member of 'PluginWindowData'");
        return false;
    }
    // Sentinel = 'bounds'
    if ((!((aMsg)->ReadSentinel(aIter, 809584493)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bounds' (LayoutDeviceIntRect) member of 'PluginWindowData'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->visible())))))) {
        (aActor)->FatalError("Error deserializing 'visible' (bool) member of 'PluginWindowData'");
        return false;
    }
    // Sentinel = 'visible'
    if ((!((aMsg)->ReadSentinel(aIter, 1037099281)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'visible' (bool) member of 'PluginWindowData'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpInsertAfter>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).container());
    // Sentinel = 'container'
    (aMsg)->WriteSentinel(613059236);
    WriteIPDLParam(aMsg, aActor, (aVar).childLayer());
    // Sentinel = 'childLayer'
    (aMsg)->WriteSentinel(154398963);
    WriteIPDLParam(aMsg, aActor, (aVar).after());
    // Sentinel = 'after'
    (aMsg)->WriteSentinel(3066110411);
}

auto IPDLParamTraits<mozilla::layers::OpInsertAfter>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->container())))))) {
        (aActor)->FatalError("Error deserializing 'container' (LayerHandle) member of 'OpInsertAfter'");
        return false;
    }
    // Sentinel = 'container'
    if ((!((aMsg)->ReadSentinel(aIter, 613059236)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'container' (LayerHandle) member of 'OpInsertAfter'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->childLayer())))))) {
        (aActor)->FatalError("Error deserializing 'childLayer' (LayerHandle) member of 'OpInsertAfter'");
        return false;
    }
    // Sentinel = 'childLayer'
    if ((!((aMsg)->ReadSentinel(aIter, 154398963)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'childLayer' (LayerHandle) member of 'OpInsertAfter'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->after())))))) {
        (aActor)->FatalError("Error deserializing 'after' (LayerHandle) member of 'OpInsertAfter'");
        return false;
    }
    // Sentinel = 'after'
    if ((!((aMsg)->ReadSentinel(aIter, 3066110411)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'after' (LayerHandle) member of 'OpInsertAfter'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpRepositionChild>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).container());
    // Sentinel = 'container'
    (aMsg)->WriteSentinel(613059236);
    WriteIPDLParam(aMsg, aActor, (aVar).childLayer());
    // Sentinel = 'childLayer'
    (aMsg)->WriteSentinel(154398963);
    WriteIPDLParam(aMsg, aActor, (aVar).after());
    // Sentinel = 'after'
    (aMsg)->WriteSentinel(3066110411);
}

auto IPDLParamTraits<mozilla::layers::OpRepositionChild>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->container())))))) {
        (aActor)->FatalError("Error deserializing 'container' (LayerHandle) member of 'OpRepositionChild'");
        return false;
    }
    // Sentinel = 'container'
    if ((!((aMsg)->ReadSentinel(aIter, 613059236)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'container' (LayerHandle) member of 'OpRepositionChild'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->childLayer())))))) {
        (aActor)->FatalError("Error deserializing 'childLayer' (LayerHandle) member of 'OpRepositionChild'");
        return false;
    }
    // Sentinel = 'childLayer'
    if ((!((aMsg)->ReadSentinel(aIter, 154398963)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'childLayer' (LayerHandle) member of 'OpRepositionChild'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->after())))))) {
        (aActor)->FatalError("Error deserializing 'after' (LayerHandle) member of 'OpRepositionChild'");
        return false;
    }
    // Sentinel = 'after'
    if ((!((aMsg)->ReadSentinel(aIter, 3066110411)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'after' (LayerHandle) member of 'OpRepositionChild'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ReadLockDescriptor|
//
namespace mozilla {
namespace layers {
auto ReadLockDescriptor::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TShmemSection:
        {
            (ptr_ShmemSection())->~ShmemSection__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;
        }
    }
    return true;
}

MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(const ShmemSection& aOther)
{
    new (mozilla::KnownNotNull, ptr_ShmemSection()) ShmemSection(aOther);
    mType = TShmemSection;
}

MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(ShmemSection&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ShmemSection()) ShmemSection(std::move(aOther));
    mType = TShmemSection;
}

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

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(const ReadLockDescriptor& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TShmemSection:
        {
            new (mozilla::KnownNotNull, ptr_ShmemSection()) ShmemSection((aOther).get_ShmemSection());
            break;
        }
    case TCrossProcessSemaphoreDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor((aOther).get_CrossProcessSemaphoreDescriptor());
            break;
        }
    case Tuintptr_t:
        {
            new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t((aOther).get_uintptr_t());
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(ReadLockDescriptor&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TShmemSection:
        {
            new (mozilla::KnownNotNull, ptr_ShmemSection()) ShmemSection(std::move((aOther).get_ShmemSection()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TCrossProcessSemaphoreDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor(std::move((aOther).get_CrossProcessSemaphoreDescriptor()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case Tuintptr_t:
        {
            new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t(std::move((aOther).get_uintptr_t()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_t()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto ReadLockDescriptor::operator=(const ShmemSection& aRhs) -> ReadLockDescriptor&
{
    if (MaybeDestroy(TShmemSection)) {
        new (mozilla::KnownNotNull, ptr_ShmemSection()) ShmemSection;
    }
    (*(ptr_ShmemSection())) = aRhs;
    mType = TShmemSection;
    return (*(this));
}

auto ReadLockDescriptor::operator=(ShmemSection&& aRhs) -> ReadLockDescriptor&
{
    if (MaybeDestroy(TShmemSection)) {
        new (mozilla::KnownNotNull, ptr_ShmemSection()) ShmemSection;
    }
    (*(ptr_ShmemSection())) = std::move(aRhs);
    mType = TShmemSection;
    return (*(this));
}

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

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

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

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

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

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

auto ReadLockDescriptor::operator=(const ReadLockDescriptor& aRhs) -> ReadLockDescriptor&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TShmemSection:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ShmemSection()) ShmemSection;
            }
            (*(ptr_ShmemSection())) = (aRhs).get_ShmemSection();
            break;
        }
    case TCrossProcessSemaphoreDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor;
            }
            (*(ptr_CrossProcessSemaphoreDescriptor())) = (aRhs).get_CrossProcessSemaphoreDescriptor();
            break;
        }
    case Tuintptr_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t;
            }
            (*(ptr_uintptr_t())) = (aRhs).get_uintptr_t();
            break;
        }
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = (aRhs).get_null_t();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

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

auto ReadLockDescriptor::operator==(const ShmemSection& aRhs) const -> bool
{
    return (get_ShmemSection()) == (aRhs);
}

auto ReadLockDescriptor::operator==(const CrossProcessSemaphoreDescriptor& aRhs) const -> bool
{
    return (get_CrossProcessSemaphoreDescriptor()) == (aRhs);
}

auto ReadLockDescriptor::operator==(const uintptr_t& aRhs) const -> bool
{
    return (get_uintptr_t()) == (aRhs);
}

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

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

    switch (type()) {
    case TShmemSection:
        {
            return (get_ShmemSection()) == ((aRhs).get_ShmemSection());
        }
    case TCrossProcessSemaphoreDescriptor:
        {
            return (get_CrossProcessSemaphoreDescriptor()) == ((aRhs).get_CrossProcessSemaphoreDescriptor());
        }
    case Tuintptr_t:
        {
            return (get_uintptr_t()) == ((aRhs).get_uintptr_t());
        }
    case Tnull_t:
        {
            return (get_null_t()) == ((aRhs).get_null_t());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto ReadLockDescriptor::get(ShmemSection* aOutValue) const -> void
{
    (*(aOutValue)) = get_ShmemSection();
}

auto ReadLockDescriptor::get(CrossProcessSemaphoreDescriptor* aOutValue) const -> void
{
    (*(aOutValue)) = get_CrossProcessSemaphoreDescriptor();
}

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

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

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TShmemSection:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ShmemSection());
            // Sentinel = 'TShmemSection'
            (aMsg)->WriteSentinel(3037204004);
            return;
        }
    case union__::TCrossProcessSemaphoreDescriptor:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_CrossProcessSemaphoreDescriptor());
            // Sentinel = 'TCrossProcessSemaphoreDescriptor'
            (aMsg)->WriteSentinel(2516853580);
            return;
        }
    case union__::Tuintptr_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_uintptr_t());
            // Sentinel = 'Tuintptr_t'
            (aMsg)->WriteSentinel(3218141805);
            return;
        }
    case union__::Tnull_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aMsg)->WriteSentinel(3731137201);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TShmemSection:
        {
            mozilla::layers::ShmemSection tmp = mozilla::layers::ShmemSection();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ShmemSection())))))) {
                (aActor)->FatalError("Error deserializing variant TShmemSection of union ReadLockDescriptor");
                return false;
            }
            // Sentinel = 'TShmemSection'
            if ((!((aMsg)->ReadSentinel(aIter, 3037204004)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TShmemSection of union ReadLockDescriptor");
                return false;
            }
            return true;
        }
    case union__::TCrossProcessSemaphoreDescriptor:
        {
            mozilla::layers::CrossProcessSemaphoreDescriptor tmp = mozilla::layers::CrossProcessSemaphoreDescriptor();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_CrossProcessSemaphoreDescriptor())))))) {
                (aActor)->FatalError("Error deserializing variant TCrossProcessSemaphoreDescriptor of union ReadLockDescriptor");
                return false;
            }
            // Sentinel = 'TCrossProcessSemaphoreDescriptor'
            if ((!((aMsg)->ReadSentinel(aIter, 2516853580)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCrossProcessSemaphoreDescriptor of union ReadLockDescriptor");
                return false;
            }
            return true;
        }
    case union__::Tuintptr_t:
        {
            uintptr_t tmp = uintptr_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_uintptr_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tuintptr_t of union ReadLockDescriptor");
                return false;
            }
            // Sentinel = 'Tuintptr_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3218141805)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tuintptr_t of union ReadLockDescriptor");
                return false;
            }
            return true;
        }
    case union__::Tnull_t:
        {
            mozilla::null_t tmp = mozilla::null_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_null_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tnull_t of union ReadLockDescriptor");
                return false;
            }
            // Sentinel = 'Tnull_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3731137201)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union ReadLockDescriptor");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

MOZ_IMPLICIT MaybeTexture::MaybeTexture(PTextureParent* aOther)
{
    new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*(const_cast<PTextureParent*>(aOther));
    mType = TPTextureParent;
}

MOZ_IMPLICIT MaybeTexture::MaybeTexture(PTextureChild* aOther)
{
    new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*(const_cast<PTextureChild*>(aOther));
    mType = TPTextureChild;
}

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

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

MOZ_IMPLICIT MaybeTexture::MaybeTexture(const MaybeTexture& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TPTextureParent:
        {
            new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*(const_cast<PTextureParent*>((aOther).get_PTextureParent()));
            break;
        }
    case TPTextureChild:
        {
            new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*(const_cast<PTextureChild*>((aOther).get_PTextureChild()));
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT MaybeTexture::MaybeTexture(MaybeTexture&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TPTextureParent:
        {
            new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*(const_cast<PTextureParent*>(std::move((aOther).get_PTextureParent())));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPTextureChild:
        {
            new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*(const_cast<PTextureChild*>(std::move((aOther).get_PTextureChild())));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_t()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto MaybeTexture::operator=(PTextureParent* aRhs) -> MaybeTexture&
{
    if (MaybeDestroy(TPTextureParent)) {
        new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*;
    }
    (*(ptr_PTextureParent())) = const_cast<PTextureParent*>(aRhs);
    mType = TPTextureParent;
    return (*(this));
}

auto MaybeTexture::operator=(PTextureChild* aRhs) -> MaybeTexture&
{
    if (MaybeDestroy(TPTextureChild)) {
        new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*;
    }
    (*(ptr_PTextureChild())) = const_cast<PTextureChild*>(aRhs);
    mType = TPTextureChild;
    return (*(this));
}

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

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

auto MaybeTexture::operator=(const MaybeTexture& aRhs) -> MaybeTexture&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TPTextureParent:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*;
            }
            (*(ptr_PTextureParent())) = const_cast<PTextureParent*>((aRhs).get_PTextureParent());
            break;
        }
    case TPTextureChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*;
            }
            (*(ptr_PTextureChild())) = const_cast<PTextureChild*>((aRhs).get_PTextureChild());
            break;
        }
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = (aRhs).get_null_t();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto MaybeTexture::operator=(MaybeTexture&& aRhs) -> MaybeTexture&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TPTextureParent:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*;
            }
            (*(ptr_PTextureParent())) = const_cast<PTextureParent*>(std::move((aRhs).get_PTextureParent()));
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPTextureChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*;
            }
            (*(ptr_PTextureChild())) = const_cast<PTextureChild*>(std::move((aRhs).get_PTextureChild()));
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = std::move((aRhs).get_null_t());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto MaybeTexture::operator==(PTextureParent* aRhs) const -> bool
{
    return (get_PTextureParent()) == (aRhs);
}

auto MaybeTexture::operator==(PTextureChild* aRhs) const -> bool
{
    return (get_PTextureChild()) == (aRhs);
}

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

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

    switch (type()) {
    case TPTextureParent:
        {
            return (get_PTextureParent()) == ((aRhs).get_PTextureParent());
        }
    case TPTextureChild:
        {
            return (get_PTextureChild()) == ((aRhs).get_PTextureChild());
        }
    case Tnull_t:
        {
            return (get_null_t()) == ((aRhs).get_null_t());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto MaybeTexture::get(PTextureParent** aOutValue) const -> void
{
    (*(aOutValue)) = get_PTextureParent();
}

auto MaybeTexture::get(PTextureChild** aOutValue) const -> void
{
    (*(aOutValue)) = get_PTextureChild();
}

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

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TPTextureParent:
        {
            if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
                MOZ_RELEASE_ASSERT((aVar).get_PTextureParent(), "NULL actor value passed to non-nullable param");
                WriteIPDLParam(aMsg, aActor, (aVar).get_PTextureParent());
                // Sentinel = 'TPTextureParent'
                (aMsg)->WriteSentinel(896696938);
            }
            else {
                (aActor)->FatalError("wrong side!");
            }
            return;
        }
    case union__::TPTextureChild:
        {
            if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
                MOZ_RELEASE_ASSERT((aVar).get_PTextureChild(), "NULL actor value passed to non-nullable param");
                WriteIPDLParam(aMsg, aActor, (aVar).get_PTextureChild());
                // Sentinel = 'TPTextureChild'
                (aMsg)->WriteSentinel(3251900187);
            }
            else {
                (aActor)->FatalError("wrong side!");
            }
            return;
        }
    case union__::Tnull_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aMsg)->WriteSentinel(3731137201);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TPTextureParent:
        {
            if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
                {
                    (aActor)->FatalError("wrong side!");
                    return false;
                }
            }
            mozilla::layers::PTextureChild* tmp = nullptr;
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PTextureChild())))))) {
                (aActor)->FatalError("Error deserializing variant TPTextureParent of union MaybeTexture");
                return false;
            }
            if ((!((*((&((aVar)->get_PTextureChild()))))))) {
                (aActor)->FatalError("Error deserializing variant TPTextureParent of union MaybeTexture");
                return false;
            }
            // Sentinel = 'TPTextureParent'
            if ((!((aMsg)->ReadSentinel(aIter, 896696938)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPTextureParent of union MaybeTexture");
                return false;
            }
            return true;
        }
    case union__::TPTextureChild:
        {
            if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
                {
                    (aActor)->FatalError("wrong side!");
                    return false;
                }
            }
            mozilla::layers::PTextureParent* tmp = nullptr;
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PTextureParent())))))) {
                (aActor)->FatalError("Error deserializing variant TPTextureChild of union MaybeTexture");
                return false;
            }
            if ((!((*((&((aVar)->get_PTextureParent()))))))) {
                (aActor)->FatalError("Error deserializing variant TPTextureChild of union MaybeTexture");
                return false;
            }
            // Sentinel = 'TPTextureChild'
            if ((!((aMsg)->ReadSentinel(aIter, 3251900187)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPTextureChild of union MaybeTexture");
                return false;
            }
            return true;
        }
    case union__::Tnull_t:
        {
            mozilla::null_t tmp = mozilla::null_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_null_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tnull_t of union MaybeTexture");
                return false;
            }
            // Sentinel = 'Tnull_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3731137201)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union MaybeTexture");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct TexturedTileDescriptor|
//
namespace mozilla {
namespace layers {
auto TexturedTileDescriptor::operator==(const TexturedTileDescriptor& _o) const -> bool
{
    if ((!((textureParent()) == ((_o).textureParent())))) {
        return false;
    }
    if ((!((textureChild()) == ((_o).textureChild())))) {
        return false;
    }
    if ((!((textureOnWhite()) == ((_o).textureOnWhite())))) {
        return false;
    }
    if ((!((updateRect()) == ((_o).updateRect())))) {
        return false;
    }
    if ((!((readLocked()) == ((_o).readLocked())))) {
        return false;
    }
    if ((!((readLockedOnWhite()) == ((_o).readLockedOnWhite())))) {
        return false;
    }
    if ((!((wasPlaceholder()) == ((_o).wasPlaceholder())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::TexturedTileDescriptor>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
        MOZ_RELEASE_ASSERT((aVar).textureParent(), "NULL actor value passed to non-nullable param");
        WriteIPDLParam(aMsg, aActor, (aVar).textureParent());
        // Sentinel = 'texture'
        (aMsg)->WriteSentinel(3654462510);
    }
    if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
        MOZ_RELEASE_ASSERT((aVar).textureChild(), "NULL actor value passed to non-nullable param");
        WriteIPDLParam(aMsg, aActor, (aVar).textureChild());
        // Sentinel = 'texture'
        (aMsg)->WriteSentinel(3654462510);
    }
    WriteIPDLParam(aMsg, aActor, (aVar).textureOnWhite());
    // Sentinel = 'textureOnWhite'
    (aMsg)->WriteSentinel(4123373327);
    WriteIPDLParam(aMsg, aActor, (aVar).updateRect());
    // Sentinel = 'updateRect'
    (aMsg)->WriteSentinel(655450235);
    WriteIPDLParam(aMsg, aActor, (aVar).readLocked());
    // Sentinel = 'readLocked'
    (aMsg)->WriteSentinel(1975024740);
    WriteIPDLParam(aMsg, aActor, (aVar).readLockedOnWhite());
    // Sentinel = 'readLockedOnWhite'
    (aMsg)->WriteSentinel(3410832245);
    WriteIPDLParam(aMsg, aActor, (aVar).wasPlaceholder());
    // Sentinel = 'wasPlaceholder'
    (aMsg)->WriteSentinel(3801375384);
}

auto IPDLParamTraits<mozilla::layers::TexturedTileDescriptor>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
        if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->textureParent())))))) {
            (aActor)->FatalError("Error deserializing 'textureParent' (PTexture) member of 'TexturedTileDescriptor'");
            return false;
        }
        if ((!((*((&((aVar)->textureParent()))))))) {
            (aActor)->FatalError("Error deserializing 'textureParent' (PTexture) member of 'TexturedTileDescriptor'");
            return false;
        }
        // Sentinel = 'texture'
        if ((!((aMsg)->ReadSentinel(aIter, 3654462510)))) {
            mozilla::ipc::SentinelReadError("Error deserializing 'textureParent' (PTexture) member of 'TexturedTileDescriptor'");
            return false;
        }
    }
    if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
        if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->textureChild())))))) {
            (aActor)->FatalError("Error deserializing 'textureChild' (PTexture) member of 'TexturedTileDescriptor'");
            return false;
        }
        if ((!((*((&((aVar)->textureChild()))))))) {
            (aActor)->FatalError("Error deserializing 'textureChild' (PTexture) member of 'TexturedTileDescriptor'");
            return false;
        }
        // Sentinel = 'texture'
        if ((!((aMsg)->ReadSentinel(aIter, 3654462510)))) {
            mozilla::ipc::SentinelReadError("Error deserializing 'textureChild' (PTexture) member of 'TexturedTileDescriptor'");
            return false;
        }
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->textureOnWhite())))))) {
        (aActor)->FatalError("Error deserializing 'textureOnWhite' (MaybeTexture) member of 'TexturedTileDescriptor'");
        return false;
    }
    // Sentinel = 'textureOnWhite'
    if ((!((aMsg)->ReadSentinel(aIter, 4123373327)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'textureOnWhite' (MaybeTexture) member of 'TexturedTileDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->updateRect())))))) {
        (aActor)->FatalError("Error deserializing 'updateRect' (IntRect) member of 'TexturedTileDescriptor'");
        return false;
    }
    // Sentinel = 'updateRect'
    if ((!((aMsg)->ReadSentinel(aIter, 655450235)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'updateRect' (IntRect) member of 'TexturedTileDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->readLocked())))))) {
        (aActor)->FatalError("Error deserializing 'readLocked' (bool) member of 'TexturedTileDescriptor'");
        return false;
    }
    // Sentinel = 'readLocked'
    if ((!((aMsg)->ReadSentinel(aIter, 1975024740)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'readLocked' (bool) member of 'TexturedTileDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->readLockedOnWhite())))))) {
        (aActor)->FatalError("Error deserializing 'readLockedOnWhite' (bool) member of 'TexturedTileDescriptor'");
        return false;
    }
    // Sentinel = 'readLockedOnWhite'
    if ((!((aMsg)->ReadSentinel(aIter, 3410832245)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'readLockedOnWhite' (bool) member of 'TexturedTileDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->wasPlaceholder())))))) {
        (aActor)->FatalError("Error deserializing 'wasPlaceholder' (bool) member of 'TexturedTileDescriptor'");
        return false;
    }
    // Sentinel = 'wasPlaceholder'
    if ((!((aMsg)->ReadSentinel(aIter, 3801375384)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'wasPlaceholder' (bool) member of 'TexturedTileDescriptor'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union TileDescriptor|
//
namespace mozilla {
namespace layers {
auto TileDescriptor::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TTexturedTileDescriptor:
        {
            (ptr_TexturedTileDescriptor())->~TexturedTileDescriptor__tdef();
            break;
        }
    case TPlaceholderTileDescriptor:
        {
            (ptr_PlaceholderTileDescriptor())->~PlaceholderTileDescriptor__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT TileDescriptor::TileDescriptor(const TexturedTileDescriptor& aOther)
{
    new (mozilla::KnownNotNull, ptr_TexturedTileDescriptor()) TexturedTileDescriptor(aOther);
    mType = TTexturedTileDescriptor;
}

MOZ_IMPLICIT TileDescriptor::TileDescriptor(TexturedTileDescriptor&& aOther)
{
    new (mozilla::KnownNotNull, ptr_TexturedTileDescriptor()) TexturedTileDescriptor(std::move(aOther));
    mType = TTexturedTileDescriptor;
}

MOZ_IMPLICIT TileDescriptor::TileDescriptor(const PlaceholderTileDescriptor& aOther)
{
    new (mozilla::KnownNotNull, ptr_PlaceholderTileDescriptor()) PlaceholderTileDescriptor(aOther);
    mType = TPlaceholderTileDescriptor;
}

MOZ_IMPLICIT TileDescriptor::TileDescriptor(PlaceholderTileDescriptor&& aOther)
{
    new (mozilla::KnownNotNull, ptr_PlaceholderTileDescriptor()) PlaceholderTileDescriptor(std::move(aOther));
    mType = TPlaceholderTileDescriptor;
}

MOZ_IMPLICIT TileDescriptor::TileDescriptor(const TileDescriptor& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TTexturedTileDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_TexturedTileDescriptor()) TexturedTileDescriptor((aOther).get_TexturedTileDescriptor());
            break;
        }
    case TPlaceholderTileDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_PlaceholderTileDescriptor()) PlaceholderTileDescriptor((aOther).get_PlaceholderTileDescriptor());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT TileDescriptor::TileDescriptor(TileDescriptor&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TTexturedTileDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_TexturedTileDescriptor()) TexturedTileDescriptor(std::move((aOther).get_TexturedTileDescriptor()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPlaceholderTileDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_PlaceholderTileDescriptor()) PlaceholderTileDescriptor(std::move((aOther).get_PlaceholderTileDescriptor()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto TileDescriptor::operator=(const TexturedTileDescriptor& aRhs) -> TileDescriptor&
{
    if (MaybeDestroy(TTexturedTileDescriptor)) {
        new (mozilla::KnownNotNull, ptr_TexturedTileDescriptor()) TexturedTileDescriptor;
    }
    (*(ptr_TexturedTileDescriptor())) = aRhs;
    mType = TTexturedTileDescriptor;
    return (*(this));
}

auto TileDescriptor::operator=(TexturedTileDescriptor&& aRhs) -> TileDescriptor&
{
    if (MaybeDestroy(TTexturedTileDescriptor)) {
        new (mozilla::KnownNotNull, ptr_TexturedTileDescriptor()) TexturedTileDescriptor;
    }
    (*(ptr_TexturedTileDescriptor())) = std::move(aRhs);
    mType = TTexturedTileDescriptor;
    return (*(this));
}

auto TileDescriptor::operator=(const PlaceholderTileDescriptor& aRhs) -> TileDescriptor&
{
    if (MaybeDestroy(TPlaceholderTileDescriptor)) {
        new (mozilla::KnownNotNull, ptr_PlaceholderTileDescriptor()) PlaceholderTileDescriptor;
    }
    (*(ptr_PlaceholderTileDescriptor())) = aRhs;
    mType = TPlaceholderTileDescriptor;
    return (*(this));
}

auto TileDescriptor::operator=(PlaceholderTileDescriptor&& aRhs) -> TileDescriptor&
{
    if (MaybeDestroy(TPlaceholderTileDescriptor)) {
        new (mozilla::KnownNotNull, ptr_PlaceholderTileDescriptor()) PlaceholderTileDescriptor;
    }
    (*(ptr_PlaceholderTileDescriptor())) = std::move(aRhs);
    mType = TPlaceholderTileDescriptor;
    return (*(this));
}

auto TileDescriptor::operator=(const TileDescriptor& aRhs) -> TileDescriptor&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TTexturedTileDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_TexturedTileDescriptor()) TexturedTileDescriptor;
            }
            (*(ptr_TexturedTileDescriptor())) = (aRhs).get_TexturedTileDescriptor();
            break;
        }
    case TPlaceholderTileDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PlaceholderTileDescriptor()) PlaceholderTileDescriptor;
            }
            (*(ptr_PlaceholderTileDescriptor())) = (aRhs).get_PlaceholderTileDescriptor();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto TileDescriptor::operator=(TileDescriptor&& aRhs) -> TileDescriptor&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TTexturedTileDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_TexturedTileDescriptor()) TexturedTileDescriptor;
            }
            (*(ptr_TexturedTileDescriptor())) = std::move((aRhs).get_TexturedTileDescriptor());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPlaceholderTileDescriptor:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PlaceholderTileDescriptor()) PlaceholderTileDescriptor;
            }
            (*(ptr_PlaceholderTileDescriptor())) = std::move((aRhs).get_PlaceholderTileDescriptor());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto TileDescriptor::operator==(const TexturedTileDescriptor& aRhs) const -> bool
{
    return (get_TexturedTileDescriptor()) == (aRhs);
}

auto TileDescriptor::operator==(const PlaceholderTileDescriptor& aRhs) const -> bool
{
    return (get_PlaceholderTileDescriptor()) == (aRhs);
}

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

    switch (type()) {
    case TTexturedTileDescriptor:
        {
            return (get_TexturedTileDescriptor()) == ((aRhs).get_TexturedTileDescriptor());
        }
    case TPlaceholderTileDescriptor:
        {
            return (get_PlaceholderTileDescriptor()) == ((aRhs).get_PlaceholderTileDescriptor());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto TileDescriptor::get(TexturedTileDescriptor* aOutValue) const -> void
{
    (*(aOutValue)) = get_TexturedTileDescriptor();
}

auto TileDescriptor::get(PlaceholderTileDescriptor* aOutValue) const -> void
{
    (*(aOutValue)) = get_PlaceholderTileDescriptor();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TTexturedTileDescriptor:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_TexturedTileDescriptor());
            // Sentinel = 'TTexturedTileDescriptor'
            (aMsg)->WriteSentinel(2237132903);
            return;
        }
    case union__::TPlaceholderTileDescriptor:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_PlaceholderTileDescriptor());
            // Sentinel = 'TPlaceholderTileDescriptor'
            (aMsg)->WriteSentinel(1643451770);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TTexturedTileDescriptor:
        {
            mozilla::layers::TexturedTileDescriptor tmp = mozilla::layers::TexturedTileDescriptor();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_TexturedTileDescriptor())))))) {
                (aActor)->FatalError("Error deserializing variant TTexturedTileDescriptor of union TileDescriptor");
                return false;
            }
            // Sentinel = 'TTexturedTileDescriptor'
            if ((!((aMsg)->ReadSentinel(aIter, 2237132903)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TTexturedTileDescriptor of union TileDescriptor");
                return false;
            }
            return true;
        }
    case union__::TPlaceholderTileDescriptor:
        {
            mozilla::layers::PlaceholderTileDescriptor tmp = mozilla::layers::PlaceholderTileDescriptor();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PlaceholderTileDescriptor())))))) {
                (aActor)->FatalError("Error deserializing variant TPlaceholderTileDescriptor of union TileDescriptor");
                return false;
            }
            // Sentinel = 'TPlaceholderTileDescriptor'
            if ((!((aMsg)->ReadSentinel(aIter, 1643451770)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPlaceholderTileDescriptor of union TileDescriptor");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SurfaceDescriptorTiles|
//
namespace mozilla {
namespace layers {
auto SurfaceDescriptorTiles::operator==(const SurfaceDescriptorTiles& _o) const -> bool
{
    if ((!((validRegion()) == ((_o).validRegion())))) {
        return false;
    }
    if ((!((tiles()) == ((_o).tiles())))) {
        return false;
    }
    if ((!((tileOrigin()) == ((_o).tileOrigin())))) {
        return false;
    }
    if ((!((tileSize()) == ((_o).tileSize())))) {
        return false;
    }
    if ((!((firstTileX()) == ((_o).firstTileX())))) {
        return false;
    }
    if ((!((firstTileY()) == ((_o).firstTileY())))) {
        return false;
    }
    if ((!((retainedWidth()) == ((_o).retainedWidth())))) {
        return false;
    }
    if ((!((retainedHeight()) == ((_o).retainedHeight())))) {
        return false;
    }
    if ((!((resolution()) == ((_o).resolution())))) {
        return false;
    }
    if ((!((frameXResolution()) == ((_o).frameXResolution())))) {
        return false;
    }
    if ((!((frameYResolution()) == ((_o).frameYResolution())))) {
        return false;
    }
    if ((!((isProgressive()) == ((_o).isProgressive())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::SurfaceDescriptorTiles>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).validRegion());
    // Sentinel = 'validRegion'
    (aMsg)->WriteSentinel(1063106721);
    WriteIPDLParam(aMsg, aActor, (aVar).tiles());
    // Sentinel = 'tiles'
    (aMsg)->WriteSentinel(2787066946);
    WriteIPDLParam(aMsg, aActor, (aVar).tileOrigin());
    // Sentinel = 'tileOrigin'
    (aMsg)->WriteSentinel(41129744);
    WriteIPDLParam(aMsg, aActor, (aVar).tileSize());
    // Sentinel = 'tileSize'
    (aMsg)->WriteSentinel(2603105767);
    WriteIPDLParam(aMsg, aActor, (aVar).firstTileX());
    // Sentinel = 'firstTileX'
    (aMsg)->WriteSentinel(1961114936);
    WriteIPDLParam(aMsg, aActor, (aVar).firstTileY());
    // Sentinel = 'firstTileY'
    (aMsg)->WriteSentinel(1961114937);
    WriteIPDLParam(aMsg, aActor, (aVar).retainedWidth());
    // Sentinel = 'retainedWidth'
    (aMsg)->WriteSentinel(2490297853);
    WriteIPDLParam(aMsg, aActor, (aVar).retainedHeight());
    // Sentinel = 'retainedHeight'
    (aMsg)->WriteSentinel(3230772307);
    WriteIPDLParam(aMsg, aActor, (aVar).resolution());
    // Sentinel = 'resolution'
    (aMsg)->WriteSentinel(4077768700);
    WriteIPDLParam(aMsg, aActor, (aVar).frameXResolution());
    // Sentinel = 'frameXResolution'
    (aMsg)->WriteSentinel(876167199);
    WriteIPDLParam(aMsg, aActor, (aVar).frameYResolution());
    // Sentinel = 'frameYResolution'
    (aMsg)->WriteSentinel(2856703858);
    WriteIPDLParam(aMsg, aActor, (aVar).isProgressive());
    // Sentinel = 'isProgressive'
    (aMsg)->WriteSentinel(1291560808);
}

auto IPDLParamTraits<mozilla::layers::SurfaceDescriptorTiles>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->validRegion())))))) {
        (aActor)->FatalError("Error deserializing 'validRegion' (nsIntRegion) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    // Sentinel = 'validRegion'
    if ((!((aMsg)->ReadSentinel(aIter, 1063106721)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'validRegion' (nsIntRegion) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->tiles())))))) {
        (aActor)->FatalError("Error deserializing 'tiles' (TileDescriptor[]) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    // Sentinel = 'tiles'
    if ((!((aMsg)->ReadSentinel(aIter, 2787066946)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'tiles' (TileDescriptor[]) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->tileOrigin())))))) {
        (aActor)->FatalError("Error deserializing 'tileOrigin' (IntPoint) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    // Sentinel = 'tileOrigin'
    if ((!((aMsg)->ReadSentinel(aIter, 41129744)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'tileOrigin' (IntPoint) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->tileSize())))))) {
        (aActor)->FatalError("Error deserializing 'tileSize' (IntSize) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    // Sentinel = 'tileSize'
    if ((!((aMsg)->ReadSentinel(aIter, 2603105767)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'tileSize' (IntSize) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->firstTileX())))))) {
        (aActor)->FatalError("Error deserializing 'firstTileX' (int) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    // Sentinel = 'firstTileX'
    if ((!((aMsg)->ReadSentinel(aIter, 1961114936)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'firstTileX' (int) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->firstTileY())))))) {
        (aActor)->FatalError("Error deserializing 'firstTileY' (int) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    // Sentinel = 'firstTileY'
    if ((!((aMsg)->ReadSentinel(aIter, 1961114937)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'firstTileY' (int) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->retainedWidth())))))) {
        (aActor)->FatalError("Error deserializing 'retainedWidth' (int) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    // Sentinel = 'retainedWidth'
    if ((!((aMsg)->ReadSentinel(aIter, 2490297853)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'retainedWidth' (int) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->retainedHeight())))))) {
        (aActor)->FatalError("Error deserializing 'retainedHeight' (int) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    // Sentinel = 'retainedHeight'
    if ((!((aMsg)->ReadSentinel(aIter, 3230772307)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'retainedHeight' (int) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->resolution())))))) {
        (aActor)->FatalError("Error deserializing 'resolution' (float) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    // Sentinel = 'resolution'
    if ((!((aMsg)->ReadSentinel(aIter, 4077768700)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'resolution' (float) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->frameXResolution())))))) {
        (aActor)->FatalError("Error deserializing 'frameXResolution' (float) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    // Sentinel = 'frameXResolution'
    if ((!((aMsg)->ReadSentinel(aIter, 876167199)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'frameXResolution' (float) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->frameYResolution())))))) {
        (aActor)->FatalError("Error deserializing 'frameYResolution' (float) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    // Sentinel = 'frameYResolution'
    if ((!((aMsg)->ReadSentinel(aIter, 2856703858)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'frameYResolution' (float) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->isProgressive())))))) {
        (aActor)->FatalError("Error deserializing 'isProgressive' (bool) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    // Sentinel = 'isProgressive'
    if ((!((aMsg)->ReadSentinel(aIter, 1291560808)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isProgressive' (bool) member of 'SurfaceDescriptorTiles'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct TimedTexture|
//
namespace mozilla {
namespace layers {
auto TimedTexture::operator==(const TimedTexture& _o) const -> bool
{
    if ((!((textureParent()) == ((_o).textureParent())))) {
        return false;
    }
    if ((!((textureChild()) == ((_o).textureChild())))) {
        return false;
    }
    if ((!((timeStamp()) == ((_o).timeStamp())))) {
        return false;
    }
    if ((!((picture()) == ((_o).picture())))) {
        return false;
    }
    if ((!((frameID()) == ((_o).frameID())))) {
        return false;
    }
    if ((!((producerID()) == ((_o).producerID())))) {
        return false;
    }
    if ((!((readLocked()) == ((_o).readLocked())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::TimedTexture>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
        MOZ_RELEASE_ASSERT((aVar).textureParent(), "NULL actor value passed to non-nullable param");
        WriteIPDLParam(aMsg, aActor, (aVar).textureParent());
        // Sentinel = 'texture'
        (aMsg)->WriteSentinel(3654462510);
    }
    if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
        MOZ_RELEASE_ASSERT((aVar).textureChild(), "NULL actor value passed to non-nullable param");
        WriteIPDLParam(aMsg, aActor, (aVar).textureChild());
        // Sentinel = 'texture'
        (aMsg)->WriteSentinel(3654462510);
    }
    WriteIPDLParam(aMsg, aActor, (aVar).timeStamp());
    // Sentinel = 'timeStamp'
    (aMsg)->WriteSentinel(988250409);
    WriteIPDLParam(aMsg, aActor, (aVar).picture());
    // Sentinel = 'picture'
    (aMsg)->WriteSentinel(3195561921);
    WriteIPDLParam(aMsg, aActor, (aVar).frameID());
    // Sentinel = 'frameID'
    (aMsg)->WriteSentinel(3054835247);
    WriteIPDLParam(aMsg, aActor, (aVar).producerID());
    // Sentinel = 'producerID'
    (aMsg)->WriteSentinel(1942472743);
    WriteIPDLParam(aMsg, aActor, (aVar).readLocked());
    // Sentinel = 'readLocked'
    (aMsg)->WriteSentinel(1975024740);
}

auto IPDLParamTraits<mozilla::layers::TimedTexture>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
        if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->textureParent())))))) {
            (aActor)->FatalError("Error deserializing 'textureParent' (PTexture) member of 'TimedTexture'");
            return false;
        }
        if ((!((*((&((aVar)->textureParent()))))))) {
            (aActor)->FatalError("Error deserializing 'textureParent' (PTexture) member of 'TimedTexture'");
            return false;
        }
        // Sentinel = 'texture'
        if ((!((aMsg)->ReadSentinel(aIter, 3654462510)))) {
            mozilla::ipc::SentinelReadError("Error deserializing 'textureParent' (PTexture) member of 'TimedTexture'");
            return false;
        }
    }
    if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
        if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->textureChild())))))) {
            (aActor)->FatalError("Error deserializing 'textureChild' (PTexture) member of 'TimedTexture'");
            return false;
        }
        if ((!((*((&((aVar)->textureChild()))))))) {
            (aActor)->FatalError("Error deserializing 'textureChild' (PTexture) member of 'TimedTexture'");
            return false;
        }
        // Sentinel = 'texture'
        if ((!((aMsg)->ReadSentinel(aIter, 3654462510)))) {
            mozilla::ipc::SentinelReadError("Error deserializing 'textureChild' (PTexture) member of 'TimedTexture'");
            return false;
        }
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->timeStamp())))))) {
        (aActor)->FatalError("Error deserializing 'timeStamp' (TimeStamp) member of 'TimedTexture'");
        return false;
    }
    // Sentinel = 'timeStamp'
    if ((!((aMsg)->ReadSentinel(aIter, 988250409)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'timeStamp' (TimeStamp) member of 'TimedTexture'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->picture())))))) {
        (aActor)->FatalError("Error deserializing 'picture' (IntRect) member of 'TimedTexture'");
        return false;
    }
    // Sentinel = 'picture'
    if ((!((aMsg)->ReadSentinel(aIter, 3195561921)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'picture' (IntRect) member of 'TimedTexture'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->frameID())))))) {
        (aActor)->FatalError("Error deserializing 'frameID' (uint32_t) member of 'TimedTexture'");
        return false;
    }
    // Sentinel = 'frameID'
    if ((!((aMsg)->ReadSentinel(aIter, 3054835247)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'frameID' (uint32_t) member of 'TimedTexture'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->producerID())))))) {
        (aActor)->FatalError("Error deserializing 'producerID' (uint32_t) member of 'TimedTexture'");
        return false;
    }
    // Sentinel = 'producerID'
    if ((!((aMsg)->ReadSentinel(aIter, 1942472743)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'producerID' (uint32_t) member of 'TimedTexture'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->readLocked())))))) {
        (aActor)->FatalError("Error deserializing 'readLocked' (bool) member of 'TimedTexture'");
        return false;
    }
    // Sentinel = 'readLocked'
    if ((!((aMsg)->ReadSentinel(aIter, 1975024740)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'readLocked' (bool) member of 'TimedTexture'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpUseComponentAlphaTextures|
//
namespace mozilla {
namespace layers {
auto OpUseComponentAlphaTextures::operator==(const OpUseComponentAlphaTextures& _o) const -> bool
{
    if ((!((textureOnBlackParent()) == ((_o).textureOnBlackParent())))) {
        return false;
    }
    if ((!((textureOnBlackChild()) == ((_o).textureOnBlackChild())))) {
        return false;
    }
    if ((!((textureOnWhiteParent()) == ((_o).textureOnWhiteParent())))) {
        return false;
    }
    if ((!((textureOnWhiteChild()) == ((_o).textureOnWhiteChild())))) {
        return false;
    }
    if ((!((readLockedBlack()) == ((_o).readLockedBlack())))) {
        return false;
    }
    if ((!((readLockedWhite()) == ((_o).readLockedWhite())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::OpUseComponentAlphaTextures>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
        MOZ_RELEASE_ASSERT((aVar).textureOnBlackParent(), "NULL actor value passed to non-nullable param");
        WriteIPDLParam(aMsg, aActor, (aVar).textureOnBlackParent());
        // Sentinel = 'textureOnBlack'
        (aMsg)->WriteSentinel(2782165397);
    }
    if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
        MOZ_RELEASE_ASSERT((aVar).textureOnBlackChild(), "NULL actor value passed to non-nullable param");
        WriteIPDLParam(aMsg, aActor, (aVar).textureOnBlackChild());
        // Sentinel = 'textureOnBlack'
        (aMsg)->WriteSentinel(2782165397);
    }
    if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
        MOZ_RELEASE_ASSERT((aVar).textureOnWhiteParent(), "NULL actor value passed to non-nullable param");
        WriteIPDLParam(aMsg, aActor, (aVar).textureOnWhiteParent());
        // Sentinel = 'textureOnWhite'
        (aMsg)->WriteSentinel(4123373327);
    }
    if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
        MOZ_RELEASE_ASSERT((aVar).textureOnWhiteChild(), "NULL actor value passed to non-nullable param");
        WriteIPDLParam(aMsg, aActor, (aVar).textureOnWhiteChild());
        // Sentinel = 'textureOnWhite'
        (aMsg)->WriteSentinel(4123373327);
    }
    WriteIPDLParam(aMsg, aActor, (aVar).readLockedBlack());
    // Sentinel = 'readLockedBlack'
    (aMsg)->WriteSentinel(4262845016);
    WriteIPDLParam(aMsg, aActor, (aVar).readLockedWhite());
    // Sentinel = 'readLockedWhite'
    (aMsg)->WriteSentinel(44179186);
}

auto IPDLParamTraits<mozilla::layers::OpUseComponentAlphaTextures>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
        if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->textureOnBlackParent())))))) {
            (aActor)->FatalError("Error deserializing 'textureOnBlackParent' (PTexture) member of 'OpUseComponentAlphaTextures'");
            return false;
        }
        if ((!((*((&((aVar)->textureOnBlackParent()))))))) {
            (aActor)->FatalError("Error deserializing 'textureOnBlackParent' (PTexture) member of 'OpUseComponentAlphaTextures'");
            return false;
        }
        // Sentinel = 'textureOnBlack'
        if ((!((aMsg)->ReadSentinel(aIter, 2782165397)))) {
            mozilla::ipc::SentinelReadError("Error deserializing 'textureOnBlackParent' (PTexture) member of 'OpUseComponentAlphaTextures'");
            return false;
        }
    }
    if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
        if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->textureOnBlackChild())))))) {
            (aActor)->FatalError("Error deserializing 'textureOnBlackChild' (PTexture) member of 'OpUseComponentAlphaTextures'");
            return false;
        }
        if ((!((*((&((aVar)->textureOnBlackChild()))))))) {
            (aActor)->FatalError("Error deserializing 'textureOnBlackChild' (PTexture) member of 'OpUseComponentAlphaTextures'");
            return false;
        }
        // Sentinel = 'textureOnBlack'
        if ((!((aMsg)->ReadSentinel(aIter, 2782165397)))) {
            mozilla::ipc::SentinelReadError("Error deserializing 'textureOnBlackChild' (PTexture) member of 'OpUseComponentAlphaTextures'");
            return false;
        }
    }
    if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
        if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->textureOnWhiteParent())))))) {
            (aActor)->FatalError("Error deserializing 'textureOnWhiteParent' (PTexture) member of 'OpUseComponentAlphaTextures'");
            return false;
        }
        if ((!((*((&((aVar)->textureOnWhiteParent()))))))) {
            (aActor)->FatalError("Error deserializing 'textureOnWhiteParent' (PTexture) member of 'OpUseComponentAlphaTextures'");
            return false;
        }
        // Sentinel = 'textureOnWhite'
        if ((!((aMsg)->ReadSentinel(aIter, 4123373327)))) {
            mozilla::ipc::SentinelReadError("Error deserializing 'textureOnWhiteParent' (PTexture) member of 'OpUseComponentAlphaTextures'");
            return false;
        }
    }
    if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
        if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->textureOnWhiteChild())))))) {
            (aActor)->FatalError("Error deserializing 'textureOnWhiteChild' (PTexture) member of 'OpUseComponentAlphaTextures'");
            return false;
        }
        if ((!((*((&((aVar)->textureOnWhiteChild()))))))) {
            (aActor)->FatalError("Error deserializing 'textureOnWhiteChild' (PTexture) member of 'OpUseComponentAlphaTextures'");
            return false;
        }
        // Sentinel = 'textureOnWhite'
        if ((!((aMsg)->ReadSentinel(aIter, 4123373327)))) {
            mozilla::ipc::SentinelReadError("Error deserializing 'textureOnWhiteChild' (PTexture) member of 'OpUseComponentAlphaTextures'");
            return false;
        }
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->readLockedBlack())))))) {
        (aActor)->FatalError("Error deserializing 'readLockedBlack' (bool) member of 'OpUseComponentAlphaTextures'");
        return false;
    }
    // Sentinel = 'readLockedBlack'
    if ((!((aMsg)->ReadSentinel(aIter, 4262845016)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'readLockedBlack' (bool) member of 'OpUseComponentAlphaTextures'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->readLockedWhite())))))) {
        (aActor)->FatalError("Error deserializing 'readLockedWhite' (bool) member of 'OpUseComponentAlphaTextures'");
        return false;
    }
    // Sentinel = 'readLockedWhite'
    if ((!((aMsg)->ReadSentinel(aIter, 44179186)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'readLockedWhite' (bool) member of 'OpUseComponentAlphaTextures'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

MOZ_IMPLICIT MaybeRegion::MaybeRegion(const nsIntRegion& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsIntRegion()) nsIntRegion(aOther);
    mType = TnsIntRegion;
}

MOZ_IMPLICIT MaybeRegion::MaybeRegion(nsIntRegion&& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsIntRegion()) nsIntRegion(std::move(aOther));
    mType = TnsIntRegion;
}

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

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

MOZ_IMPLICIT MaybeRegion::MaybeRegion(const MaybeRegion& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TnsIntRegion:
        {
            new (mozilla::KnownNotNull, ptr_nsIntRegion()) nsIntRegion((aOther).get_nsIntRegion());
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT MaybeRegion::MaybeRegion(MaybeRegion&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TnsIntRegion:
        {
            new (mozilla::KnownNotNull, ptr_nsIntRegion()) nsIntRegion(std::move((aOther).get_nsIntRegion()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_t()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto MaybeRegion::operator=(const nsIntRegion& aRhs) -> MaybeRegion&
{
    if (MaybeDestroy(TnsIntRegion)) {
        new (mozilla::KnownNotNull, ptr_nsIntRegion()) nsIntRegion;
    }
    (*(ptr_nsIntRegion())) = aRhs;
    mType = TnsIntRegion;
    return (*(this));
}

auto MaybeRegion::operator=(nsIntRegion&& aRhs) -> MaybeRegion&
{
    if (MaybeDestroy(TnsIntRegion)) {
        new (mozilla::KnownNotNull, ptr_nsIntRegion()) nsIntRegion;
    }
    (*(ptr_nsIntRegion())) = std::move(aRhs);
    mType = TnsIntRegion;
    return (*(this));
}

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

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

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

auto MaybeRegion::operator=(MaybeRegion&& aRhs) -> MaybeRegion&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TnsIntRegion:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_nsIntRegion()) nsIntRegion;
            }
            (*(ptr_nsIntRegion())) = std::move((aRhs).get_nsIntRegion());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = std::move((aRhs).get_null_t());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto MaybeRegion::operator==(const nsIntRegion& aRhs) const -> bool
{
    return (get_nsIntRegion()) == (aRhs);
}

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

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

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

auto MaybeRegion::get(nsIntRegion* aOutValue) const -> void
{
    (*(aOutValue)) = get_nsIntRegion();
}

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

} // namespace layers
} // namespace mozilla

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

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

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union CompositableOperationDetail|
//
namespace mozilla {
namespace layers {
auto CompositableOperationDetail::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TOpPaintTextureRegion:
        {
            (ptr_OpPaintTextureRegion())->~OpPaintTextureRegion__tdef();
            break;
        }
    case TOpUseTiledLayerBuffer:
        {
            (ptr_OpUseTiledLayerBuffer())->~OpUseTiledLayerBuffer__tdef();
            break;
        }
    case TOpRemoveTexture:
        {
            (ptr_OpRemoveTexture())->~OpRemoveTexture__tdef();
            break;
        }
    case TOpUseTexture:
        {
            (ptr_OpUseTexture())->~OpUseTexture__tdef();
            break;
        }
    case TOpUseComponentAlphaTextures:
        {
            (ptr_OpUseComponentAlphaTextures())->~OpUseComponentAlphaTextures__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpPaintTextureRegion& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpPaintTextureRegion()) OpPaintTextureRegion(aOther);
    mType = TOpPaintTextureRegion;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(OpPaintTextureRegion&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpPaintTextureRegion()) OpPaintTextureRegion(std::move(aOther));
    mType = TOpPaintTextureRegion;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpUseTiledLayerBuffer& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUseTiledLayerBuffer()) OpUseTiledLayerBuffer(aOther);
    mType = TOpUseTiledLayerBuffer;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(OpUseTiledLayerBuffer&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUseTiledLayerBuffer()) OpUseTiledLayerBuffer(std::move(aOther));
    mType = TOpUseTiledLayerBuffer;
}

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 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 OpUseComponentAlphaTextures& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUseComponentAlphaTextures()) OpUseComponentAlphaTextures(aOther);
    mType = TOpUseComponentAlphaTextures;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(OpUseComponentAlphaTextures&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpUseComponentAlphaTextures()) OpUseComponentAlphaTextures(std::move(aOther));
    mType = TOpUseComponentAlphaTextures;
}

MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const CompositableOperationDetail& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TOpPaintTextureRegion:
        {
            new (mozilla::KnownNotNull, ptr_OpPaintTextureRegion()) OpPaintTextureRegion((aOther).get_OpPaintTextureRegion());
            break;
        }
    case TOpUseTiledLayerBuffer:
        {
            new (mozilla::KnownNotNull, ptr_OpUseTiledLayerBuffer()) OpUseTiledLayerBuffer((aOther).get_OpUseTiledLayerBuffer());
            break;
        }
    case TOpRemoveTexture:
        {
            new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture((aOther).get_OpRemoveTexture());
            break;
        }
    case TOpUseTexture:
        {
            new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture((aOther).get_OpUseTexture());
            break;
        }
    case TOpUseComponentAlphaTextures:
        {
            new (mozilla::KnownNotNull, ptr_OpUseComponentAlphaTextures()) OpUseComponentAlphaTextures((aOther).get_OpUseComponentAlphaTextures());
            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 TOpPaintTextureRegion:
        {
            new (mozilla::KnownNotNull, ptr_OpPaintTextureRegion()) OpPaintTextureRegion(std::move((aOther).get_OpPaintTextureRegion()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpUseTiledLayerBuffer:
        {
            new (mozilla::KnownNotNull, ptr_OpUseTiledLayerBuffer()) OpUseTiledLayerBuffer(std::move((aOther).get_OpUseTiledLayerBuffer()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpRemoveTexture:
        {
            new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture(std::move((aOther).get_OpRemoveTexture()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpUseTexture:
        {
            new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture(std::move((aOther).get_OpUseTexture()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpUseComponentAlphaTextures:
        {
            new (mozilla::KnownNotNull, ptr_OpUseComponentAlphaTextures()) OpUseComponentAlphaTextures(std::move((aOther).get_OpUseComponentAlphaTextures()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto CompositableOperationDetail::operator=(const OpPaintTextureRegion& aRhs) -> CompositableOperationDetail&
{
    if (MaybeDestroy(TOpPaintTextureRegion)) {
        new (mozilla::KnownNotNull, ptr_OpPaintTextureRegion()) OpPaintTextureRegion;
    }
    (*(ptr_OpPaintTextureRegion())) = aRhs;
    mType = TOpPaintTextureRegion;
    return (*(this));
}

auto CompositableOperationDetail::operator=(OpPaintTextureRegion&& aRhs) -> CompositableOperationDetail&
{
    if (MaybeDestroy(TOpPaintTextureRegion)) {
        new (mozilla::KnownNotNull, ptr_OpPaintTextureRegion()) OpPaintTextureRegion;
    }
    (*(ptr_OpPaintTextureRegion())) = std::move(aRhs);
    mType = TOpPaintTextureRegion;
    return (*(this));
}

auto CompositableOperationDetail::operator=(const OpUseTiledLayerBuffer& aRhs) -> CompositableOperationDetail&
{
    if (MaybeDestroy(TOpUseTiledLayerBuffer)) {
        new (mozilla::KnownNotNull, ptr_OpUseTiledLayerBuffer()) OpUseTiledLayerBuffer;
    }
    (*(ptr_OpUseTiledLayerBuffer())) = aRhs;
    mType = TOpUseTiledLayerBuffer;
    return (*(this));
}

auto CompositableOperationDetail::operator=(OpUseTiledLayerBuffer&& aRhs) -> CompositableOperationDetail&
{
    if (MaybeDestroy(TOpUseTiledLayerBuffer)) {
        new (mozilla::KnownNotNull, ptr_OpUseTiledLayerBuffer()) OpUseTiledLayerBuffer;
    }
    (*(ptr_OpUseTiledLayerBuffer())) = std::move(aRhs);
    mType = TOpUseTiledLayerBuffer;
    return (*(this));
}

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

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

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

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

auto CompositableOperationDetail::operator=(const OpUseComponentAlphaTextures& aRhs) -> CompositableOperationDetail&
{
    if (MaybeDestroy(TOpUseComponentAlphaTextures)) {
        new (mozilla::KnownNotNull, ptr_OpUseComponentAlphaTextures()) OpUseComponentAlphaTextures;
    }
    (*(ptr_OpUseComponentAlphaTextures())) = aRhs;
    mType = TOpUseComponentAlphaTextures;
    return (*(this));
}

auto CompositableOperationDetail::operator=(OpUseComponentAlphaTextures&& aRhs) -> CompositableOperationDetail&
{
    if (MaybeDestroy(TOpUseComponentAlphaTextures)) {
        new (mozilla::KnownNotNull, ptr_OpUseComponentAlphaTextures()) OpUseComponentAlphaTextures;
    }
    (*(ptr_OpUseComponentAlphaTextures())) = std::move(aRhs);
    mType = TOpUseComponentAlphaTextures;
    return (*(this));
}

auto CompositableOperationDetail::operator=(const CompositableOperationDetail& aRhs) -> CompositableOperationDetail&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TOpPaintTextureRegion:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpPaintTextureRegion()) OpPaintTextureRegion;
            }
            (*(ptr_OpPaintTextureRegion())) = (aRhs).get_OpPaintTextureRegion();
            break;
        }
    case TOpUseTiledLayerBuffer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUseTiledLayerBuffer()) OpUseTiledLayerBuffer;
            }
            (*(ptr_OpUseTiledLayerBuffer())) = (aRhs).get_OpUseTiledLayerBuffer();
            break;
        }
    case TOpRemoveTexture:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture;
            }
            (*(ptr_OpRemoveTexture())) = (aRhs).get_OpRemoveTexture();
            break;
        }
    case TOpUseTexture:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture;
            }
            (*(ptr_OpUseTexture())) = (aRhs).get_OpUseTexture();
            break;
        }
    case TOpUseComponentAlphaTextures:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUseComponentAlphaTextures()) OpUseComponentAlphaTextures;
            }
            (*(ptr_OpUseComponentAlphaTextures())) = (aRhs).get_OpUseComponentAlphaTextures();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            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 TOpPaintTextureRegion:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpPaintTextureRegion()) OpPaintTextureRegion;
            }
            (*(ptr_OpPaintTextureRegion())) = std::move((aRhs).get_OpPaintTextureRegion());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpUseTiledLayerBuffer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUseTiledLayerBuffer()) OpUseTiledLayerBuffer;
            }
            (*(ptr_OpUseTiledLayerBuffer())) = std::move((aRhs).get_OpUseTiledLayerBuffer());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpRemoveTexture:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture;
            }
            (*(ptr_OpRemoveTexture())) = std::move((aRhs).get_OpRemoveTexture());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpUseTexture:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture;
            }
            (*(ptr_OpUseTexture())) = std::move((aRhs).get_OpUseTexture());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpUseComponentAlphaTextures:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpUseComponentAlphaTextures()) OpUseComponentAlphaTextures;
            }
            (*(ptr_OpUseComponentAlphaTextures())) = std::move((aRhs).get_OpUseComponentAlphaTextures());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto CompositableOperationDetail::operator==(const OpPaintTextureRegion& aRhs) const -> bool
{
    return (get_OpPaintTextureRegion()) == (aRhs);
}

auto CompositableOperationDetail::operator==(const OpUseTiledLayerBuffer& aRhs) const -> bool
{
    return (get_OpUseTiledLayerBuffer()) == (aRhs);
}

auto CompositableOperationDetail::operator==(const OpRemoveTexture& aRhs) const -> bool
{
    return (get_OpRemoveTexture()) == (aRhs);
}

auto CompositableOperationDetail::operator==(const OpUseTexture& aRhs) const -> bool
{
    return (get_OpUseTexture()) == (aRhs);
}

auto CompositableOperationDetail::operator==(const OpUseComponentAlphaTextures& aRhs) const -> bool
{
    return (get_OpUseComponentAlphaTextures()) == (aRhs);
}

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

    switch (type()) {
    case TOpPaintTextureRegion:
        {
            return (get_OpPaintTextureRegion()) == ((aRhs).get_OpPaintTextureRegion());
        }
    case TOpUseTiledLayerBuffer:
        {
            return (get_OpUseTiledLayerBuffer()) == ((aRhs).get_OpUseTiledLayerBuffer());
        }
    case TOpRemoveTexture:
        {
            return (get_OpRemoveTexture()) == ((aRhs).get_OpRemoveTexture());
        }
    case TOpUseTexture:
        {
            return (get_OpUseTexture()) == ((aRhs).get_OpUseTexture());
        }
    case TOpUseComponentAlphaTextures:
        {
            return (get_OpUseComponentAlphaTextures()) == ((aRhs).get_OpUseComponentAlphaTextures());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto CompositableOperationDetail::get(OpPaintTextureRegion* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpPaintTextureRegion();
}

auto CompositableOperationDetail::get(OpUseTiledLayerBuffer* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpUseTiledLayerBuffer();
}

auto CompositableOperationDetail::get(OpRemoveTexture* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpRemoveTexture();
}

auto CompositableOperationDetail::get(OpUseTexture* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpUseTexture();
}

auto CompositableOperationDetail::get(OpUseComponentAlphaTextures* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpUseComponentAlphaTextures();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TOpPaintTextureRegion:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpPaintTextureRegion());
            // Sentinel = 'TOpPaintTextureRegion'
            (aMsg)->WriteSentinel(734509049);
            return;
        }
    case union__::TOpUseTiledLayerBuffer:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpUseTiledLayerBuffer());
            // Sentinel = 'TOpUseTiledLayerBuffer'
            (aMsg)->WriteSentinel(916924693);
            return;
        }
    case union__::TOpRemoveTexture:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpRemoveTexture());
            // Sentinel = 'TOpRemoveTexture'
            (aMsg)->WriteSentinel(2379906162);
            return;
        }
    case union__::TOpUseTexture:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpUseTexture());
            // Sentinel = 'TOpUseTexture'
            (aMsg)->WriteSentinel(581630962);
            return;
        }
    case union__::TOpUseComponentAlphaTextures:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpUseComponentAlphaTextures());
            // Sentinel = 'TOpUseComponentAlphaTextures'
            (aMsg)->WriteSentinel(457985329);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TOpPaintTextureRegion:
        {
            mozilla::layers::OpPaintTextureRegion tmp = mozilla::layers::OpPaintTextureRegion();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpPaintTextureRegion())))))) {
                (aActor)->FatalError("Error deserializing variant TOpPaintTextureRegion of union CompositableOperationDetail");
                return false;
            }
            // Sentinel = 'TOpPaintTextureRegion'
            if ((!((aMsg)->ReadSentinel(aIter, 734509049)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpPaintTextureRegion of union CompositableOperationDetail");
                return false;
            }
            return true;
        }
    case union__::TOpUseTiledLayerBuffer:
        {
            mozilla::layers::OpUseTiledLayerBuffer tmp = mozilla::layers::OpUseTiledLayerBuffer();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpUseTiledLayerBuffer())))))) {
                (aActor)->FatalError("Error deserializing variant TOpUseTiledLayerBuffer of union CompositableOperationDetail");
                return false;
            }
            // Sentinel = 'TOpUseTiledLayerBuffer'
            if ((!((aMsg)->ReadSentinel(aIter, 916924693)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpUseTiledLayerBuffer of union CompositableOperationDetail");
                return false;
            }
            return true;
        }
    case union__::TOpRemoveTexture:
        {
            mozilla::layers::OpRemoveTexture tmp = mozilla::layers::OpRemoveTexture();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpRemoveTexture())))))) {
                (aActor)->FatalError("Error deserializing variant TOpRemoveTexture of union CompositableOperationDetail");
                return false;
            }
            // Sentinel = 'TOpRemoveTexture'
            if ((!((aMsg)->ReadSentinel(aIter, 2379906162)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpRemoveTexture of union CompositableOperationDetail");
                return false;
            }
            return true;
        }
    case union__::TOpUseTexture:
        {
            mozilla::layers::OpUseTexture tmp = mozilla::layers::OpUseTexture();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpUseTexture())))))) {
                (aActor)->FatalError("Error deserializing variant TOpUseTexture of union CompositableOperationDetail");
                return false;
            }
            // Sentinel = 'TOpUseTexture'
            if ((!((aMsg)->ReadSentinel(aIter, 581630962)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpUseTexture of union CompositableOperationDetail");
                return false;
            }
            return true;
        }
    case union__::TOpUseComponentAlphaTextures:
        {
            mozilla::layers::OpUseComponentAlphaTextures tmp = mozilla::layers::OpUseComponentAlphaTextures();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpUseComponentAlphaTextures())))))) {
                (aActor)->FatalError("Error deserializing variant TOpUseComponentAlphaTextures of union CompositableOperationDetail");
                return false;
            }
            // Sentinel = 'TOpUseComponentAlphaTextures'
            if ((!((aMsg)->ReadSentinel(aIter, 457985329)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpUseComponentAlphaTextures of union CompositableOperationDetail");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union Edit|
//
namespace mozilla {
namespace layers {
auto Edit::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TOpCreatePaintedLayer:
        {
            (ptr_OpCreatePaintedLayer())->~OpCreatePaintedLayer__tdef();
            break;
        }
    case TOpCreateContainerLayer:
        {
            (ptr_OpCreateContainerLayer())->~OpCreateContainerLayer__tdef();
            break;
        }
    case TOpCreateImageLayer:
        {
            (ptr_OpCreateImageLayer())->~OpCreateImageLayer__tdef();
            break;
        }
    case TOpCreateColorLayer:
        {
            (ptr_OpCreateColorLayer())->~OpCreateColorLayer__tdef();
            break;
        }
    case TOpCreateCanvasLayer:
        {
            (ptr_OpCreateCanvasLayer())->~OpCreateCanvasLayer__tdef();
            break;
        }
    case TOpCreateRefLayer:
        {
            (ptr_OpCreateRefLayer())->~OpCreateRefLayer__tdef();
            break;
        }
    case TOpSetDiagnosticTypes:
        {
            (ptr_OpSetDiagnosticTypes())->~OpSetDiagnosticTypes__tdef();
            break;
        }
    case TOpWindowOverlayChanged:
        {
            (ptr_OpWindowOverlayChanged())->~OpWindowOverlayChanged__tdef();
            break;
        }
    case TOpSetRoot:
        {
            (ptr_OpSetRoot())->~OpSetRoot__tdef();
            break;
        }
    case TOpInsertAfter:
        {
            (ptr_OpInsertAfter())->~OpInsertAfter__tdef();
            break;
        }
    case TOpPrependChild:
        {
            (ptr_OpPrependChild())->~OpPrependChild__tdef();
            break;
        }
    case TOpRemoveChild:
        {
            (ptr_OpRemoveChild())->~OpRemoveChild__tdef();
            break;
        }
    case TOpRepositionChild:
        {
            (ptr_OpRepositionChild())->~OpRepositionChild__tdef();
            break;
        }
    case TOpRaiseToTopChild:
        {
            (ptr_OpRaiseToTopChild())->~OpRaiseToTopChild__tdef();
            break;
        }
    case TOpAttachCompositable:
        {
            (ptr_OpAttachCompositable())->~OpAttachCompositable__tdef();
            break;
        }
    case TOpAttachAsyncCompositable:
        {
            (ptr_OpAttachAsyncCompositable())->~OpAttachAsyncCompositable__tdef();
            break;
        }
    case TCompositableOperation:
        {
            (ptr_CompositableOperation())->~CompositableOperation__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT Edit::Edit(const OpCreatePaintedLayer& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpCreatePaintedLayer()) OpCreatePaintedLayer(aOther);
    mType = TOpCreatePaintedLayer;
}

MOZ_IMPLICIT Edit::Edit(OpCreatePaintedLayer&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpCreatePaintedLayer()) OpCreatePaintedLayer(std::move(aOther));
    mType = TOpCreatePaintedLayer;
}

MOZ_IMPLICIT Edit::Edit(const OpCreateContainerLayer& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpCreateContainerLayer()) OpCreateContainerLayer(aOther);
    mType = TOpCreateContainerLayer;
}

MOZ_IMPLICIT Edit::Edit(OpCreateContainerLayer&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpCreateContainerLayer()) OpCreateContainerLayer(std::move(aOther));
    mType = TOpCreateContainerLayer;
}

MOZ_IMPLICIT Edit::Edit(const OpCreateImageLayer& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpCreateImageLayer()) OpCreateImageLayer(aOther);
    mType = TOpCreateImageLayer;
}

MOZ_IMPLICIT Edit::Edit(OpCreateImageLayer&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpCreateImageLayer()) OpCreateImageLayer(std::move(aOther));
    mType = TOpCreateImageLayer;
}

MOZ_IMPLICIT Edit::Edit(const OpCreateColorLayer& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpCreateColorLayer()) OpCreateColorLayer(aOther);
    mType = TOpCreateColorLayer;
}

MOZ_IMPLICIT Edit::Edit(OpCreateColorLayer&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpCreateColorLayer()) OpCreateColorLayer(std::move(aOther));
    mType = TOpCreateColorLayer;
}

MOZ_IMPLICIT Edit::Edit(const OpCreateCanvasLayer& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer(aOther);
    mType = TOpCreateCanvasLayer;
}

MOZ_IMPLICIT Edit::Edit(OpCreateCanvasLayer&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer(std::move(aOther));
    mType = TOpCreateCanvasLayer;
}

MOZ_IMPLICIT Edit::Edit(const OpCreateRefLayer& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpCreateRefLayer()) OpCreateRefLayer(aOther);
    mType = TOpCreateRefLayer;
}

MOZ_IMPLICIT Edit::Edit(OpCreateRefLayer&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpCreateRefLayer()) OpCreateRefLayer(std::move(aOther));
    mType = TOpCreateRefLayer;
}

MOZ_IMPLICIT Edit::Edit(const OpSetDiagnosticTypes& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpSetDiagnosticTypes()) OpSetDiagnosticTypes(aOther);
    mType = TOpSetDiagnosticTypes;
}

MOZ_IMPLICIT Edit::Edit(OpSetDiagnosticTypes&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpSetDiagnosticTypes()) OpSetDiagnosticTypes(std::move(aOther));
    mType = TOpSetDiagnosticTypes;
}

MOZ_IMPLICIT Edit::Edit(const OpWindowOverlayChanged& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpWindowOverlayChanged()) OpWindowOverlayChanged(aOther);
    mType = TOpWindowOverlayChanged;
}

MOZ_IMPLICIT Edit::Edit(OpWindowOverlayChanged&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpWindowOverlayChanged()) OpWindowOverlayChanged(std::move(aOther));
    mType = TOpWindowOverlayChanged;
}

MOZ_IMPLICIT Edit::Edit(const OpSetRoot& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpSetRoot()) OpSetRoot(aOther);
    mType = TOpSetRoot;
}

MOZ_IMPLICIT Edit::Edit(OpSetRoot&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpSetRoot()) OpSetRoot(std::move(aOther));
    mType = TOpSetRoot;
}

MOZ_IMPLICIT Edit::Edit(const OpInsertAfter& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpInsertAfter()) OpInsertAfter(aOther);
    mType = TOpInsertAfter;
}

MOZ_IMPLICIT Edit::Edit(OpInsertAfter&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpInsertAfter()) OpInsertAfter(std::move(aOther));
    mType = TOpInsertAfter;
}

MOZ_IMPLICIT Edit::Edit(const OpPrependChild& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpPrependChild()) OpPrependChild(aOther);
    mType = TOpPrependChild;
}

MOZ_IMPLICIT Edit::Edit(OpPrependChild&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpPrependChild()) OpPrependChild(std::move(aOther));
    mType = TOpPrependChild;
}

MOZ_IMPLICIT Edit::Edit(const OpRemoveChild& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpRemoveChild()) OpRemoveChild(aOther);
    mType = TOpRemoveChild;
}

MOZ_IMPLICIT Edit::Edit(OpRemoveChild&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpRemoveChild()) OpRemoveChild(std::move(aOther));
    mType = TOpRemoveChild;
}

MOZ_IMPLICIT Edit::Edit(const OpRepositionChild& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpRepositionChild()) OpRepositionChild(aOther);
    mType = TOpRepositionChild;
}

MOZ_IMPLICIT Edit::Edit(OpRepositionChild&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpRepositionChild()) OpRepositionChild(std::move(aOther));
    mType = TOpRepositionChild;
}

MOZ_IMPLICIT Edit::Edit(const OpRaiseToTopChild& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpRaiseToTopChild()) OpRaiseToTopChild(aOther);
    mType = TOpRaiseToTopChild;
}

MOZ_IMPLICIT Edit::Edit(OpRaiseToTopChild&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpRaiseToTopChild()) OpRaiseToTopChild(std::move(aOther));
    mType = TOpRaiseToTopChild;
}

MOZ_IMPLICIT Edit::Edit(const OpAttachCompositable& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAttachCompositable()) OpAttachCompositable(aOther);
    mType = TOpAttachCompositable;
}

MOZ_IMPLICIT Edit::Edit(OpAttachCompositable&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAttachCompositable()) OpAttachCompositable(std::move(aOther));
    mType = TOpAttachCompositable;
}

MOZ_IMPLICIT Edit::Edit(const OpAttachAsyncCompositable& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAttachAsyncCompositable()) OpAttachAsyncCompositable(aOther);
    mType = TOpAttachAsyncCompositable;
}

MOZ_IMPLICIT Edit::Edit(OpAttachAsyncCompositable&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OpAttachAsyncCompositable()) OpAttachAsyncCompositable(std::move(aOther));
    mType = TOpAttachAsyncCompositable;
}

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

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

MOZ_IMPLICIT Edit::Edit(const Edit& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TOpCreatePaintedLayer:
        {
            new (mozilla::KnownNotNull, ptr_OpCreatePaintedLayer()) OpCreatePaintedLayer((aOther).get_OpCreatePaintedLayer());
            break;
        }
    case TOpCreateContainerLayer:
        {
            new (mozilla::KnownNotNull, ptr_OpCreateContainerLayer()) OpCreateContainerLayer((aOther).get_OpCreateContainerLayer());
            break;
        }
    case TOpCreateImageLayer:
        {
            new (mozilla::KnownNotNull, ptr_OpCreateImageLayer()) OpCreateImageLayer((aOther).get_OpCreateImageLayer());
            break;
        }
    case TOpCreateColorLayer:
        {
            new (mozilla::KnownNotNull, ptr_OpCreateColorLayer()) OpCreateColorLayer((aOther).get_OpCreateColorLayer());
            break;
        }
    case TOpCreateCanvasLayer:
        {
            new (mozilla::KnownNotNull, ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer((aOther).get_OpCreateCanvasLayer());
            break;
        }
    case TOpCreateRefLayer:
        {
            new (mozilla::KnownNotNull, ptr_OpCreateRefLayer()) OpCreateRefLayer((aOther).get_OpCreateRefLayer());
            break;
        }
    case TOpSetDiagnosticTypes:
        {
            new (mozilla::KnownNotNull, ptr_OpSetDiagnosticTypes()) OpSetDiagnosticTypes((aOther).get_OpSetDiagnosticTypes());
            break;
        }
    case TOpWindowOverlayChanged:
        {
            new (mozilla::KnownNotNull, ptr_OpWindowOverlayChanged()) OpWindowOverlayChanged((aOther).get_OpWindowOverlayChanged());
            break;
        }
    case TOpSetRoot:
        {
            new (mozilla::KnownNotNull, ptr_OpSetRoot()) OpSetRoot((aOther).get_OpSetRoot());
            break;
        }
    case TOpInsertAfter:
        {
            new (mozilla::KnownNotNull, ptr_OpInsertAfter()) OpInsertAfter((aOther).get_OpInsertAfter());
            break;
        }
    case TOpPrependChild:
        {
            new (mozilla::KnownNotNull, ptr_OpPrependChild()) OpPrependChild((aOther).get_OpPrependChild());
            break;
        }
    case TOpRemoveChild:
        {
            new (mozilla::KnownNotNull, ptr_OpRemoveChild()) OpRemoveChild((aOther).get_OpRemoveChild());
            break;
        }
    case TOpRepositionChild:
        {
            new (mozilla::KnownNotNull, ptr_OpRepositionChild()) OpRepositionChild((aOther).get_OpRepositionChild());
            break;
        }
    case TOpRaiseToTopChild:
        {
            new (mozilla::KnownNotNull, ptr_OpRaiseToTopChild()) OpRaiseToTopChild((aOther).get_OpRaiseToTopChild());
            break;
        }
    case TOpAttachCompositable:
        {
            new (mozilla::KnownNotNull, ptr_OpAttachCompositable()) OpAttachCompositable((aOther).get_OpAttachCompositable());
            break;
        }
    case TOpAttachAsyncCompositable:
        {
            new (mozilla::KnownNotNull, ptr_OpAttachAsyncCompositable()) OpAttachAsyncCompositable((aOther).get_OpAttachAsyncCompositable());
            break;
        }
    case TCompositableOperation:
        {
            new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation((aOther).get_CompositableOperation());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT Edit::Edit(Edit&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TOpCreatePaintedLayer:
        {
            new (mozilla::KnownNotNull, ptr_OpCreatePaintedLayer()) OpCreatePaintedLayer(std::move((aOther).get_OpCreatePaintedLayer()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpCreateContainerLayer:
        {
            new (mozilla::KnownNotNull, ptr_OpCreateContainerLayer()) OpCreateContainerLayer(std::move((aOther).get_OpCreateContainerLayer()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpCreateImageLayer:
        {
            new (mozilla::KnownNotNull, ptr_OpCreateImageLayer()) OpCreateImageLayer(std::move((aOther).get_OpCreateImageLayer()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpCreateColorLayer:
        {
            new (mozilla::KnownNotNull, ptr_OpCreateColorLayer()) OpCreateColorLayer(std::move((aOther).get_OpCreateColorLayer()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpCreateCanvasLayer:
        {
            new (mozilla::KnownNotNull, ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer(std::move((aOther).get_OpCreateCanvasLayer()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpCreateRefLayer:
        {
            new (mozilla::KnownNotNull, ptr_OpCreateRefLayer()) OpCreateRefLayer(std::move((aOther).get_OpCreateRefLayer()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpSetDiagnosticTypes:
        {
            new (mozilla::KnownNotNull, ptr_OpSetDiagnosticTypes()) OpSetDiagnosticTypes(std::move((aOther).get_OpSetDiagnosticTypes()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpWindowOverlayChanged:
        {
            new (mozilla::KnownNotNull, ptr_OpWindowOverlayChanged()) OpWindowOverlayChanged(std::move((aOther).get_OpWindowOverlayChanged()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpSetRoot:
        {
            new (mozilla::KnownNotNull, ptr_OpSetRoot()) OpSetRoot(std::move((aOther).get_OpSetRoot()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpInsertAfter:
        {
            new (mozilla::KnownNotNull, ptr_OpInsertAfter()) OpInsertAfter(std::move((aOther).get_OpInsertAfter()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpPrependChild:
        {
            new (mozilla::KnownNotNull, ptr_OpPrependChild()) OpPrependChild(std::move((aOther).get_OpPrependChild()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpRemoveChild:
        {
            new (mozilla::KnownNotNull, ptr_OpRemoveChild()) OpRemoveChild(std::move((aOther).get_OpRemoveChild()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpRepositionChild:
        {
            new (mozilla::KnownNotNull, ptr_OpRepositionChild()) OpRepositionChild(std::move((aOther).get_OpRepositionChild()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpRaiseToTopChild:
        {
            new (mozilla::KnownNotNull, ptr_OpRaiseToTopChild()) OpRaiseToTopChild(std::move((aOther).get_OpRaiseToTopChild()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpAttachCompositable:
        {
            new (mozilla::KnownNotNull, ptr_OpAttachCompositable()) OpAttachCompositable(std::move((aOther).get_OpAttachCompositable()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOpAttachAsyncCompositable:
        {
            new (mozilla::KnownNotNull, ptr_OpAttachAsyncCompositable()) OpAttachAsyncCompositable(std::move((aOther).get_OpAttachAsyncCompositable()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TCompositableOperation:
        {
            new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation(std::move((aOther).get_CompositableOperation()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto Edit::operator=(const OpCreatePaintedLayer& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpCreatePaintedLayer)) {
        new (mozilla::KnownNotNull, ptr_OpCreatePaintedLayer()) OpCreatePaintedLayer;
    }
    (*(ptr_OpCreatePaintedLayer())) = aRhs;
    mType = TOpCreatePaintedLayer;
    return (*(this));
}

auto Edit::operator=(OpCreatePaintedLayer&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpCreatePaintedLayer)) {
        new (mozilla::KnownNotNull, ptr_OpCreatePaintedLayer()) OpCreatePaintedLayer;
    }
    (*(ptr_OpCreatePaintedLayer())) = std::move(aRhs);
    mType = TOpCreatePaintedLayer;
    return (*(this));
}

auto Edit::operator=(const OpCreateContainerLayer& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpCreateContainerLayer)) {
        new (mozilla::KnownNotNull, ptr_OpCreateContainerLayer()) OpCreateContainerLayer;
    }
    (*(ptr_OpCreateContainerLayer())) = aRhs;
    mType = TOpCreateContainerLayer;
    return (*(this));
}

auto Edit::operator=(OpCreateContainerLayer&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpCreateContainerLayer)) {
        new (mozilla::KnownNotNull, ptr_OpCreateContainerLayer()) OpCreateContainerLayer;
    }
    (*(ptr_OpCreateContainerLayer())) = std::move(aRhs);
    mType = TOpCreateContainerLayer;
    return (*(this));
}

auto Edit::operator=(const OpCreateImageLayer& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpCreateImageLayer)) {
        new (mozilla::KnownNotNull, ptr_OpCreateImageLayer()) OpCreateImageLayer;
    }
    (*(ptr_OpCreateImageLayer())) = aRhs;
    mType = TOpCreateImageLayer;
    return (*(this));
}

auto Edit::operator=(OpCreateImageLayer&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpCreateImageLayer)) {
        new (mozilla::KnownNotNull, ptr_OpCreateImageLayer()) OpCreateImageLayer;
    }
    (*(ptr_OpCreateImageLayer())) = std::move(aRhs);
    mType = TOpCreateImageLayer;
    return (*(this));
}

auto Edit::operator=(const OpCreateColorLayer& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpCreateColorLayer)) {
        new (mozilla::KnownNotNull, ptr_OpCreateColorLayer()) OpCreateColorLayer;
    }
    (*(ptr_OpCreateColorLayer())) = aRhs;
    mType = TOpCreateColorLayer;
    return (*(this));
}

auto Edit::operator=(OpCreateColorLayer&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpCreateColorLayer)) {
        new (mozilla::KnownNotNull, ptr_OpCreateColorLayer()) OpCreateColorLayer;
    }
    (*(ptr_OpCreateColorLayer())) = std::move(aRhs);
    mType = TOpCreateColorLayer;
    return (*(this));
}

auto Edit::operator=(const OpCreateCanvasLayer& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpCreateCanvasLayer)) {
        new (mozilla::KnownNotNull, ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer;
    }
    (*(ptr_OpCreateCanvasLayer())) = aRhs;
    mType = TOpCreateCanvasLayer;
    return (*(this));
}

auto Edit::operator=(OpCreateCanvasLayer&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpCreateCanvasLayer)) {
        new (mozilla::KnownNotNull, ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer;
    }
    (*(ptr_OpCreateCanvasLayer())) = std::move(aRhs);
    mType = TOpCreateCanvasLayer;
    return (*(this));
}

auto Edit::operator=(const OpCreateRefLayer& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpCreateRefLayer)) {
        new (mozilla::KnownNotNull, ptr_OpCreateRefLayer()) OpCreateRefLayer;
    }
    (*(ptr_OpCreateRefLayer())) = aRhs;
    mType = TOpCreateRefLayer;
    return (*(this));
}

auto Edit::operator=(OpCreateRefLayer&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpCreateRefLayer)) {
        new (mozilla::KnownNotNull, ptr_OpCreateRefLayer()) OpCreateRefLayer;
    }
    (*(ptr_OpCreateRefLayer())) = std::move(aRhs);
    mType = TOpCreateRefLayer;
    return (*(this));
}

auto Edit::operator=(const OpSetDiagnosticTypes& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpSetDiagnosticTypes)) {
        new (mozilla::KnownNotNull, ptr_OpSetDiagnosticTypes()) OpSetDiagnosticTypes;
    }
    (*(ptr_OpSetDiagnosticTypes())) = aRhs;
    mType = TOpSetDiagnosticTypes;
    return (*(this));
}

auto Edit::operator=(OpSetDiagnosticTypes&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpSetDiagnosticTypes)) {
        new (mozilla::KnownNotNull, ptr_OpSetDiagnosticTypes()) OpSetDiagnosticTypes;
    }
    (*(ptr_OpSetDiagnosticTypes())) = std::move(aRhs);
    mType = TOpSetDiagnosticTypes;
    return (*(this));
}

auto Edit::operator=(const OpWindowOverlayChanged& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpWindowOverlayChanged)) {
        new (mozilla::KnownNotNull, ptr_OpWindowOverlayChanged()) OpWindowOverlayChanged;
    }
    (*(ptr_OpWindowOverlayChanged())) = aRhs;
    mType = TOpWindowOverlayChanged;
    return (*(this));
}

auto Edit::operator=(OpWindowOverlayChanged&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpWindowOverlayChanged)) {
        new (mozilla::KnownNotNull, ptr_OpWindowOverlayChanged()) OpWindowOverlayChanged;
    }
    (*(ptr_OpWindowOverlayChanged())) = std::move(aRhs);
    mType = TOpWindowOverlayChanged;
    return (*(this));
}

auto Edit::operator=(const OpSetRoot& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpSetRoot)) {
        new (mozilla::KnownNotNull, ptr_OpSetRoot()) OpSetRoot;
    }
    (*(ptr_OpSetRoot())) = aRhs;
    mType = TOpSetRoot;
    return (*(this));
}

auto Edit::operator=(OpSetRoot&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpSetRoot)) {
        new (mozilla::KnownNotNull, ptr_OpSetRoot()) OpSetRoot;
    }
    (*(ptr_OpSetRoot())) = std::move(aRhs);
    mType = TOpSetRoot;
    return (*(this));
}

auto Edit::operator=(const OpInsertAfter& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpInsertAfter)) {
        new (mozilla::KnownNotNull, ptr_OpInsertAfter()) OpInsertAfter;
    }
    (*(ptr_OpInsertAfter())) = aRhs;
    mType = TOpInsertAfter;
    return (*(this));
}

auto Edit::operator=(OpInsertAfter&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpInsertAfter)) {
        new (mozilla::KnownNotNull, ptr_OpInsertAfter()) OpInsertAfter;
    }
    (*(ptr_OpInsertAfter())) = std::move(aRhs);
    mType = TOpInsertAfter;
    return (*(this));
}

auto Edit::operator=(const OpPrependChild& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpPrependChild)) {
        new (mozilla::KnownNotNull, ptr_OpPrependChild()) OpPrependChild;
    }
    (*(ptr_OpPrependChild())) = aRhs;
    mType = TOpPrependChild;
    return (*(this));
}

auto Edit::operator=(OpPrependChild&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpPrependChild)) {
        new (mozilla::KnownNotNull, ptr_OpPrependChild()) OpPrependChild;
    }
    (*(ptr_OpPrependChild())) = std::move(aRhs);
    mType = TOpPrependChild;
    return (*(this));
}

auto Edit::operator=(const OpRemoveChild& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpRemoveChild)) {
        new (mozilla::KnownNotNull, ptr_OpRemoveChild()) OpRemoveChild;
    }
    (*(ptr_OpRemoveChild())) = aRhs;
    mType = TOpRemoveChild;
    return (*(this));
}

auto Edit::operator=(OpRemoveChild&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpRemoveChild)) {
        new (mozilla::KnownNotNull, ptr_OpRemoveChild()) OpRemoveChild;
    }
    (*(ptr_OpRemoveChild())) = std::move(aRhs);
    mType = TOpRemoveChild;
    return (*(this));
}

auto Edit::operator=(const OpRepositionChild& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpRepositionChild)) {
        new (mozilla::KnownNotNull, ptr_OpRepositionChild()) OpRepositionChild;
    }
    (*(ptr_OpRepositionChild())) = aRhs;
    mType = TOpRepositionChild;
    return (*(this));
}

auto Edit::operator=(OpRepositionChild&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpRepositionChild)) {
        new (mozilla::KnownNotNull, ptr_OpRepositionChild()) OpRepositionChild;
    }
    (*(ptr_OpRepositionChild())) = std::move(aRhs);
    mType = TOpRepositionChild;
    return (*(this));
}

auto Edit::operator=(const OpRaiseToTopChild& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpRaiseToTopChild)) {
        new (mozilla::KnownNotNull, ptr_OpRaiseToTopChild()) OpRaiseToTopChild;
    }
    (*(ptr_OpRaiseToTopChild())) = aRhs;
    mType = TOpRaiseToTopChild;
    return (*(this));
}

auto Edit::operator=(OpRaiseToTopChild&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpRaiseToTopChild)) {
        new (mozilla::KnownNotNull, ptr_OpRaiseToTopChild()) OpRaiseToTopChild;
    }
    (*(ptr_OpRaiseToTopChild())) = std::move(aRhs);
    mType = TOpRaiseToTopChild;
    return (*(this));
}

auto Edit::operator=(const OpAttachCompositable& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpAttachCompositable)) {
        new (mozilla::KnownNotNull, ptr_OpAttachCompositable()) OpAttachCompositable;
    }
    (*(ptr_OpAttachCompositable())) = aRhs;
    mType = TOpAttachCompositable;
    return (*(this));
}

auto Edit::operator=(OpAttachCompositable&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpAttachCompositable)) {
        new (mozilla::KnownNotNull, ptr_OpAttachCompositable()) OpAttachCompositable;
    }
    (*(ptr_OpAttachCompositable())) = std::move(aRhs);
    mType = TOpAttachCompositable;
    return (*(this));
}

auto Edit::operator=(const OpAttachAsyncCompositable& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpAttachAsyncCompositable)) {
        new (mozilla::KnownNotNull, ptr_OpAttachAsyncCompositable()) OpAttachAsyncCompositable;
    }
    (*(ptr_OpAttachAsyncCompositable())) = aRhs;
    mType = TOpAttachAsyncCompositable;
    return (*(this));
}

auto Edit::operator=(OpAttachAsyncCompositable&& aRhs) -> Edit&
{
    if (MaybeDestroy(TOpAttachAsyncCompositable)) {
        new (mozilla::KnownNotNull, ptr_OpAttachAsyncCompositable()) OpAttachAsyncCompositable;
    }
    (*(ptr_OpAttachAsyncCompositable())) = std::move(aRhs);
    mType = TOpAttachAsyncCompositable;
    return (*(this));
}

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

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

auto Edit::operator=(const Edit& aRhs) -> Edit&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TOpCreatePaintedLayer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpCreatePaintedLayer()) OpCreatePaintedLayer;
            }
            (*(ptr_OpCreatePaintedLayer())) = (aRhs).get_OpCreatePaintedLayer();
            break;
        }
    case TOpCreateContainerLayer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpCreateContainerLayer()) OpCreateContainerLayer;
            }
            (*(ptr_OpCreateContainerLayer())) = (aRhs).get_OpCreateContainerLayer();
            break;
        }
    case TOpCreateImageLayer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpCreateImageLayer()) OpCreateImageLayer;
            }
            (*(ptr_OpCreateImageLayer())) = (aRhs).get_OpCreateImageLayer();
            break;
        }
    case TOpCreateColorLayer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpCreateColorLayer()) OpCreateColorLayer;
            }
            (*(ptr_OpCreateColorLayer())) = (aRhs).get_OpCreateColorLayer();
            break;
        }
    case TOpCreateCanvasLayer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer;
            }
            (*(ptr_OpCreateCanvasLayer())) = (aRhs).get_OpCreateCanvasLayer();
            break;
        }
    case TOpCreateRefLayer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpCreateRefLayer()) OpCreateRefLayer;
            }
            (*(ptr_OpCreateRefLayer())) = (aRhs).get_OpCreateRefLayer();
            break;
        }
    case TOpSetDiagnosticTypes:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpSetDiagnosticTypes()) OpSetDiagnosticTypes;
            }
            (*(ptr_OpSetDiagnosticTypes())) = (aRhs).get_OpSetDiagnosticTypes();
            break;
        }
    case TOpWindowOverlayChanged:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpWindowOverlayChanged()) OpWindowOverlayChanged;
            }
            (*(ptr_OpWindowOverlayChanged())) = (aRhs).get_OpWindowOverlayChanged();
            break;
        }
    case TOpSetRoot:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpSetRoot()) OpSetRoot;
            }
            (*(ptr_OpSetRoot())) = (aRhs).get_OpSetRoot();
            break;
        }
    case TOpInsertAfter:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpInsertAfter()) OpInsertAfter;
            }
            (*(ptr_OpInsertAfter())) = (aRhs).get_OpInsertAfter();
            break;
        }
    case TOpPrependChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpPrependChild()) OpPrependChild;
            }
            (*(ptr_OpPrependChild())) = (aRhs).get_OpPrependChild();
            break;
        }
    case TOpRemoveChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpRemoveChild()) OpRemoveChild;
            }
            (*(ptr_OpRemoveChild())) = (aRhs).get_OpRemoveChild();
            break;
        }
    case TOpRepositionChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpRepositionChild()) OpRepositionChild;
            }
            (*(ptr_OpRepositionChild())) = (aRhs).get_OpRepositionChild();
            break;
        }
    case TOpRaiseToTopChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpRaiseToTopChild()) OpRaiseToTopChild;
            }
            (*(ptr_OpRaiseToTopChild())) = (aRhs).get_OpRaiseToTopChild();
            break;
        }
    case TOpAttachCompositable:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAttachCompositable()) OpAttachCompositable;
            }
            (*(ptr_OpAttachCompositable())) = (aRhs).get_OpAttachCompositable();
            break;
        }
    case TOpAttachAsyncCompositable:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAttachAsyncCompositable()) OpAttachAsyncCompositable;
            }
            (*(ptr_OpAttachAsyncCompositable())) = (aRhs).get_OpAttachAsyncCompositable();
            break;
        }
    case TCompositableOperation:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation;
            }
            (*(ptr_CompositableOperation())) = (aRhs).get_CompositableOperation();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto Edit::operator=(Edit&& aRhs) -> Edit&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TOpCreatePaintedLayer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpCreatePaintedLayer()) OpCreatePaintedLayer;
            }
            (*(ptr_OpCreatePaintedLayer())) = std::move((aRhs).get_OpCreatePaintedLayer());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpCreateContainerLayer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpCreateContainerLayer()) OpCreateContainerLayer;
            }
            (*(ptr_OpCreateContainerLayer())) = std::move((aRhs).get_OpCreateContainerLayer());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpCreateImageLayer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpCreateImageLayer()) OpCreateImageLayer;
            }
            (*(ptr_OpCreateImageLayer())) = std::move((aRhs).get_OpCreateImageLayer());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpCreateColorLayer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpCreateColorLayer()) OpCreateColorLayer;
            }
            (*(ptr_OpCreateColorLayer())) = std::move((aRhs).get_OpCreateColorLayer());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpCreateCanvasLayer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer;
            }
            (*(ptr_OpCreateCanvasLayer())) = std::move((aRhs).get_OpCreateCanvasLayer());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpCreateRefLayer:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpCreateRefLayer()) OpCreateRefLayer;
            }
            (*(ptr_OpCreateRefLayer())) = std::move((aRhs).get_OpCreateRefLayer());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpSetDiagnosticTypes:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpSetDiagnosticTypes()) OpSetDiagnosticTypes;
            }
            (*(ptr_OpSetDiagnosticTypes())) = std::move((aRhs).get_OpSetDiagnosticTypes());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpWindowOverlayChanged:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpWindowOverlayChanged()) OpWindowOverlayChanged;
            }
            (*(ptr_OpWindowOverlayChanged())) = std::move((aRhs).get_OpWindowOverlayChanged());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpSetRoot:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpSetRoot()) OpSetRoot;
            }
            (*(ptr_OpSetRoot())) = std::move((aRhs).get_OpSetRoot());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpInsertAfter:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpInsertAfter()) OpInsertAfter;
            }
            (*(ptr_OpInsertAfter())) = std::move((aRhs).get_OpInsertAfter());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpPrependChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpPrependChild()) OpPrependChild;
            }
            (*(ptr_OpPrependChild())) = std::move((aRhs).get_OpPrependChild());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpRemoveChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpRemoveChild()) OpRemoveChild;
            }
            (*(ptr_OpRemoveChild())) = std::move((aRhs).get_OpRemoveChild());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpRepositionChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpRepositionChild()) OpRepositionChild;
            }
            (*(ptr_OpRepositionChild())) = std::move((aRhs).get_OpRepositionChild());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpRaiseToTopChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpRaiseToTopChild()) OpRaiseToTopChild;
            }
            (*(ptr_OpRaiseToTopChild())) = std::move((aRhs).get_OpRaiseToTopChild());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpAttachCompositable:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAttachCompositable()) OpAttachCompositable;
            }
            (*(ptr_OpAttachCompositable())) = std::move((aRhs).get_OpAttachCompositable());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOpAttachAsyncCompositable:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpAttachAsyncCompositable()) OpAttachAsyncCompositable;
            }
            (*(ptr_OpAttachAsyncCompositable())) = std::move((aRhs).get_OpAttachAsyncCompositable());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TCompositableOperation:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation;
            }
            (*(ptr_CompositableOperation())) = std::move((aRhs).get_CompositableOperation());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto Edit::operator==(const OpCreatePaintedLayer& aRhs) const -> bool
{
    return (get_OpCreatePaintedLayer()) == (aRhs);
}

auto Edit::operator==(const OpCreateContainerLayer& aRhs) const -> bool
{
    return (get_OpCreateContainerLayer()) == (aRhs);
}

auto Edit::operator==(const OpCreateImageLayer& aRhs) const -> bool
{
    return (get_OpCreateImageLayer()) == (aRhs);
}

auto Edit::operator==(const OpCreateColorLayer& aRhs) const -> bool
{
    return (get_OpCreateColorLayer()) == (aRhs);
}

auto Edit::operator==(const OpCreateCanvasLayer& aRhs) const -> bool
{
    return (get_OpCreateCanvasLayer()) == (aRhs);
}

auto Edit::operator==(const OpCreateRefLayer& aRhs) const -> bool
{
    return (get_OpCreateRefLayer()) == (aRhs);
}

auto Edit::operator==(const OpSetDiagnosticTypes& aRhs) const -> bool
{
    return (get_OpSetDiagnosticTypes()) == (aRhs);
}

auto Edit::operator==(const OpWindowOverlayChanged& aRhs) const -> bool
{
    return (get_OpWindowOverlayChanged()) == (aRhs);
}

auto Edit::operator==(const OpSetRoot& aRhs) const -> bool
{
    return (get_OpSetRoot()) == (aRhs);
}

auto Edit::operator==(const OpInsertAfter& aRhs) const -> bool
{
    return (get_OpInsertAfter()) == (aRhs);
}

auto Edit::operator==(const OpPrependChild& aRhs) const -> bool
{
    return (get_OpPrependChild()) == (aRhs);
}

auto Edit::operator==(const OpRemoveChild& aRhs) const -> bool
{
    return (get_OpRemoveChild()) == (aRhs);
}

auto Edit::operator==(const OpRepositionChild& aRhs) const -> bool
{
    return (get_OpRepositionChild()) == (aRhs);
}

auto Edit::operator==(const OpRaiseToTopChild& aRhs) const -> bool
{
    return (get_OpRaiseToTopChild()) == (aRhs);
}

auto Edit::operator==(const OpAttachCompositable& aRhs) const -> bool
{
    return (get_OpAttachCompositable()) == (aRhs);
}

auto Edit::operator==(const OpAttachAsyncCompositable& aRhs) const -> bool
{
    return (get_OpAttachAsyncCompositable()) == (aRhs);
}

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

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

    switch (type()) {
    case TOpCreatePaintedLayer:
        {
            return (get_OpCreatePaintedLayer()) == ((aRhs).get_OpCreatePaintedLayer());
        }
    case TOpCreateContainerLayer:
        {
            return (get_OpCreateContainerLayer()) == ((aRhs).get_OpCreateContainerLayer());
        }
    case TOpCreateImageLayer:
        {
            return (get_OpCreateImageLayer()) == ((aRhs).get_OpCreateImageLayer());
        }
    case TOpCreateColorLayer:
        {
            return (get_OpCreateColorLayer()) == ((aRhs).get_OpCreateColorLayer());
        }
    case TOpCreateCanvasLayer:
        {
            return (get_OpCreateCanvasLayer()) == ((aRhs).get_OpCreateCanvasLayer());
        }
    case TOpCreateRefLayer:
        {
            return (get_OpCreateRefLayer()) == ((aRhs).get_OpCreateRefLayer());
        }
    case TOpSetDiagnosticTypes:
        {
            return (get_OpSetDiagnosticTypes()) == ((aRhs).get_OpSetDiagnosticTypes());
        }
    case TOpWindowOverlayChanged:
        {
            return (get_OpWindowOverlayChanged()) == ((aRhs).get_OpWindowOverlayChanged());
        }
    case TOpSetRoot:
        {
            return (get_OpSetRoot()) == ((aRhs).get_OpSetRoot());
        }
    case TOpInsertAfter:
        {
            return (get_OpInsertAfter()) == ((aRhs).get_OpInsertAfter());
        }
    case TOpPrependChild:
        {
            return (get_OpPrependChild()) == ((aRhs).get_OpPrependChild());
        }
    case TOpRemoveChild:
        {
            return (get_OpRemoveChild()) == ((aRhs).get_OpRemoveChild());
        }
    case TOpRepositionChild:
        {
            return (get_OpRepositionChild()) == ((aRhs).get_OpRepositionChild());
        }
    case TOpRaiseToTopChild:
        {
            return (get_OpRaiseToTopChild()) == ((aRhs).get_OpRaiseToTopChild());
        }
    case TOpAttachCompositable:
        {
            return (get_OpAttachCompositable()) == ((aRhs).get_OpAttachCompositable());
        }
    case TOpAttachAsyncCompositable:
        {
            return (get_OpAttachAsyncCompositable()) == ((aRhs).get_OpAttachAsyncCompositable());
        }
    case TCompositableOperation:
        {
            return (get_CompositableOperation()) == ((aRhs).get_CompositableOperation());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto Edit::get(OpCreatePaintedLayer* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpCreatePaintedLayer();
}

auto Edit::get(OpCreateContainerLayer* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpCreateContainerLayer();
}

auto Edit::get(OpCreateImageLayer* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpCreateImageLayer();
}

auto Edit::get(OpCreateColorLayer* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpCreateColorLayer();
}

auto Edit::get(OpCreateCanvasLayer* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpCreateCanvasLayer();
}

auto Edit::get(OpCreateRefLayer* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpCreateRefLayer();
}

auto Edit::get(OpSetDiagnosticTypes* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpSetDiagnosticTypes();
}

auto Edit::get(OpWindowOverlayChanged* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpWindowOverlayChanged();
}

auto Edit::get(OpSetRoot* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpSetRoot();
}

auto Edit::get(OpInsertAfter* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpInsertAfter();
}

auto Edit::get(OpPrependChild* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpPrependChild();
}

auto Edit::get(OpRemoveChild* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpRemoveChild();
}

auto Edit::get(OpRepositionChild* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpRepositionChild();
}

auto Edit::get(OpRaiseToTopChild* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpRaiseToTopChild();
}

auto Edit::get(OpAttachCompositable* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpAttachCompositable();
}

auto Edit::get(OpAttachAsyncCompositable* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpAttachAsyncCompositable();
}

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

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TOpCreatePaintedLayer:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpCreatePaintedLayer());
            // Sentinel = 'TOpCreatePaintedLayer'
            (aMsg)->WriteSentinel(3853495226);
            return;
        }
    case union__::TOpCreateContainerLayer:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpCreateContainerLayer());
            // Sentinel = 'TOpCreateContainerLayer'
            (aMsg)->WriteSentinel(1810998542);
            return;
        }
    case union__::TOpCreateImageLayer:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpCreateImageLayer());
            // Sentinel = 'TOpCreateImageLayer'
            (aMsg)->WriteSentinel(3556379108);
            return;
        }
    case union__::TOpCreateColorLayer:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpCreateColorLayer());
            // Sentinel = 'TOpCreateColorLayer'
            (aMsg)->WriteSentinel(1657969326);
            return;
        }
    case union__::TOpCreateCanvasLayer:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpCreateCanvasLayer());
            // Sentinel = 'TOpCreateCanvasLayer'
            (aMsg)->WriteSentinel(156843276);
            return;
        }
    case union__::TOpCreateRefLayer:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpCreateRefLayer());
            // Sentinel = 'TOpCreateRefLayer'
            (aMsg)->WriteSentinel(1988949338);
            return;
        }
    case union__::TOpSetDiagnosticTypes:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpSetDiagnosticTypes());
            // Sentinel = 'TOpSetDiagnosticTypes'
            (aMsg)->WriteSentinel(2447105948);
            return;
        }
    case union__::TOpWindowOverlayChanged:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpWindowOverlayChanged());
            // Sentinel = 'TOpWindowOverlayChanged'
            (aMsg)->WriteSentinel(3466220546);
            return;
        }
    case union__::TOpSetRoot:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpSetRoot());
            // Sentinel = 'TOpSetRoot'
            (aMsg)->WriteSentinel(2410055009);
            return;
        }
    case union__::TOpInsertAfter:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpInsertAfter());
            // Sentinel = 'TOpInsertAfter'
            (aMsg)->WriteSentinel(1382649822);
            return;
        }
    case union__::TOpPrependChild:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpPrependChild());
            // Sentinel = 'TOpPrependChild'
            (aMsg)->WriteSentinel(444055092);
            return;
        }
    case union__::TOpRemoveChild:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpRemoveChild());
            // Sentinel = 'TOpRemoveChild'
            (aMsg)->WriteSentinel(2988995859);
            return;
        }
    case union__::TOpRepositionChild:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpRepositionChild());
            // Sentinel = 'TOpRepositionChild'
            (aMsg)->WriteSentinel(2467889549);
            return;
        }
    case union__::TOpRaiseToTopChild:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpRaiseToTopChild());
            // Sentinel = 'TOpRaiseToTopChild'
            (aMsg)->WriteSentinel(2024445967);
            return;
        }
    case union__::TOpAttachCompositable:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpAttachCompositable());
            // Sentinel = 'TOpAttachCompositable'
            (aMsg)->WriteSentinel(1767933903);
            return;
        }
    case union__::TOpAttachAsyncCompositable:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpAttachAsyncCompositable());
            // Sentinel = 'TOpAttachAsyncCompositable'
            (aMsg)->WriteSentinel(4011154988);
            return;
        }
    case union__::TCompositableOperation:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_CompositableOperation());
            // Sentinel = 'TCompositableOperation'
            (aMsg)->WriteSentinel(1903999853);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TOpCreatePaintedLayer:
        {
            mozilla::layers::OpCreatePaintedLayer tmp = mozilla::layers::OpCreatePaintedLayer();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpCreatePaintedLayer())))))) {
                (aActor)->FatalError("Error deserializing variant TOpCreatePaintedLayer of union Edit");
                return false;
            }
            // Sentinel = 'TOpCreatePaintedLayer'
            if ((!((aMsg)->ReadSentinel(aIter, 3853495226)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpCreatePaintedLayer of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpCreateContainerLayer:
        {
            mozilla::layers::OpCreateContainerLayer tmp = mozilla::layers::OpCreateContainerLayer();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpCreateContainerLayer())))))) {
                (aActor)->FatalError("Error deserializing variant TOpCreateContainerLayer of union Edit");
                return false;
            }
            // Sentinel = 'TOpCreateContainerLayer'
            if ((!((aMsg)->ReadSentinel(aIter, 1810998542)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpCreateContainerLayer of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpCreateImageLayer:
        {
            mozilla::layers::OpCreateImageLayer tmp = mozilla::layers::OpCreateImageLayer();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpCreateImageLayer())))))) {
                (aActor)->FatalError("Error deserializing variant TOpCreateImageLayer of union Edit");
                return false;
            }
            // Sentinel = 'TOpCreateImageLayer'
            if ((!((aMsg)->ReadSentinel(aIter, 3556379108)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpCreateImageLayer of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpCreateColorLayer:
        {
            mozilla::layers::OpCreateColorLayer tmp = mozilla::layers::OpCreateColorLayer();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpCreateColorLayer())))))) {
                (aActor)->FatalError("Error deserializing variant TOpCreateColorLayer of union Edit");
                return false;
            }
            // Sentinel = 'TOpCreateColorLayer'
            if ((!((aMsg)->ReadSentinel(aIter, 1657969326)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpCreateColorLayer of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpCreateCanvasLayer:
        {
            mozilla::layers::OpCreateCanvasLayer tmp = mozilla::layers::OpCreateCanvasLayer();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpCreateCanvasLayer())))))) {
                (aActor)->FatalError("Error deserializing variant TOpCreateCanvasLayer of union Edit");
                return false;
            }
            // Sentinel = 'TOpCreateCanvasLayer'
            if ((!((aMsg)->ReadSentinel(aIter, 156843276)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpCreateCanvasLayer of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpCreateRefLayer:
        {
            mozilla::layers::OpCreateRefLayer tmp = mozilla::layers::OpCreateRefLayer();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpCreateRefLayer())))))) {
                (aActor)->FatalError("Error deserializing variant TOpCreateRefLayer of union Edit");
                return false;
            }
            // Sentinel = 'TOpCreateRefLayer'
            if ((!((aMsg)->ReadSentinel(aIter, 1988949338)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpCreateRefLayer of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpSetDiagnosticTypes:
        {
            mozilla::layers::OpSetDiagnosticTypes tmp = mozilla::layers::OpSetDiagnosticTypes();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpSetDiagnosticTypes())))))) {
                (aActor)->FatalError("Error deserializing variant TOpSetDiagnosticTypes of union Edit");
                return false;
            }
            // Sentinel = 'TOpSetDiagnosticTypes'
            if ((!((aMsg)->ReadSentinel(aIter, 2447105948)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpSetDiagnosticTypes of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpWindowOverlayChanged:
        {
            mozilla::layers::OpWindowOverlayChanged tmp = mozilla::layers::OpWindowOverlayChanged();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpWindowOverlayChanged())))))) {
                (aActor)->FatalError("Error deserializing variant TOpWindowOverlayChanged of union Edit");
                return false;
            }
            // Sentinel = 'TOpWindowOverlayChanged'
            if ((!((aMsg)->ReadSentinel(aIter, 3466220546)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpWindowOverlayChanged of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpSetRoot:
        {
            mozilla::layers::OpSetRoot tmp = mozilla::layers::OpSetRoot();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpSetRoot())))))) {
                (aActor)->FatalError("Error deserializing variant TOpSetRoot of union Edit");
                return false;
            }
            // Sentinel = 'TOpSetRoot'
            if ((!((aMsg)->ReadSentinel(aIter, 2410055009)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpSetRoot of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpInsertAfter:
        {
            mozilla::layers::OpInsertAfter tmp = mozilla::layers::OpInsertAfter();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpInsertAfter())))))) {
                (aActor)->FatalError("Error deserializing variant TOpInsertAfter of union Edit");
                return false;
            }
            // Sentinel = 'TOpInsertAfter'
            if ((!((aMsg)->ReadSentinel(aIter, 1382649822)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpInsertAfter of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpPrependChild:
        {
            mozilla::layers::OpPrependChild tmp = mozilla::layers::OpPrependChild();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpPrependChild())))))) {
                (aActor)->FatalError("Error deserializing variant TOpPrependChild of union Edit");
                return false;
            }
            // Sentinel = 'TOpPrependChild'
            if ((!((aMsg)->ReadSentinel(aIter, 444055092)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpPrependChild of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpRemoveChild:
        {
            mozilla::layers::OpRemoveChild tmp = mozilla::layers::OpRemoveChild();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpRemoveChild())))))) {
                (aActor)->FatalError("Error deserializing variant TOpRemoveChild of union Edit");
                return false;
            }
            // Sentinel = 'TOpRemoveChild'
            if ((!((aMsg)->ReadSentinel(aIter, 2988995859)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpRemoveChild of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpRepositionChild:
        {
            mozilla::layers::OpRepositionChild tmp = mozilla::layers::OpRepositionChild();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpRepositionChild())))))) {
                (aActor)->FatalError("Error deserializing variant TOpRepositionChild of union Edit");
                return false;
            }
            // Sentinel = 'TOpRepositionChild'
            if ((!((aMsg)->ReadSentinel(aIter, 2467889549)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpRepositionChild of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpRaiseToTopChild:
        {
            mozilla::layers::OpRaiseToTopChild tmp = mozilla::layers::OpRaiseToTopChild();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpRaiseToTopChild())))))) {
                (aActor)->FatalError("Error deserializing variant TOpRaiseToTopChild of union Edit");
                return false;
            }
            // Sentinel = 'TOpRaiseToTopChild'
            if ((!((aMsg)->ReadSentinel(aIter, 2024445967)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpRaiseToTopChild of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpAttachCompositable:
        {
            mozilla::layers::OpAttachCompositable tmp = mozilla::layers::OpAttachCompositable();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpAttachCompositable())))))) {
                (aActor)->FatalError("Error deserializing variant TOpAttachCompositable of union Edit");
                return false;
            }
            // Sentinel = 'TOpAttachCompositable'
            if ((!((aMsg)->ReadSentinel(aIter, 1767933903)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpAttachCompositable of union Edit");
                return false;
            }
            return true;
        }
    case union__::TOpAttachAsyncCompositable:
        {
            mozilla::layers::OpAttachAsyncCompositable tmp = mozilla::layers::OpAttachAsyncCompositable();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpAttachAsyncCompositable())))))) {
                (aActor)->FatalError("Error deserializing variant TOpAttachAsyncCompositable of union Edit");
                return false;
            }
            // Sentinel = 'TOpAttachAsyncCompositable'
            if ((!((aMsg)->ReadSentinel(aIter, 4011154988)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpAttachAsyncCompositable of union Edit");
                return false;
            }
            return true;
        }
    case union__::TCompositableOperation:
        {
            mozilla::layers::CompositableOperation tmp = mozilla::layers::CompositableOperation();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_CompositableOperation())))))) {
                (aActor)->FatalError("Error deserializing variant TCompositableOperation of union Edit");
                return false;
            }
            // Sentinel = 'TCompositableOperation'
            if ((!((aMsg)->ReadSentinel(aIter, 1903999853)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCompositableOperation of union Edit");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union OpDestroy|
//
namespace mozilla {
namespace layers {
auto OpDestroy::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TPTextureParent:
        {
            (ptr_PTextureParent())->~PTextureParent__tdef();
            break;
        }
    case TPTextureChild:
        {
            (ptr_PTextureChild())->~PTextureChild__tdef();
            break;
        }
    case TCompositableHandle:
        {
            (ptr_CompositableHandle())->~CompositableHandle__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT OpDestroy::OpDestroy(PTextureParent* aOther)
{
    new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*(const_cast<PTextureParent*>(aOther));
    mType = TPTextureParent;
}

MOZ_IMPLICIT OpDestroy::OpDestroy(PTextureChild* aOther)
{
    new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*(const_cast<PTextureChild*>(aOther));
    mType = TPTextureChild;
}

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 TPTextureParent:
        {
            new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*(const_cast<PTextureParent*>((aOther).get_PTextureParent()));
            break;
        }
    case TPTextureChild:
        {
            new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*(const_cast<PTextureChild*>((aOther).get_PTextureChild()));
            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 TPTextureParent:
        {
            new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*(const_cast<PTextureParent*>(std::move((aOther).get_PTextureParent())));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPTextureChild:
        {
            new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*(const_cast<PTextureChild*>(std::move((aOther).get_PTextureChild())));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TCompositableHandle:
        {
            new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle(std::move((aOther).get_CompositableHandle()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto OpDestroy::operator=(PTextureParent* aRhs) -> OpDestroy&
{
    if (MaybeDestroy(TPTextureParent)) {
        new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*;
    }
    (*(ptr_PTextureParent())) = const_cast<PTextureParent*>(aRhs);
    mType = TPTextureParent;
    return (*(this));
}

auto OpDestroy::operator=(PTextureChild* aRhs) -> OpDestroy&
{
    if (MaybeDestroy(TPTextureChild)) {
        new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*;
    }
    (*(ptr_PTextureChild())) = const_cast<PTextureChild*>(aRhs);
    mType = TPTextureChild;
    return (*(this));
}

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

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

auto OpDestroy::operator=(const OpDestroy& aRhs) -> OpDestroy&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TPTextureParent:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*;
            }
            (*(ptr_PTextureParent())) = const_cast<PTextureParent*>((aRhs).get_PTextureParent());
            break;
        }
    case TPTextureChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*;
            }
            (*(ptr_PTextureChild())) = const_cast<PTextureChild*>((aRhs).get_PTextureChild());
            break;
        }
    case TCompositableHandle:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle;
            }
            (*(ptr_CompositableHandle())) = (aRhs).get_CompositableHandle();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            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 TPTextureParent:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*;
            }
            (*(ptr_PTextureParent())) = const_cast<PTextureParent*>(std::move((aRhs).get_PTextureParent()));
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPTextureChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*;
            }
            (*(ptr_PTextureChild())) = const_cast<PTextureChild*>(std::move((aRhs).get_PTextureChild()));
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TCompositableHandle:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle;
            }
            (*(ptr_CompositableHandle())) = std::move((aRhs).get_CompositableHandle());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto OpDestroy::operator==(PTextureParent* aRhs) const -> bool
{
    return (get_PTextureParent()) == (aRhs);
}

auto OpDestroy::operator==(PTextureChild* aRhs) const -> bool
{
    return (get_PTextureChild()) == (aRhs);
}

auto OpDestroy::operator==(const CompositableHandle& aRhs) const -> bool
{
    return (get_CompositableHandle()) == (aRhs);
}

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

    switch (type()) {
    case TPTextureParent:
        {
            return (get_PTextureParent()) == ((aRhs).get_PTextureParent());
        }
    case TPTextureChild:
        {
            return (get_PTextureChild()) == ((aRhs).get_PTextureChild());
        }
    case TCompositableHandle:
        {
            return (get_CompositableHandle()) == ((aRhs).get_CompositableHandle());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto OpDestroy::get(PTextureParent** aOutValue) const -> void
{
    (*(aOutValue)) = get_PTextureParent();
}

auto OpDestroy::get(PTextureChild** aOutValue) const -> void
{
    (*(aOutValue)) = get_PTextureChild();
}

auto OpDestroy::get(CompositableHandle* aOutValue) const -> void
{
    (*(aOutValue)) = get_CompositableHandle();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TPTextureParent:
        {
            if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
                MOZ_RELEASE_ASSERT((aVar).get_PTextureParent(), "NULL actor value passed to non-nullable param");
                WriteIPDLParam(aMsg, aActor, (aVar).get_PTextureParent());
                // Sentinel = 'TPTextureParent'
                (aMsg)->WriteSentinel(896696938);
            }
            else {
                (aActor)->FatalError("wrong side!");
            }
            return;
        }
    case union__::TPTextureChild:
        {
            if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
                MOZ_RELEASE_ASSERT((aVar).get_PTextureChild(), "NULL actor value passed to non-nullable param");
                WriteIPDLParam(aMsg, aActor, (aVar).get_PTextureChild());
                // Sentinel = 'TPTextureChild'
                (aMsg)->WriteSentinel(3251900187);
            }
            else {
                (aActor)->FatalError("wrong side!");
            }
            return;
        }
    case union__::TCompositableHandle:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_CompositableHandle());
            // Sentinel = 'TCompositableHandle'
            (aMsg)->WriteSentinel(4258010777);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TPTextureParent:
        {
            if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
                {
                    (aActor)->FatalError("wrong side!");
                    return false;
                }
            }
            mozilla::layers::PTextureChild* tmp = nullptr;
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PTextureChild())))))) {
                (aActor)->FatalError("Error deserializing variant TPTextureParent of union OpDestroy");
                return false;
            }
            if ((!((*((&((aVar)->get_PTextureChild()))))))) {
                (aActor)->FatalError("Error deserializing variant TPTextureParent of union OpDestroy");
                return false;
            }
            // Sentinel = 'TPTextureParent'
            if ((!((aMsg)->ReadSentinel(aIter, 896696938)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPTextureParent of union OpDestroy");
                return false;
            }
            return true;
        }
    case union__::TPTextureChild:
        {
            if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
                {
                    (aActor)->FatalError("wrong side!");
                    return false;
                }
            }
            mozilla::layers::PTextureParent* tmp = nullptr;
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PTextureParent())))))) {
                (aActor)->FatalError("Error deserializing variant TPTextureChild of union OpDestroy");
                return false;
            }
            if ((!((*((&((aVar)->get_PTextureParent()))))))) {
                (aActor)->FatalError("Error deserializing variant TPTextureChild of union OpDestroy");
                return false;
            }
            // Sentinel = 'TPTextureChild'
            if ((!((aMsg)->ReadSentinel(aIter, 3251900187)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPTextureChild of union OpDestroy");
                return false;
            }
            return true;
        }
    case union__::TCompositableHandle:
        {
            mozilla::layers::CompositableHandle tmp = mozilla::layers::CompositableHandle();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_CompositableHandle())))))) {
                (aActor)->FatalError("Error deserializing variant TCompositableHandle of union OpDestroy");
                return false;
            }
            // Sentinel = 'TCompositableHandle'
            if ((!((aMsg)->ReadSentinel(aIter, 4258010777)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCompositableHandle of union OpDestroy");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::ImageCompositeNotification>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).compositable());
    // Sentinel = 'compositable'
    (aMsg)->WriteSentinel(4031958248);
    WriteIPDLParam(aMsg, aActor, (aVar).imageTimeStamp());
    // Sentinel = 'imageTimeStamp'
    (aMsg)->WriteSentinel(1759084471);
    WriteIPDLParam(aMsg, aActor, (aVar).firstCompositeTimeStamp());
    // Sentinel = 'firstCompositeTimeStamp'
    (aMsg)->WriteSentinel(2056815046);
    WriteIPDLParam(aMsg, aActor, (aVar).frameID());
    // Sentinel = 'frameID'
    (aMsg)->WriteSentinel(3054835247);
    WriteIPDLParam(aMsg, aActor, (aVar).producerID());
    // Sentinel = 'producerID'
    (aMsg)->WriteSentinel(1942472743);
}

auto IPDLParamTraits<mozilla::layers::ImageCompositeNotification>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->compositable())))))) {
        (aActor)->FatalError("Error deserializing 'compositable' (CompositableHandle) member of 'ImageCompositeNotification'");
        return false;
    }
    // Sentinel = 'compositable'
    if ((!((aMsg)->ReadSentinel(aIter, 4031958248)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'compositable' (CompositableHandle) member of 'ImageCompositeNotification'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->imageTimeStamp())))))) {
        (aActor)->FatalError("Error deserializing 'imageTimeStamp' (TimeStamp) member of 'ImageCompositeNotification'");
        return false;
    }
    // Sentinel = 'imageTimeStamp'
    if ((!((aMsg)->ReadSentinel(aIter, 1759084471)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'imageTimeStamp' (TimeStamp) member of 'ImageCompositeNotification'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->firstCompositeTimeStamp())))))) {
        (aActor)->FatalError("Error deserializing 'firstCompositeTimeStamp' (TimeStamp) member of 'ImageCompositeNotification'");
        return false;
    }
    // Sentinel = 'firstCompositeTimeStamp'
    if ((!((aMsg)->ReadSentinel(aIter, 2056815046)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'firstCompositeTimeStamp' (TimeStamp) member of 'ImageCompositeNotification'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->frameID())))))) {
        (aActor)->FatalError("Error deserializing 'frameID' (uint32_t) member of 'ImageCompositeNotification'");
        return false;
    }
    // Sentinel = 'frameID'
    if ((!((aMsg)->ReadSentinel(aIter, 3054835247)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'frameID' (uint32_t) member of 'ImageCompositeNotification'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->producerID())))))) {
        (aActor)->FatalError("Error deserializing 'producerID' (uint32_t) member of 'ImageCompositeNotification'");
        return false;
    }
    // Sentinel = 'producerID'
    if ((!((aMsg)->ReadSentinel(aIter, 1942472743)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'producerID' (uint32_t) member of 'ImageCompositeNotification'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

auto AsyncParentMessageData::operator=(OpNotifyNotUsed&& aRhs) -> AsyncParentMessageData&
{
    if (MaybeDestroy(TOpNotifyNotUsed)) {
        new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed;
    }
    (*(ptr_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:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed;
            }
            (*(ptr_OpNotifyNotUsed())) = (aRhs).get_OpNotifyNotUsed();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            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:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed;
            }
            (*(ptr_OpNotifyNotUsed())) = std::move((aRhs).get_OpNotifyNotUsed());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto AsyncParentMessageData::operator==(const OpNotifyNotUsed& aRhs) const -> bool
{
    return (get_OpNotifyNotUsed()) == (aRhs);
}

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

    switch (type()) {
    case TOpNotifyNotUsed:
        {
            return (get_OpNotifyNotUsed()) == ((aRhs).get_OpNotifyNotUsed());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto AsyncParentMessageData::get(OpNotifyNotUsed* aOutValue) const -> void
{
    (*(aOutValue)) = get_OpNotifyNotUsed();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TOpNotifyNotUsed:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OpNotifyNotUsed());
            // Sentinel = 'TOpNotifyNotUsed'
            (aMsg)->WriteSentinel(2920493638);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TOpNotifyNotUsed:
        {
            mozilla::layers::OpNotifyNotUsed tmp = mozilla::layers::OpNotifyNotUsed();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OpNotifyNotUsed())))))) {
                (aActor)->FatalError("Error deserializing variant TOpNotifyNotUsed of union AsyncParentMessageData");
                return false;
            }
            // Sentinel = 'TOpNotifyNotUsed'
            if ((!((aMsg)->ReadSentinel(aIter, 2920493638)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOpNotifyNotUsed of union AsyncParentMessageData");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct PaintTiming|
//
namespace mozilla {
namespace layers {
auto PaintTiming::operator==(const PaintTiming& _o) const -> bool
{
    if ((!((serializeMs()) == ((_o).serializeMs())))) {
        return false;
    }
    if ((!((sendMs()) == ((_o).sendMs())))) {
        return false;
    }
    if ((!((dlMs()) == ((_o).dlMs())))) {
        return false;
    }
    if ((!((dl2Ms()) == ((_o).dl2Ms())))) {
        return false;
    }
    if ((!((flbMs()) == ((_o).flbMs())))) {
        return false;
    }
    if ((!((rasterMs()) == ((_o).rasterMs())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::PaintTiming>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).serializeMs());
    // Sentinel = 'serializeMs'
    (aMsg)->WriteSentinel(1679155289);
    WriteIPDLParam(aMsg, aActor, (aVar).sendMs());
    // Sentinel = 'sendMs'
    (aMsg)->WriteSentinel(1895220908);
    WriteIPDLParam(aMsg, aActor, (aVar).dlMs());
    // Sentinel = 'dlMs'
    (aMsg)->WriteSentinel(1536357008);
    WriteIPDLParam(aMsg, aActor, (aVar).dl2Ms());
    // Sentinel = 'dl2Ms'
    (aMsg)->WriteSentinel(458752615);
    WriteIPDLParam(aMsg, aActor, (aVar).flbMs());
    // Sentinel = 'flbMs'
    (aMsg)->WriteSentinel(315691481);
    WriteIPDLParam(aMsg, aActor, (aVar).rasterMs());
    // Sentinel = 'rasterMs'
    (aMsg)->WriteSentinel(3876624083);
}

auto IPDLParamTraits<mozilla::layers::PaintTiming>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->serializeMs())))))) {
        (aActor)->FatalError("Error deserializing 'serializeMs' (float) member of 'PaintTiming'");
        return false;
    }
    // Sentinel = 'serializeMs'
    if ((!((aMsg)->ReadSentinel(aIter, 1679155289)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'serializeMs' (float) member of 'PaintTiming'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->sendMs())))))) {
        (aActor)->FatalError("Error deserializing 'sendMs' (float) member of 'PaintTiming'");
        return false;
    }
    // Sentinel = 'sendMs'
    if ((!((aMsg)->ReadSentinel(aIter, 1895220908)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'sendMs' (float) member of 'PaintTiming'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->dlMs())))))) {
        (aActor)->FatalError("Error deserializing 'dlMs' (float) member of 'PaintTiming'");
        return false;
    }
    // Sentinel = 'dlMs'
    if ((!((aMsg)->ReadSentinel(aIter, 1536357008)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'dlMs' (float) member of 'PaintTiming'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->dl2Ms())))))) {
        (aActor)->FatalError("Error deserializing 'dl2Ms' (float) member of 'PaintTiming'");
        return false;
    }
    // Sentinel = 'dl2Ms'
    if ((!((aMsg)->ReadSentinel(aIter, 458752615)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'dl2Ms' (float) member of 'PaintTiming'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->flbMs())))))) {
        (aActor)->FatalError("Error deserializing 'flbMs' (float) member of 'PaintTiming'");
        return false;
    }
    // Sentinel = 'flbMs'
    if ((!((aMsg)->ReadSentinel(aIter, 315691481)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'flbMs' (float) member of 'PaintTiming'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->rasterMs())))))) {
        (aActor)->FatalError("Error deserializing 'rasterMs' (float) member of 'PaintTiming'");
        return false;
    }
    // Sentinel = 'rasterMs'
    if ((!((aMsg)->ReadSentinel(aIter, 3876624083)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'rasterMs' (float) member of 'PaintTiming'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct TransactionInfo|
//
namespace mozilla {
namespace layers {
auto TransactionInfo::operator==(const TransactionInfo& _o) const -> bool
{
    if ((!((cset()) == ((_o).cset())))) {
        return false;
    }
    if ((!((setSimpleAttrs()) == ((_o).setSimpleAttrs())))) {
        return false;
    }
    if ((!((setAttrs()) == ((_o).setAttrs())))) {
        return false;
    }
    if ((!((paints()) == ((_o).paints())))) {
        return false;
    }
    if ((!((toDestroy()) == ((_o).toDestroy())))) {
        return false;
    }
    if ((!((fwdTransactionId()) == ((_o).fwdTransactionId())))) {
        return false;
    }
    if ((!((id()) == ((_o).id())))) {
        return false;
    }
    if ((!((targetConfig()) == ((_o).targetConfig())))) {
        return false;
    }
    if ((!((plugins()) == ((_o).plugins())))) {
        return false;
    }
    if ((!((isFirstPaint()) == ((_o).isFirstPaint())))) {
        return false;
    }
    if ((!((focusTarget()) == ((_o).focusTarget())))) {
        return false;
    }
    if ((!((scheduleComposite()) == ((_o).scheduleComposite())))) {
        return false;
    }
    if ((!((paintSequenceNumber()) == ((_o).paintSequenceNumber())))) {
        return false;
    }
    if ((!((isRepeatTransaction()) == ((_o).isRepeatTransaction())))) {
        return false;
    }
    if ((!((refreshStart()) == ((_o).refreshStart())))) {
        return false;
    }
    if ((!((transactionStart()) == ((_o).transactionStart())))) {
        return false;
    }
    if ((!((fwdTime()) == ((_o).fwdTime())))) {
        return false;
    }
    return true;
}

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::TransactionInfo>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).cset());
    // Sentinel = 'cset'
    (aMsg)->WriteSentinel(1641215409);
    WriteIPDLParam(aMsg, aActor, (aVar).setSimpleAttrs());
    // Sentinel = 'setSimpleAttrs'
    (aMsg)->WriteSentinel(2311501828);
    WriteIPDLParam(aMsg, aActor, (aVar).setAttrs());
    // Sentinel = 'setAttrs'
    (aMsg)->WriteSentinel(1753236472);
    WriteIPDLParam(aMsg, aActor, (aVar).paints());
    // Sentinel = 'paints'
    (aMsg)->WriteSentinel(4193300201);
    WriteIPDLParam(aMsg, aActor, (aVar).toDestroy());
    // Sentinel = 'toDestroy'
    (aMsg)->WriteSentinel(4183172130);
    WriteIPDLParam(aMsg, aActor, (aVar).fwdTransactionId());
    // Sentinel = 'fwdTransactionId'
    (aMsg)->WriteSentinel(2023976742);
    WriteIPDLParam(aMsg, aActor, (aVar).id());
    // Sentinel = 'id'
    (aMsg)->WriteSentinel(2794505629);
    WriteIPDLParam(aMsg, aActor, (aVar).targetConfig());
    // Sentinel = 'targetConfig'
    (aMsg)->WriteSentinel(3027540357);
    WriteIPDLParam(aMsg, aActor, (aVar).plugins());
    // Sentinel = 'plugins'
    (aMsg)->WriteSentinel(2745061527);
    WriteIPDLParam(aMsg, aActor, (aVar).isFirstPaint());
    // Sentinel = 'isFirstPaint'
    (aMsg)->WriteSentinel(3748149138);
    WriteIPDLParam(aMsg, aActor, (aVar).focusTarget());
    // Sentinel = 'focusTarget'
    (aMsg)->WriteSentinel(2511236160);
    WriteIPDLParam(aMsg, aActor, (aVar).scheduleComposite());
    // Sentinel = 'scheduleComposite'
    (aMsg)->WriteSentinel(3730535701);
    WriteIPDLParam(aMsg, aActor, (aVar).paintSequenceNumber());
    // Sentinel = 'paintSequenceNumber'
    (aMsg)->WriteSentinel(3875026487);
    WriteIPDLParam(aMsg, aActor, (aVar).isRepeatTransaction());
    // Sentinel = 'isRepeatTransaction'
    (aMsg)->WriteSentinel(4043798256);
    WriteIPDLParam(aMsg, aActor, (aVar).refreshStart());
    // Sentinel = 'refreshStart'
    (aMsg)->WriteSentinel(3056521935);
    WriteIPDLParam(aMsg, aActor, (aVar).transactionStart());
    // Sentinel = 'transactionStart'
    (aMsg)->WriteSentinel(214152700);
    WriteIPDLParam(aMsg, aActor, (aVar).fwdTime());
    // Sentinel = 'fwdTime'
    (aMsg)->WriteSentinel(1610637679);
}

auto IPDLParamTraits<mozilla::layers::TransactionInfo>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->cset())))))) {
        (aActor)->FatalError("Error deserializing 'cset' (Edit[]) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'cset'
    if ((!((aMsg)->ReadSentinel(aIter, 1641215409)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cset' (Edit[]) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->setSimpleAttrs())))))) {
        (aActor)->FatalError("Error deserializing 'setSimpleAttrs' (OpSetSimpleLayerAttributes[]) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'setSimpleAttrs'
    if ((!((aMsg)->ReadSentinel(aIter, 2311501828)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'setSimpleAttrs' (OpSetSimpleLayerAttributes[]) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->setAttrs())))))) {
        (aActor)->FatalError("Error deserializing 'setAttrs' (OpSetLayerAttributes[]) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'setAttrs'
    if ((!((aMsg)->ReadSentinel(aIter, 1753236472)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'setAttrs' (OpSetLayerAttributes[]) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->paints())))))) {
        (aActor)->FatalError("Error deserializing 'paints' (CompositableOperation[]) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'paints'
    if ((!((aMsg)->ReadSentinel(aIter, 4193300201)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'paints' (CompositableOperation[]) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->toDestroy())))))) {
        (aActor)->FatalError("Error deserializing 'toDestroy' (OpDestroy[]) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'toDestroy'
    if ((!((aMsg)->ReadSentinel(aIter, 4183172130)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'toDestroy' (OpDestroy[]) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->fwdTransactionId())))))) {
        (aActor)->FatalError("Error deserializing 'fwdTransactionId' (uint64_t) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'fwdTransactionId'
    if ((!((aMsg)->ReadSentinel(aIter, 2023976742)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fwdTransactionId' (uint64_t) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->id())))))) {
        (aActor)->FatalError("Error deserializing 'id' (TransactionId) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'id'
    if ((!((aMsg)->ReadSentinel(aIter, 2794505629)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'id' (TransactionId) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->targetConfig())))))) {
        (aActor)->FatalError("Error deserializing 'targetConfig' (TargetConfig) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'targetConfig'
    if ((!((aMsg)->ReadSentinel(aIter, 3027540357)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'targetConfig' (TargetConfig) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->plugins())))))) {
        (aActor)->FatalError("Error deserializing 'plugins' (PluginWindowData[]) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'plugins'
    if ((!((aMsg)->ReadSentinel(aIter, 2745061527)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'plugins' (PluginWindowData[]) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->isFirstPaint())))))) {
        (aActor)->FatalError("Error deserializing 'isFirstPaint' (bool) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'isFirstPaint'
    if ((!((aMsg)->ReadSentinel(aIter, 3748149138)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isFirstPaint' (bool) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->focusTarget())))))) {
        (aActor)->FatalError("Error deserializing 'focusTarget' (FocusTarget) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'focusTarget'
    if ((!((aMsg)->ReadSentinel(aIter, 2511236160)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'focusTarget' (FocusTarget) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->scheduleComposite())))))) {
        (aActor)->FatalError("Error deserializing 'scheduleComposite' (bool) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'scheduleComposite'
    if ((!((aMsg)->ReadSentinel(aIter, 3730535701)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scheduleComposite' (bool) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->paintSequenceNumber())))))) {
        (aActor)->FatalError("Error deserializing 'paintSequenceNumber' (uint32_t) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'paintSequenceNumber'
    if ((!((aMsg)->ReadSentinel(aIter, 3875026487)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'paintSequenceNumber' (uint32_t) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->isRepeatTransaction())))))) {
        (aActor)->FatalError("Error deserializing 'isRepeatTransaction' (bool) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'isRepeatTransaction'
    if ((!((aMsg)->ReadSentinel(aIter, 4043798256)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isRepeatTransaction' (bool) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->refreshStart())))))) {
        (aActor)->FatalError("Error deserializing 'refreshStart' (TimeStamp) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'refreshStart'
    if ((!((aMsg)->ReadSentinel(aIter, 3056521935)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'refreshStart' (TimeStamp) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->transactionStart())))))) {
        (aActor)->FatalError("Error deserializing 'transactionStart' (TimeStamp) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'transactionStart'
    if ((!((aMsg)->ReadSentinel(aIter, 214152700)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'transactionStart' (TimeStamp) member of 'TransactionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->fwdTime())))))) {
        (aActor)->FatalError("Error deserializing 'fwdTime' (TimeStamp) member of 'TransactionInfo'");
        return false;
    }
    // Sentinel = 'fwdTime'
    if ((!((aMsg)->ReadSentinel(aIter, 1610637679)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fwdTime' (TimeStamp) member of 'TransactionInfo'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

} // namespace layers
} // namespace mozilla

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

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

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

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

} // namespace ipc
} // namespace mozilla

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

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 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 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()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case Tfloat:
        {
            new (mozilla::KnownNotNull, ptr_float()) float(std::move((aOther).get_float()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TMatrix4x4:
        {
            new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4(std::move((aOther).get_Matrix4x4()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

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

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

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

auto OMTAValue::operator=(Matrix4x4&& aRhs) -> OMTAValue&
{
    if (MaybeDestroy(TMatrix4x4)) {
        new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4;
    }
    (*(ptr_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:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = (aRhs).get_null_t();
            break;
        }
    case Tfloat:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_float()) float;
            }
            (*(ptr_float())) = (aRhs).get_float();
            break;
        }
    case TMatrix4x4:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4;
            }
            (*(ptr_Matrix4x4())) = (aRhs).get_Matrix4x4();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            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:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = std::move((aRhs).get_null_t());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case Tfloat:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_float()) float;
            }
            (*(ptr_float())) = std::move((aRhs).get_float());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TMatrix4x4:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4;
            }
            (*(ptr_Matrix4x4())) = std::move((aRhs).get_Matrix4x4());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

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

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

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

auto OMTAValue::operator==(const OMTAValue& 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 TMatrix4x4:
        {
            return (get_Matrix4x4()) == ((aRhs).get_Matrix4x4());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

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

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

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

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::Tnull_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aMsg)->WriteSentinel(3731137201);
            return;
        }
    case union__::Tfloat:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_float());
            // Sentinel = 'Tfloat'
            (aMsg)->WriteSentinel(2693237468);
            return;
        }
    case union__::TMatrix4x4:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_Matrix4x4());
            // Sentinel = 'TMatrix4x4'
            (aMsg)->WriteSentinel(1886581935);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::Tnull_t:
        {
            mozilla::null_t tmp = mozilla::null_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_null_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tnull_t of union OMTAValue");
                return false;
            }
            // Sentinel = 'Tnull_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3731137201)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union OMTAValue");
                return false;
            }
            return true;
        }
    case union__::Tfloat:
        {
            float tmp = float();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_float())))))) {
                (aActor)->FatalError("Error deserializing variant Tfloat of union OMTAValue");
                return false;
            }
            // Sentinel = 'Tfloat'
            if ((!((aMsg)->ReadSentinel(aIter, 2693237468)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tfloat of union OMTAValue");
                return false;
            }
            return true;
        }
    case union__::TMatrix4x4:
        {
            mozilla::gfx::Matrix4x4 tmp = mozilla::gfx::Matrix4x4();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_Matrix4x4())))))) {
                (aActor)->FatalError("Error deserializing variant TMatrix4x4 of union OMTAValue");
                return false;
            }
            // Sentinel = 'TMatrix4x4'
            if ((!((aMsg)->ReadSentinel(aIter, 1886581935)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TMatrix4x4 of union OMTAValue");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53