mozilla-central/__GENERATED__/ipc/ipdl/LayersMessages.cpp (file symbol)

Copy as Markdown

Other Tools

//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "gfxipc/ShadowLayerUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "gfxipc/ShadowLayerUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/layers/WebRenderMessageUtils.h"
#include "mozilla/layers/PCompositorBridgeParent.h"
#include "mozilla/layers/PCompositorBridgeChild.h"
#include "mozilla/layers/PTextureParent.h"
#include "mozilla/layers/PTextureChild.h"
#include "mozilla/layers/LayersMessages.h"
#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct TargetConfig|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::TargetConfig>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).naturalBounds());
// Sentinel = 'naturalBounds'
(aWriter)->WriteSentinel(634062179);
IPC::WriteParam(aWriter, (aVar).rotation());
// Sentinel = 'rotation'
(aWriter)->WriteSentinel(261423985);
IPC::WriteParam(aWriter, (aVar).orientation());
// Sentinel = 'orientation'
(aWriter)->WriteSentinel(471008429);
IPC::WriteParam(aWriter, (aVar).clearRegion());
// Sentinel = 'clearRegion'
(aWriter)->WriteSentinel(440337516);
}
auto ParamTraits<::mozilla::layers::TargetConfig>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___naturalBounds = IPC::ReadParam<::mozilla::gfx::IntRect>(aReader);
if (!maybe___naturalBounds) {
aReader->FatalError("Error deserializing 'naturalBounds' (IntRect) member of 'TargetConfig'");
return {};
}
auto& _naturalBounds = *maybe___naturalBounds;
// Sentinel = 'naturalBounds'
if ((!((aReader)->ReadSentinel(634062179)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'naturalBounds' (IntRect) member of 'TargetConfig'");
return {};
}
auto maybe___rotation = IPC::ReadParam<::mozilla::ScreenRotation>(aReader);
if (!maybe___rotation) {
aReader->FatalError("Error deserializing 'rotation' (ScreenRotation) member of 'TargetConfig'");
return {};
}
auto& _rotation = *maybe___rotation;
// Sentinel = 'rotation'
if ((!((aReader)->ReadSentinel(261423985)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'rotation' (ScreenRotation) member of 'TargetConfig'");
return {};
}
auto maybe___orientation = IPC::ReadParam<::mozilla::hal::ScreenOrientation>(aReader);
if (!maybe___orientation) {
aReader->FatalError("Error deserializing 'orientation' (ScreenOrientation) member of 'TargetConfig'");
return {};
}
auto& _orientation = *maybe___orientation;
// Sentinel = 'orientation'
if ((!((aReader)->ReadSentinel(471008429)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'orientation' (ScreenOrientation) member of 'TargetConfig'");
return {};
}
auto maybe___clearRegion = IPC::ReadParam<::nsIntRegion>(aReader);
if (!maybe___clearRegion) {
aReader->FatalError("Error deserializing 'clearRegion' (nsIntRegion) member of 'TargetConfig'");
return {};
}
auto& _clearRegion = *maybe___clearRegion;
// Sentinel = 'clearRegion'
if ((!((aReader)->ReadSentinel(440337516)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'clearRegion' (nsIntRegion) member of 'TargetConfig'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_naturalBounds),
std::move(_rotation),
std::move(_orientation),
std::move(_clearRegion)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpAttachCompositable|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::OpAttachCompositable>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).layer());
// Sentinel = 'layer'
(aWriter)->WriteSentinel(105644574);
IPC::WriteParam(aWriter, (aVar).compositable());
// Sentinel = 'compositable'
(aWriter)->WriteSentinel(551879939);
}
auto ParamTraits<::mozilla::layers::OpAttachCompositable>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___layer = IPC::ReadParam<::mozilla::layers::LayerHandle>(aReader);
if (!maybe___layer) {
aReader->FatalError("Error deserializing 'layer' (LayerHandle) member of 'OpAttachCompositable'");
return {};
}
auto& _layer = *maybe___layer;
// Sentinel = 'layer'
if ((!((aReader)->ReadSentinel(105644574)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'layer' (LayerHandle) member of 'OpAttachCompositable'");
return {};
}
auto maybe___compositable = IPC::ReadParam<::mozilla::layers::CompositableHandle>(aReader);
if (!maybe___compositable) {
aReader->FatalError("Error deserializing 'compositable' (CompositableHandle) member of 'OpAttachCompositable'");
return {};
}
auto& _compositable = *maybe___compositable;
// Sentinel = 'compositable'
if ((!((aReader)->ReadSentinel(551879939)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'compositable' (CompositableHandle) member of 'OpAttachCompositable'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_layer),
std::move(_compositable)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpAttachAsyncCompositable|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::OpAttachAsyncCompositable>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).layer());
// Sentinel = 'layer'
(aWriter)->WriteSentinel(105644574);
IPC::WriteParam(aWriter, (aVar).compositable());
// Sentinel = 'compositable'
(aWriter)->WriteSentinel(551879939);
}
auto ParamTraits<::mozilla::layers::OpAttachAsyncCompositable>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___layer = IPC::ReadParam<::mozilla::layers::LayerHandle>(aReader);
if (!maybe___layer) {
aReader->FatalError("Error deserializing 'layer' (LayerHandle) member of 'OpAttachAsyncCompositable'");
return {};
}
auto& _layer = *maybe___layer;
// Sentinel = 'layer'
if ((!((aReader)->ReadSentinel(105644574)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'layer' (LayerHandle) member of 'OpAttachAsyncCompositable'");
return {};
}
auto maybe___compositable = IPC::ReadParam<::mozilla::layers::CompositableHandle>(aReader);
if (!maybe___compositable) {
aReader->FatalError("Error deserializing 'compositable' (CompositableHandle) member of 'OpAttachAsyncCompositable'");
return {};
}
auto& _compositable = *maybe___compositable;
// Sentinel = 'compositable'
if ((!((aReader)->ReadSentinel(551879939)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'compositable' (CompositableHandle) member of 'OpAttachAsyncCompositable'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_layer),
std::move(_compositable)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct LayerColor|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::LayerColor>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).value());
// Sentinel = 'value'
(aWriter)->WriteSentinel(107610654);
}
auto ParamTraits<::mozilla::layers::LayerColor>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___value = IPC::ReadParam<::mozilla::gfx::DeviceColor>(aReader);
if (!maybe___value) {
aReader->FatalError("Error deserializing 'value' (DeviceColor) member of 'LayerColor'");
return {};
}
auto& _value = *maybe___value;
// Sentinel = 'value'
if ((!((aReader)->ReadSentinel(107610654)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'value' (DeviceColor) member of 'LayerColor'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_value)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union Animatable|
//
namespace mozilla {
namespace layers {
auto Animatable::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnull_t:
{
(ptr_null_t())->~null_t__tdef();
break;
}
case Tfloat:
{
(ptr_float())->~float__tdef();
break;
}
case Tnscolor:
{
(ptr_nscolor())->~nscolor__tdef();
break;
}
case TStyleRotate:
{
(ptr_StyleRotate())->~StyleRotate__tdef();
break;
}
case TStyleScale:
{
(ptr_StyleScale())->~StyleScale__tdef();
break;
}
case TStyleTranslate:
{
(ptr_StyleTranslate())->~StyleTranslate__tdef();
break;
}
case TStyleTransform:
{
(ptr_StyleTransform())->~StyleTransform__tdef();
break;
}
case TStyleOffsetPath:
{
(ptr_StyleOffsetPath())->~StyleOffsetPath__tdef();
break;
}
case TLengthPercentage:
{
(ptr_LengthPercentage())->~LengthPercentage__tdef();
break;
}
case TStyleOffsetRotate:
{
(ptr_StyleOffsetRotate())->~StyleOffsetRotate__tdef();
break;
}
case TStylePositionOrAuto:
{
(ptr_StylePositionOrAuto())->~StylePositionOrAuto__tdef();
break;
}
case TStyleOffsetPosition:
{
(ptr_StyleOffsetPosition())->~StyleOffsetPosition__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT Animatable::Animatable(const null_t& aOther)
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
mType = Tnull_t;
}
MOZ_IMPLICIT Animatable::Animatable(null_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aOther));
mType = Tnull_t;
}
MOZ_IMPLICIT Animatable::Animatable(const float& aOther)
{
new (mozilla::KnownNotNull, ptr_float()) float(aOther);
mType = Tfloat;
}
MOZ_IMPLICIT Animatable::Animatable(float&& aOther)
{
new (mozilla::KnownNotNull, ptr_float()) float(std::move(aOther));
mType = Tfloat;
}
MOZ_IMPLICIT Animatable::Animatable(const nscolor& aOther)
{
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(aOther);
mType = Tnscolor;
}
MOZ_IMPLICIT Animatable::Animatable(nscolor&& aOther)
{
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move(aOther));
mType = Tnscolor;
}
MOZ_IMPLICIT Animatable::Animatable(const StyleRotate& aOther)
{
new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate(aOther);
mType = TStyleRotate;
}
MOZ_IMPLICIT Animatable::Animatable(StyleRotate&& aOther)
{
new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate(std::move(aOther));
mType = TStyleRotate;
}
MOZ_IMPLICIT Animatable::Animatable(const StyleScale& aOther)
{
new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale(aOther);
mType = TStyleScale;
}
MOZ_IMPLICIT Animatable::Animatable(StyleScale&& aOther)
{
new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale(std::move(aOther));
mType = TStyleScale;
}
MOZ_IMPLICIT Animatable::Animatable(const StyleTranslate& aOther)
{
new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate(aOther);
mType = TStyleTranslate;
}
MOZ_IMPLICIT Animatable::Animatable(StyleTranslate&& aOther)
{
new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate(std::move(aOther));
mType = TStyleTranslate;
}
MOZ_IMPLICIT Animatable::Animatable(const StyleTransform& aOther)
{
new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform(aOther);
mType = TStyleTransform;
}
MOZ_IMPLICIT Animatable::Animatable(StyleTransform&& aOther)
{
new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform(std::move(aOther));
mType = TStyleTransform;
}
MOZ_IMPLICIT Animatable::Animatable(const StyleOffsetPath& aOther)
{
new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath(aOther);
mType = TStyleOffsetPath;
}
MOZ_IMPLICIT Animatable::Animatable(StyleOffsetPath&& aOther)
{
new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath(std::move(aOther));
mType = TStyleOffsetPath;
}
MOZ_IMPLICIT Animatable::Animatable(const LengthPercentage& aOther)
{
new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage(aOther);
mType = TLengthPercentage;
}
MOZ_IMPLICIT Animatable::Animatable(LengthPercentage&& aOther)
{
new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage(std::move(aOther));
mType = TLengthPercentage;
}
MOZ_IMPLICIT Animatable::Animatable(const StyleOffsetRotate& aOther)
{
new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate(aOther);
mType = TStyleOffsetRotate;
}
MOZ_IMPLICIT Animatable::Animatable(StyleOffsetRotate&& aOther)
{
new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate(std::move(aOther));
mType = TStyleOffsetRotate;
}
MOZ_IMPLICIT Animatable::Animatable(const StylePositionOrAuto& aOther)
{
new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto(aOther);
mType = TStylePositionOrAuto;
}
MOZ_IMPLICIT Animatable::Animatable(StylePositionOrAuto&& aOther)
{
new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto(std::move(aOther));
mType = TStylePositionOrAuto;
}
MOZ_IMPLICIT Animatable::Animatable(const StyleOffsetPosition& aOther)
{
new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition(aOther);
mType = TStyleOffsetPosition;
}
MOZ_IMPLICIT Animatable::Animatable(StyleOffsetPosition&& aOther)
{
new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition(std::move(aOther));
mType = TStyleOffsetPosition;
}
MOZ_IMPLICIT Animatable::Animatable(const Animatable& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tnull_t:
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
break;
}
case Tfloat:
{
new (mozilla::KnownNotNull, ptr_float()) float((aOther).get_float());
break;
}
case Tnscolor:
{
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor((aOther).get_nscolor());
break;
}
case TStyleRotate:
{
new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate((aOther).get_StyleRotate());
break;
}
case TStyleScale:
{
new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale((aOther).get_StyleScale());
break;
}
case TStyleTranslate:
{
new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate((aOther).get_StyleTranslate());
break;
}
case TStyleTransform:
{
new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform((aOther).get_StyleTransform());
break;
}
case TStyleOffsetPath:
{
new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath((aOther).get_StyleOffsetPath());
break;
}
case TLengthPercentage:
{
new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage((aOther).get_LengthPercentage());
break;
}
case TStyleOffsetRotate:
{
new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate((aOther).get_StyleOffsetRotate());
break;
}
case TStylePositionOrAuto:
{
new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto((aOther).get_StylePositionOrAuto());
break;
}
case TStyleOffsetPosition:
{
new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition((aOther).get_StyleOffsetPosition());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT Animatable::Animatable(Animatable&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tnull_t:
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_t()));
(aOther).MaybeDestroy();
break;
}
case Tfloat:
{
new (mozilla::KnownNotNull, ptr_float()) float(std::move((aOther).get_float()));
(aOther).MaybeDestroy();
break;
}
case Tnscolor:
{
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move((aOther).get_nscolor()));
(aOther).MaybeDestroy();
break;
}
case TStyleRotate:
{
new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate(std::move((aOther).get_StyleRotate()));
(aOther).MaybeDestroy();
break;
}
case TStyleScale:
{
new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale(std::move((aOther).get_StyleScale()));
(aOther).MaybeDestroy();
break;
}
case TStyleTranslate:
{
new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate(std::move((aOther).get_StyleTranslate()));
(aOther).MaybeDestroy();
break;
}
case TStyleTransform:
{
new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform(std::move((aOther).get_StyleTransform()));
(aOther).MaybeDestroy();
break;
}
case TStyleOffsetPath:
{
new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath(std::move((aOther).get_StyleOffsetPath()));
(aOther).MaybeDestroy();
break;
}
case TLengthPercentage:
{
new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage(std::move((aOther).get_LengthPercentage()));
(aOther).MaybeDestroy();
break;
}
case TStyleOffsetRotate:
{
new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate(std::move((aOther).get_StyleOffsetRotate()));
(aOther).MaybeDestroy();
break;
}
case TStylePositionOrAuto:
{
new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto(std::move((aOther).get_StylePositionOrAuto()));
(aOther).MaybeDestroy();
break;
}
case TStyleOffsetPosition:
{
new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition(std::move((aOther).get_StyleOffsetPosition()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
Animatable::~Animatable()
{
MaybeDestroy();
}
auto Animatable::operator=(const null_t& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t(aRhs);
mType = Tnull_t;
return (*(this));
}
auto Animatable::operator=(null_t&& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aRhs));
mType = Tnull_t;
return (*(this));
}
auto Animatable::operator=(const float& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_float()) float(aRhs);
mType = Tfloat;
return (*(this));
}
auto Animatable::operator=(float&& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_float()) float(std::move(aRhs));
mType = Tfloat;
return (*(this));
}
auto Animatable::operator=(const nscolor& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(aRhs);
mType = Tnscolor;
return (*(this));
}
auto Animatable::operator=(nscolor&& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move(aRhs));
mType = Tnscolor;
return (*(this));
}
auto Animatable::operator=(const StyleRotate& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate(aRhs);
mType = TStyleRotate;
return (*(this));
}
auto Animatable::operator=(StyleRotate&& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate(std::move(aRhs));
mType = TStyleRotate;
return (*(this));
}
auto Animatable::operator=(const StyleScale& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale(aRhs);
mType = TStyleScale;
return (*(this));
}
auto Animatable::operator=(StyleScale&& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale(std::move(aRhs));
mType = TStyleScale;
return (*(this));
}
auto Animatable::operator=(const StyleTranslate& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate(aRhs);
mType = TStyleTranslate;
return (*(this));
}
auto Animatable::operator=(StyleTranslate&& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate(std::move(aRhs));
mType = TStyleTranslate;
return (*(this));
}
auto Animatable::operator=(const StyleTransform& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform(aRhs);
mType = TStyleTransform;
return (*(this));
}
auto Animatable::operator=(StyleTransform&& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform(std::move(aRhs));
mType = TStyleTransform;
return (*(this));
}
auto Animatable::operator=(const StyleOffsetPath& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath(aRhs);
mType = TStyleOffsetPath;
return (*(this));
}
auto Animatable::operator=(StyleOffsetPath&& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath(std::move(aRhs));
mType = TStyleOffsetPath;
return (*(this));
}
auto Animatable::operator=(const LengthPercentage& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage(aRhs);
mType = TLengthPercentage;
return (*(this));
}
auto Animatable::operator=(LengthPercentage&& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage(std::move(aRhs));
mType = TLengthPercentage;
return (*(this));
}
auto Animatable::operator=(const StyleOffsetRotate& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate(aRhs);
mType = TStyleOffsetRotate;
return (*(this));
}
auto Animatable::operator=(StyleOffsetRotate&& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate(std::move(aRhs));
mType = TStyleOffsetRotate;
return (*(this));
}
auto Animatable::operator=(const StylePositionOrAuto& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto(aRhs);
mType = TStylePositionOrAuto;
return (*(this));
}
auto Animatable::operator=(StylePositionOrAuto&& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto(std::move(aRhs));
mType = TStylePositionOrAuto;
return (*(this));
}
auto Animatable::operator=(const StyleOffsetPosition& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition(aRhs);
mType = TStyleOffsetPosition;
return (*(this));
}
auto Animatable::operator=(StyleOffsetPosition&& aRhs) -> Animatable&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition(std::move(aRhs));
mType = TStyleOffsetPosition;
return (*(this));
}
auto Animatable::operator=(const Animatable& aRhs) -> Animatable&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnull_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t((aRhs).get_null_t());
break;
}
case Tfloat:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_float()) float((aRhs).get_float());
break;
}
case Tnscolor:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor((aRhs).get_nscolor());
break;
}
case TStyleRotate:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate((aRhs).get_StyleRotate());
break;
}
case TStyleScale:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale((aRhs).get_StyleScale());
break;
}
case TStyleTranslate:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate((aRhs).get_StyleTranslate());
break;
}
case TStyleTransform:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform((aRhs).get_StyleTransform());
break;
}
case TStyleOffsetPath:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath((aRhs).get_StyleOffsetPath());
break;
}
case TLengthPercentage:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage((aRhs).get_LengthPercentage());
break;
}
case TStyleOffsetRotate:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate((aRhs).get_StyleOffsetRotate());
break;
}
case TStylePositionOrAuto:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto((aRhs).get_StylePositionOrAuto());
break;
}
case TStyleOffsetPosition:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition((aRhs).get_StyleOffsetPosition());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto Animatable::operator=(Animatable&& aRhs) -> Animatable&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnull_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aRhs).get_null_t()));
(aRhs).MaybeDestroy();
break;
}
case Tfloat:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_float()) float(std::move((aRhs).get_float()));
(aRhs).MaybeDestroy();
break;
}
case Tnscolor:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move((aRhs).get_nscolor()));
(aRhs).MaybeDestroy();
break;
}
case TStyleRotate:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleRotate()) StyleRotate(std::move((aRhs).get_StyleRotate()));
(aRhs).MaybeDestroy();
break;
}
case TStyleScale:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleScale()) StyleScale(std::move((aRhs).get_StyleScale()));
(aRhs).MaybeDestroy();
break;
}
case TStyleTranslate:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleTranslate()) StyleTranslate(std::move((aRhs).get_StyleTranslate()));
(aRhs).MaybeDestroy();
break;
}
case TStyleTransform:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleTransform()) StyleTransform(std::move((aRhs).get_StyleTransform()));
(aRhs).MaybeDestroy();
break;
}
case TStyleOffsetPath:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleOffsetPath()) StyleOffsetPath(std::move((aRhs).get_StyleOffsetPath()));
(aRhs).MaybeDestroy();
break;
}
case TLengthPercentage:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_LengthPercentage()) LengthPercentage(std::move((aRhs).get_LengthPercentage()));
(aRhs).MaybeDestroy();
break;
}
case TStyleOffsetRotate:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleOffsetRotate()) StyleOffsetRotate(std::move((aRhs).get_StyleOffsetRotate()));
(aRhs).MaybeDestroy();
break;
}
case TStylePositionOrAuto:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StylePositionOrAuto()) StylePositionOrAuto(std::move((aRhs).get_StylePositionOrAuto()));
(aRhs).MaybeDestroy();
break;
}
case TStyleOffsetPosition:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StyleOffsetPosition()) StyleOffsetPosition(std::move((aRhs).get_StyleOffsetPosition()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
auto Animatable::operator==(const null_t& aRhs) const -> bool
{
return (get_null_t()) == (aRhs);
}
auto Animatable::operator==(const float& aRhs) const -> bool
{
return (get_float()) == (aRhs);
}
auto Animatable::operator==(const nscolor& aRhs) const -> bool
{
return (get_nscolor()) == (aRhs);
}
auto Animatable::operator==(const StyleRotate& aRhs) const -> bool
{
return (get_StyleRotate()) == (aRhs);
}
auto Animatable::operator==(const StyleScale& aRhs) const -> bool
{
return (get_StyleScale()) == (aRhs);
}
auto Animatable::operator==(const StyleTranslate& aRhs) const -> bool
{
return (get_StyleTranslate()) == (aRhs);
}
auto Animatable::operator==(const StyleTransform& aRhs) const -> bool
{
return (get_StyleTransform()) == (aRhs);
}
auto Animatable::operator==(const StyleOffsetPath& aRhs) const -> bool
{
return (get_StyleOffsetPath()) == (aRhs);
}
auto Animatable::operator==(const LengthPercentage& aRhs) const -> bool
{
return (get_LengthPercentage()) == (aRhs);
}
auto Animatable::operator==(const StyleOffsetRotate& aRhs) const -> bool
{
return (get_StyleOffsetRotate()) == (aRhs);
}
auto Animatable::operator==(const StylePositionOrAuto& aRhs) const -> bool
{
return (get_StylePositionOrAuto()) == (aRhs);
}
auto Animatable::operator==(const StyleOffsetPosition& aRhs) const -> bool
{
return (get_StyleOffsetPosition()) == (aRhs);
}
auto Animatable::operator==(const Animatable& aRhs) const -> bool
{
if ((type()) != ((aRhs).type())) {
return false;
}
switch (type()) {
case Tnull_t:
{
return (get_null_t()) == ((aRhs).get_null_t());
}
case Tfloat:
{
return (get_float()) == ((aRhs).get_float());
}
case Tnscolor:
{
return (get_nscolor()) == ((aRhs).get_nscolor());
}
case TStyleRotate:
{
return (get_StyleRotate()) == ((aRhs).get_StyleRotate());
}
case TStyleScale:
{
return (get_StyleScale()) == ((aRhs).get_StyleScale());
}
case TStyleTranslate:
{
return (get_StyleTranslate()) == ((aRhs).get_StyleTranslate());
}
case TStyleTransform:
{
return (get_StyleTransform()) == ((aRhs).get_StyleTransform());
}
case TStyleOffsetPath:
{
return (get_StyleOffsetPath()) == ((aRhs).get_StyleOffsetPath());
}
case TLengthPercentage:
{
return (get_LengthPercentage()) == ((aRhs).get_LengthPercentage());
}
case TStyleOffsetRotate:
{
return (get_StyleOffsetRotate()) == ((aRhs).get_StyleOffsetRotate());
}
case TStylePositionOrAuto:
{
return (get_StylePositionOrAuto()) == ((aRhs).get_StylePositionOrAuto());
}
case TStyleOffsetPosition:
{
return (get_StyleOffsetPosition()) == ((aRhs).get_StyleOffsetPosition());
}
default:
{
mozilla::ipc::LogicError("unreached");
return false;
}
}
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::Animatable>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::layers::Animatable union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'Animatable'
(aWriter)->WriteSentinel(354812911);
switch (type) {
case union__::Tnull_t:
{
IPC::WriteParam(aWriter, (aVar).get_null_t());
// Sentinel = 'Tnull_t'
(aWriter)->WriteSentinel(190186211);
return;
}
case union__::Tfloat:
{
IPC::WriteParam(aWriter, (aVar).get_float());
// Sentinel = 'Tfloat'
(aWriter)->WriteSentinel(137298539);
return;
}
case union__::Tnscolor:
{
IPC::WriteParam(aWriter, (aVar).get_nscolor());
// Sentinel = 'Tnscolor'
(aWriter)->WriteSentinel(245039957);
return;
}
case union__::TStyleRotate:
{
IPC::WriteParam(aWriter, (aVar).get_StyleRotate());
// Sentinel = 'TStyleRotate'
(aWriter)->WriteSentinel(516949205);
return;
}
case union__::TStyleScale:
{
IPC::WriteParam(aWriter, (aVar).get_StyleScale());
// Sentinel = 'TStyleScale'
(aWriter)->WriteSentinel(429786190);
return;
}
case union__::TStyleTranslate:
{
IPC::WriteParam(aWriter, (aVar).get_StyleTranslate());
// Sentinel = 'TStyleTranslate'
(aWriter)->WriteSentinel(801703444);
return;
}
case union__::TStyleTransform:
{
IPC::WriteParam(aWriter, (aVar).get_StyleTransform());
// Sentinel = 'TStyleTransform'
(aWriter)->WriteSentinel(803145250);
return;
}
case union__::TStyleOffsetPath:
{
IPC::WriteParam(aWriter, (aVar).get_StyleOffsetPath());
// Sentinel = 'TStyleOffsetPath'
(aWriter)->WriteSentinel(895944282);
return;
}
case union__::TLengthPercentage:
{
IPC::WriteParam(aWriter, (aVar).get_LengthPercentage());
// Sentinel = 'TLengthPercentage'
(aWriter)->WriteSentinel(991102645);
return;
}
case union__::TStyleOffsetRotate:
{
IPC::WriteParam(aWriter, (aVar).get_StyleOffsetRotate());
// Sentinel = 'TStyleOffsetRotate'
(aWriter)->WriteSentinel(1134888764);
return;
}
case union__::TStylePositionOrAuto:
{
IPC::WriteParam(aWriter, (aVar).get_StylePositionOrAuto());
// Sentinel = 'TStylePositionOrAuto'
(aWriter)->WriteSentinel(1410598933);
return;
}
case union__::TStyleOffsetPosition:
{
IPC::WriteParam(aWriter, (aVar).get_StyleOffsetPosition());
// Sentinel = 'TStyleOffsetPosition'
(aWriter)->WriteSentinel(1401358370);
return;
}
default:
{
aWriter->FatalError("unknown variant of union Animatable");
return;
}
}
}
auto ParamTraits<::mozilla::layers::Animatable>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::layers::Animatable union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union Animatable");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'Animatable'
if ((!((aReader)->ReadSentinel(354812911)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union Animatable");
return {};
}
switch (type) {
case union__::Tnull_t:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::null_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnull_t of union Animatable");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnull_t'
if ((!((aReader)->ReadSentinel(190186211)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union Animatable");
return {};
}
return std::move(tmp);
}
case union__::Tfloat:
{
auto maybe__tmp = IPC::ReadParam<float>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tfloat of union Animatable");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tfloat'
if ((!((aReader)->ReadSentinel(137298539)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tfloat of union Animatable");
return {};
}
return std::move(tmp);
}
case union__::Tnscolor:
{
auto maybe__tmp = IPC::ReadParam<::nscolor>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnscolor of union Animatable");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnscolor'
if ((!((aReader)->ReadSentinel(245039957)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnscolor of union Animatable");
return {};
}
return std::move(tmp);
}
case union__::TStyleRotate:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::StyleRotate>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStyleRotate of union Animatable");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStyleRotate'
if ((!((aReader)->ReadSentinel(516949205)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStyleRotate of union Animatable");
return {};
}
return std::move(tmp);
}
case union__::TStyleScale:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::StyleScale>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStyleScale of union Animatable");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStyleScale'
if ((!((aReader)->ReadSentinel(429786190)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStyleScale of union Animatable");
return {};
}
return std::move(tmp);
}
case union__::TStyleTranslate:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::StyleTranslate>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStyleTranslate of union Animatable");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStyleTranslate'
if ((!((aReader)->ReadSentinel(801703444)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStyleTranslate of union Animatable");
return {};
}
return std::move(tmp);
}
case union__::TStyleTransform:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::StyleTransform>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStyleTransform of union Animatable");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStyleTransform'
if ((!((aReader)->ReadSentinel(803145250)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStyleTransform of union Animatable");
return {};
}
return std::move(tmp);
}
case union__::TStyleOffsetPath:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::StyleOffsetPath>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStyleOffsetPath of union Animatable");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStyleOffsetPath'
if ((!((aReader)->ReadSentinel(895944282)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStyleOffsetPath of union Animatable");
return {};
}
return std::move(tmp);
}
case union__::TLengthPercentage:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::LengthPercentage>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TLengthPercentage of union Animatable");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TLengthPercentage'
if ((!((aReader)->ReadSentinel(991102645)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TLengthPercentage of union Animatable");
return {};
}
return std::move(tmp);
}
case union__::TStyleOffsetRotate:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::StyleOffsetRotate>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStyleOffsetRotate of union Animatable");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStyleOffsetRotate'
if ((!((aReader)->ReadSentinel(1134888764)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStyleOffsetRotate of union Animatable");
return {};
}
return std::move(tmp);
}
case union__::TStylePositionOrAuto:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::StylePositionOrAuto>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStylePositionOrAuto of union Animatable");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStylePositionOrAuto'
if ((!((aReader)->ReadSentinel(1410598933)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStylePositionOrAuto of union Animatable");
return {};
}
return std::move(tmp);
}
case union__::TStyleOffsetPosition:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::StyleOffsetPosition>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStyleOffsetPosition of union Animatable");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStyleOffsetPosition'
if ((!((aReader)->ReadSentinel(1401358370)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStyleOffsetPosition of union Animatable");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union Animatable");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct AnimationSegment|
//
namespace mozilla {
namespace layers {
auto AnimationSegment::StaticAssertions() const -> void
{
static_assert(
(offsetof(AnimationSegment, endPortion_) - offsetof(AnimationSegment, startPortion_)) == 4,
"Bad assumptions about field layout!");
static_assert(
(offsetof(AnimationSegment, endComposite_) - offsetof(AnimationSegment, startComposite_)) == 1,
"Bad assumptions about field layout!");
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::AnimationSegment>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).startState());
// Sentinel = 'startState'
(aWriter)->WriteSentinel(391709744);
IPC::WriteParam(aWriter, (aVar).endState());
// Sentinel = 'endState'
(aWriter)->WriteSentinel(241763129);
IPC::WriteParam(aWriter, (aVar).sampleFn());
// Sentinel = 'sampleFn'
(aWriter)->WriteSentinel(249430839);
(aWriter)->WriteBytes((&((aVar).startPortion())), 8);
// Sentinel = 'startPortion | endPortion'
(aWriter)->WriteSentinel(2191526392);
(aWriter)->WriteBytes((&((aVar).startComposite())), 2);
// Sentinel = 'startComposite | endComposite'
(aWriter)->WriteSentinel(2918452104);
}
auto ParamTraits<::mozilla::layers::AnimationSegment>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___startState = IPC::ReadParam<::mozilla::layers::Animatable>(aReader);
if (!maybe___startState) {
aReader->FatalError("Error deserializing 'startState' (Animatable) member of 'AnimationSegment'");
return {};
}
auto& _startState = *maybe___startState;
// Sentinel = 'startState'
if ((!((aReader)->ReadSentinel(391709744)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'startState' (Animatable) member of 'AnimationSegment'");
return {};
}
auto maybe___endState = IPC::ReadParam<::mozilla::layers::Animatable>(aReader);
if (!maybe___endState) {
aReader->FatalError("Error deserializing 'endState' (Animatable) member of 'AnimationSegment'");
return {};
}
auto& _endState = *maybe___endState;
// Sentinel = 'endState'
if ((!((aReader)->ReadSentinel(241763129)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'endState' (Animatable) member of 'AnimationSegment'");
return {};
}
auto maybe___sampleFn = IPC::ReadParam<mozilla::Maybe<::mozilla::StyleComputedTimingFunction>>(aReader);
if (!maybe___sampleFn) {
aReader->FatalError("Error deserializing 'sampleFn' (StyleComputedTimingFunction?) member of 'AnimationSegment'");
return {};
}
auto& _sampleFn = *maybe___sampleFn;
// Sentinel = 'sampleFn'
if ((!((aReader)->ReadSentinel(249430839)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'sampleFn' (StyleComputedTimingFunction?) member of 'AnimationSegment'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_startState),
std::move(_endState),
float{0},
float{0},
::uint8_t{0},
::uint8_t{0},
std::move(_sampleFn)};
if ((!((aReader)->ReadBytesInto((&((result__)->startPortion())), 8)))) {
aReader->FatalError("Error bulk reading fields from float");
return {};
}
// Sentinel = 'startPortion | endPortion'
if ((!((aReader)->ReadSentinel(2191526392)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from float");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->startComposite())), 2)))) {
aReader->FatalError("Error bulk reading fields from uint8_t");
return {};
}
// Sentinel = 'startComposite | endComposite'
if ((!((aReader)->ReadSentinel(2918452104)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint8_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct MotionPathData|
//
namespace mozilla {
namespace layers {
auto MotionPathData::operator==(const MotionPathData& _o) const -> bool
{
if ((!((origin()) == ((_o).origin())))) {
return false;
}
if ((!((anchorAdjustment()) == ((_o).anchorAdjustment())))) {
return false;
}
if ((!((coordBox()) == ((_o).coordBox())))) {
return false;
}
if ((!((currentPosition()) == ((_o).currentPosition())))) {
return false;
}
if ((!((rayContainReferenceLength()) == ((_o).rayContainReferenceLength())))) {
return false;
}
if ((!((coordBoxInsetRadii()) == ((_o).coordBoxInsetRadii())))) {
return false;
}
return true;
}
auto MotionPathData::operator!=(const MotionPathData& _o) const -> bool
{
return (!(operator==(_o)));
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::MotionPathData>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).origin());
// Sentinel = 'origin'
(aWriter)->WriteSentinel(150143625);
IPC::WriteParam(aWriter, (aVar).anchorAdjustment());
// Sentinel = 'anchorAdjustment'
(aWriter)->WriteSentinel(924321435);
IPC::WriteParam(aWriter, (aVar).coordBox());
// Sentinel = 'coordBox'
(aWriter)->WriteSentinel(245957441);
IPC::WriteParam(aWriter, (aVar).currentPosition());
// Sentinel = 'currentPosition'
(aWriter)->WriteSentinel(851052121);
IPC::WriteParam(aWriter, (aVar).rayContainReferenceLength());
// Sentinel = 'rayContainReferenceLength'
(aWriter)->WriteSentinel(2193295882);
IPC::WriteParam(aWriter, (aVar).coordBoxInsetRadii());
// Sentinel = 'coordBoxInsetRadii'
(aWriter)->WriteSentinel(1149437741);
}
auto ParamTraits<::mozilla::layers::MotionPathData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___origin = IPC::ReadParam<::mozilla::CSSPoint>(aReader);
if (!maybe___origin) {
aReader->FatalError("Error deserializing 'origin' (CSSPoint) member of 'MotionPathData'");
return {};
}
auto& _origin = *maybe___origin;
// Sentinel = 'origin'
if ((!((aReader)->ReadSentinel(150143625)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'origin' (CSSPoint) member of 'MotionPathData'");
return {};
}
auto maybe___anchorAdjustment = IPC::ReadParam<::mozilla::CSSPoint>(aReader);
if (!maybe___anchorAdjustment) {
aReader->FatalError("Error deserializing 'anchorAdjustment' (CSSPoint) member of 'MotionPathData'");
return {};
}
auto& _anchorAdjustment = *maybe___anchorAdjustment;
// Sentinel = 'anchorAdjustment'
if ((!((aReader)->ReadSentinel(924321435)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'anchorAdjustment' (CSSPoint) member of 'MotionPathData'");
return {};
}
auto maybe___coordBox = IPC::ReadParam<::nsRect>(aReader);
if (!maybe___coordBox) {
aReader->FatalError("Error deserializing 'coordBox' (nsRect) member of 'MotionPathData'");
return {};
}
auto& _coordBox = *maybe___coordBox;
// Sentinel = 'coordBox'
if ((!((aReader)->ReadSentinel(245957441)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'coordBox' (nsRect) member of 'MotionPathData'");
return {};
}
auto maybe___currentPosition = IPC::ReadParam<::nsPoint>(aReader);
if (!maybe___currentPosition) {
aReader->FatalError("Error deserializing 'currentPosition' (nsPoint) member of 'MotionPathData'");
return {};
}
auto& _currentPosition = *maybe___currentPosition;
// Sentinel = 'currentPosition'
if ((!((aReader)->ReadSentinel(851052121)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'currentPosition' (nsPoint) member of 'MotionPathData'");
return {};
}
auto maybe___rayContainReferenceLength = IPC::ReadParam<::mozilla::CSSCoord>(aReader);
if (!maybe___rayContainReferenceLength) {
aReader->FatalError("Error deserializing 'rayContainReferenceLength' (CSSCoord) member of 'MotionPathData'");
return {};
}
auto& _rayContainReferenceLength = *maybe___rayContainReferenceLength;
// Sentinel = 'rayContainReferenceLength'
if ((!((aReader)->ReadSentinel(2193295882)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'rayContainReferenceLength' (CSSCoord) member of 'MotionPathData'");
return {};
}
auto maybe___coordBoxInsetRadii = IPC::ReadParam<nsTArray<::nscoord>>(aReader);
if (!maybe___coordBoxInsetRadii) {
aReader->FatalError("Error deserializing 'coordBoxInsetRadii' (nscoord[]) member of 'MotionPathData'");
return {};
}
auto& _coordBoxInsetRadii = *maybe___coordBoxInsetRadii;
// Sentinel = 'coordBoxInsetRadii'
if ((!((aReader)->ReadSentinel(1149437741)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'coordBoxInsetRadii' (nscoord[]) member of 'MotionPathData'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_origin),
std::move(_anchorAdjustment),
std::move(_coordBox),
std::move(_currentPosition),
std::move(_rayContainReferenceLength),
std::move(_coordBoxInsetRadii)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct PartialPrerenderData|
//
namespace mozilla {
namespace layers {
auto PartialPrerenderData::operator==(const PartialPrerenderData& _o) const -> bool
{
if ((!((rect()) == ((_o).rect())))) {
return false;
}
if ((!((overflowedSides()) == ((_o).overflowedSides())))) {
return false;
}
if ((!((scrollId()) == ((_o).scrollId())))) {
return false;
}
if ((!((clipRect()) == ((_o).clipRect())))) {
return false;
}
if ((!((transformInClip()) == ((_o).transformInClip())))) {
return false;
}
if ((!((position()) == ((_o).position())))) {
return false;
}
return true;
}
auto PartialPrerenderData::operator!=(const PartialPrerenderData& _o) const -> bool
{
return (!(operator==(_o)));
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::PartialPrerenderData>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).rect());
// Sentinel = 'rect'
(aWriter)->WriteSentinel(70582703);
IPC::WriteParam(aWriter, (aVar).overflowedSides());
// Sentinel = 'overflowedSides'
(aWriter)->WriteSentinel(847054390);
IPC::WriteParam(aWriter, (aVar).scrollId());
// Sentinel = 'scrollId'
(aWriter)->WriteSentinel(253100861);
IPC::WriteParam(aWriter, (aVar).clipRect());
// Sentinel = 'clipRect'
(aWriter)->WriteSentinel(241894199);
IPC::WriteParam(aWriter, (aVar).transformInClip());
// Sentinel = 'transformInClip'
(aWriter)->WriteSentinel(838403612);
IPC::WriteParam(aWriter, (aVar).position());
// Sentinel = 'position'
(aWriter)->WriteSentinel(262603638);
}
auto ParamTraits<::mozilla::layers::PartialPrerenderData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___rect = IPC::ReadParam<::mozilla::LayoutDeviceRect>(aReader);
if (!maybe___rect) {
aReader->FatalError("Error deserializing 'rect' (LayoutDeviceRect) member of 'PartialPrerenderData'");
return {};
}
auto& _rect = *maybe___rect;
// Sentinel = 'rect'
if ((!((aReader)->ReadSentinel(70582703)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'rect' (LayoutDeviceRect) member of 'PartialPrerenderData'");
return {};
}
auto maybe___overflowedSides = IPC::ReadParam<::mozilla::SideBits>(aReader);
if (!maybe___overflowedSides) {
aReader->FatalError("Error deserializing 'overflowedSides' (SideBits) member of 'PartialPrerenderData'");
return {};
}
auto& _overflowedSides = *maybe___overflowedSides;
// Sentinel = 'overflowedSides'
if ((!((aReader)->ReadSentinel(847054390)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'overflowedSides' (SideBits) member of 'PartialPrerenderData'");
return {};
}
auto maybe___scrollId = IPC::ReadParam<::mozilla::layers::ScrollableLayerGuid::ViewID>(aReader);
if (!maybe___scrollId) {
aReader->FatalError("Error deserializing 'scrollId' (ViewID) member of 'PartialPrerenderData'");
return {};
}
auto& _scrollId = *maybe___scrollId;
// Sentinel = 'scrollId'
if ((!((aReader)->ReadSentinel(253100861)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'scrollId' (ViewID) member of 'PartialPrerenderData'");
return {};
}
auto maybe___clipRect = IPC::ReadParam<::mozilla::ParentLayerRect>(aReader);
if (!maybe___clipRect) {
aReader->FatalError("Error deserializing 'clipRect' (ParentLayerRect) member of 'PartialPrerenderData'");
return {};
}
auto& _clipRect = *maybe___clipRect;
// Sentinel = 'clipRect'
if ((!((aReader)->ReadSentinel(241894199)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'clipRect' (ParentLayerRect) member of 'PartialPrerenderData'");
return {};
}
auto maybe___transformInClip = IPC::ReadParam<::mozilla::gfx::Matrix4x4>(aReader);
if (!maybe___transformInClip) {
aReader->FatalError("Error deserializing 'transformInClip' (Matrix4x4) member of 'PartialPrerenderData'");
return {};
}
auto& _transformInClip = *maybe___transformInClip;
// Sentinel = 'transformInClip'
if ((!((aReader)->ReadSentinel(838403612)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'transformInClip' (Matrix4x4) member of 'PartialPrerenderData'");
return {};
}
auto maybe___position = IPC::ReadParam<::mozilla::LayoutDevicePoint>(aReader);
if (!maybe___position) {
aReader->FatalError("Error deserializing 'position' (LayoutDevicePoint) member of 'PartialPrerenderData'");
return {};
}
auto& _position = *maybe___position;
// Sentinel = 'position'
if ((!((aReader)->ReadSentinel(262603638)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'position' (LayoutDevicePoint) member of 'PartialPrerenderData'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_rect),
std::move(_overflowedSides),
std::move(_scrollId),
std::move(_clipRect),
std::move(_transformInClip),
std::move(_position)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct TransformData|
//
namespace mozilla {
namespace layers {
auto TransformData::operator==(const TransformData& _o) const -> bool
{
if ((!((origin()) == ((_o).origin())))) {
return false;
}
if ((!((transformOrigin()) == ((_o).transformOrigin())))) {
return false;
}
if ((!((bounds()) == ((_o).bounds())))) {
return false;
}
if ((!((appUnitsPerDevPixel()) == ((_o).appUnitsPerDevPixel())))) {
return false;
}
if ((!((motionPathData()) == ((_o).motionPathData())))) {
return false;
}
if ((!((partialPrerenderData()) == ((_o).partialPrerenderData())))) {
return false;
}
return true;
}
auto TransformData::operator!=(const TransformData& _o) const -> bool
{
return (!(operator==(_o)));
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::TransformData>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).origin());
// Sentinel = 'origin'
(aWriter)->WriteSentinel(150143625);
IPC::WriteParam(aWriter, (aVar).transformOrigin());
// Sentinel = 'transformOrigin'
(aWriter)->WriteSentinel(850921029);
IPC::WriteParam(aWriter, (aVar).bounds());
// Sentinel = 'bounds'
(aWriter)->WriteSentinel(148243084);
IPC::WriteParam(aWriter, (aVar).motionPathData());
// Sentinel = 'motionPathData'
(aWriter)->WriteSentinel(724632990);
IPC::WriteParam(aWriter, (aVar).partialPrerenderData());
// Sentinel = 'partialPrerenderData'
(aWriter)->WriteSentinel(1441138703);
(aWriter)->WriteBytes((&((aVar).appUnitsPerDevPixel())), 4);
// Sentinel = 'appUnitsPerDevPixel'
(aWriter)->WriteSentinel(1278936989);
}
auto ParamTraits<::mozilla::layers::TransformData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___origin = IPC::ReadParam<::nsPoint>(aReader);
if (!maybe___origin) {
aReader->FatalError("Error deserializing 'origin' (nsPoint) member of 'TransformData'");
return {};
}
auto& _origin = *maybe___origin;
// Sentinel = 'origin'
if ((!((aReader)->ReadSentinel(150143625)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'origin' (nsPoint) member of 'TransformData'");
return {};
}
auto maybe___transformOrigin = IPC::ReadParam<::mozilla::gfx::Point3D>(aReader);
if (!maybe___transformOrigin) {
aReader->FatalError("Error deserializing 'transformOrigin' (Point3D) member of 'TransformData'");
return {};
}
auto& _transformOrigin = *maybe___transformOrigin;
// Sentinel = 'transformOrigin'
if ((!((aReader)->ReadSentinel(850921029)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'transformOrigin' (Point3D) member of 'TransformData'");
return {};
}
auto maybe___bounds = IPC::ReadParam<::nsRect>(aReader);
if (!maybe___bounds) {
aReader->FatalError("Error deserializing 'bounds' (nsRect) member of 'TransformData'");
return {};
}
auto& _bounds = *maybe___bounds;
// Sentinel = 'bounds'
if ((!((aReader)->ReadSentinel(148243084)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bounds' (nsRect) member of 'TransformData'");
return {};
}
auto maybe___motionPathData = IPC::ReadParam<mozilla::Maybe<::mozilla::layers::MotionPathData>>(aReader);
if (!maybe___motionPathData) {
aReader->FatalError("Error deserializing 'motionPathData' (MotionPathData?) member of 'TransformData'");
return {};
}
auto& _motionPathData = *maybe___motionPathData;
// Sentinel = 'motionPathData'
if ((!((aReader)->ReadSentinel(724632990)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'motionPathData' (MotionPathData?) member of 'TransformData'");
return {};
}
auto maybe___partialPrerenderData = IPC::ReadParam<mozilla::Maybe<::mozilla::layers::PartialPrerenderData>>(aReader);
if (!maybe___partialPrerenderData) {
aReader->FatalError("Error deserializing 'partialPrerenderData' (PartialPrerenderData?) member of 'TransformData'");
return {};
}
auto& _partialPrerenderData = *maybe___partialPrerenderData;
// Sentinel = 'partialPrerenderData'
if ((!((aReader)->ReadSentinel(1441138703)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'partialPrerenderData' (PartialPrerenderData?) member of 'TransformData'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_origin),
std::move(_transformOrigin),
std::move(_bounds),
::int32_t{0},
std::move(_motionPathData),
std::move(_partialPrerenderData)};
if ((!((aReader)->ReadBytesInto((&((result__)->appUnitsPerDevPixel())), 4)))) {
aReader->FatalError("Error bulk reading fields from int32_t");
return {};
}
// Sentinel = 'appUnitsPerDevPixel'
if ((!((aReader)->ReadSentinel(1278936989)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ScrollTimelineOptions|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::ScrollTimelineOptions>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).source());
// Sentinel = 'source'
(aWriter)->WriteSentinel(154665618);
IPC::WriteParam(aWriter, (aVar).axis());
// Sentinel = 'axis'
(aWriter)->WriteSentinel(70582710);
}
auto ParamTraits<::mozilla::layers::ScrollTimelineOptions>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___source = IPC::ReadParam<::mozilla::layers::ScrollableLayerGuid::ViewID>(aReader);
if (!maybe___source) {
aReader->FatalError("Error deserializing 'source' (ViewID) member of 'ScrollTimelineOptions'");
return {};
}
auto& _source = *maybe___source;
// Sentinel = 'source'
if ((!((aReader)->ReadSentinel(154665618)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'source' (ViewID) member of 'ScrollTimelineOptions'");
return {};
}
auto maybe___axis = IPC::ReadParam<::mozilla::layers::ScrollDirection>(aReader);
if (!maybe___axis) {
aReader->FatalError("Error deserializing 'axis' (ScrollDirection) member of 'ScrollTimelineOptions'");
return {};
}
auto& _axis = *maybe___axis;
// Sentinel = 'axis'
if ((!((aReader)->ReadSentinel(70582710)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'axis' (ScrollDirection) member of 'ScrollTimelineOptions'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_source),
std::move(_axis)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct Animation|
//
namespace mozilla {
namespace layers {
auto Animation::StaticAssertions() const -> void
{
static_assert(
(offsetof(Animation, previousPlaybackRate_) - offsetof(Animation, iterations_)) == 12,
"Bad assumptions about field layout!");
static_assert(
(offsetof(Animation, iterationComposite_) - offsetof(Animation, direction_)) == 2,
"Bad assumptions about field layout!");
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::Animation>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).originTime());
// Sentinel = 'originTime'
(aWriter)->WriteSentinel(383845400);
IPC::WriteParam(aWriter, (aVar).startTime());
// Sentinel = 'startTime'
(aWriter)->WriteSentinel(320144318);
IPC::WriteParam(aWriter, (aVar).delay());
// Sentinel = 'delay'
(aWriter)->WriteSentinel(101450256);
IPC::WriteParam(aWriter, (aVar).endDelay());
// Sentinel = 'endDelay'
(aWriter)->WriteSentinel(233898791);
IPC::WriteParam(aWriter, (aVar).holdTime());
// Sentinel = 'holdTime'
(aWriter)->WriteSentinel(244777783);
IPC::WriteParam(aWriter, (aVar).duration());
// Sentinel = 'duration'
(aWriter)->WriteSentinel(256050023);
IPC::WriteParam(aWriter, (aVar).segments());
// Sentinel = 'segments'
(aWriter)->WriteSentinel(254215015);
IPC::WriteParam(aWriter, (aVar).property());
// Sentinel = 'property'
(aWriter)->WriteSentinel(263914374);
IPC::WriteParam(aWriter, (aVar).easingFunction());
// Sentinel = 'easingFunction'
(aWriter)->WriteSentinel(714081726);
IPC::WriteParam(aWriter, (aVar).isNotPlaying());
// Sentinel = 'isNotPlaying'
(aWriter)->WriteSentinel(528155874);
IPC::WriteParam(aWriter, (aVar).isNotAnimating());
// Sentinel = 'isNotAnimating'
(aWriter)->WriteSentinel(703661478);
IPC::WriteParam(aWriter, (aVar).baseStyle());
// Sentinel = 'baseStyle'
(aWriter)->WriteSentinel(303891373);
IPC::WriteParam(aWriter, (aVar).transformData());
// Sentinel = 'transformData'
(aWriter)->WriteSentinel(642581847);
IPC::WriteParam(aWriter, (aVar).replacedTransitionId());
// Sentinel = 'replacedTransitionId'
(aWriter)->WriteSentinel(1437861913);
IPC::WriteParam(aWriter, (aVar).scrollTimelineOptions());
// Sentinel = 'scrollTimelineOptions'
(aWriter)->WriteSentinel(1601177779);
(aWriter)->WriteBytes((&((aVar).iterations())), 16);
// Sentinel = 'iterations | iterationStart | playbackRate | previousPlaybackRate'
(aWriter)->WriteSentinel(1175198039);
(aWriter)->WriteBytes((&((aVar).direction())), 3);
// Sentinel = 'direction | fillMode | iterationComposite'
(aWriter)->WriteSentinel(1216810984);
}
auto ParamTraits<::mozilla::layers::Animation>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___originTime = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___originTime) {
aReader->FatalError("Error deserializing 'originTime' (TimeStamp) member of 'Animation'");
return {};
}
auto& _originTime = *maybe___originTime;
// Sentinel = 'originTime'
if ((!((aReader)->ReadSentinel(383845400)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'originTime' (TimeStamp) member of 'Animation'");
return {};
}
auto maybe___startTime = IPC::ReadParam<mozilla::Maybe<::mozilla::TimeDuration>>(aReader);
if (!maybe___startTime) {
aReader->FatalError("Error deserializing 'startTime' (TimeDuration?) member of 'Animation'");
return {};
}
auto& _startTime = *maybe___startTime;
// Sentinel = 'startTime'
if ((!((aReader)->ReadSentinel(320144318)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'startTime' (TimeDuration?) member of 'Animation'");
return {};
}
auto maybe___delay = IPC::ReadParam<::mozilla::TimeDuration>(aReader);
if (!maybe___delay) {
aReader->FatalError("Error deserializing 'delay' (TimeDuration) member of 'Animation'");
return {};
}
auto& _delay = *maybe___delay;
// Sentinel = 'delay'
if ((!((aReader)->ReadSentinel(101450256)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'delay' (TimeDuration) member of 'Animation'");
return {};
}
auto maybe___endDelay = IPC::ReadParam<::mozilla::TimeDuration>(aReader);
if (!maybe___endDelay) {
aReader->FatalError("Error deserializing 'endDelay' (TimeDuration) member of 'Animation'");
return {};
}
auto& _endDelay = *maybe___endDelay;
// Sentinel = 'endDelay'
if ((!((aReader)->ReadSentinel(233898791)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'endDelay' (TimeDuration) member of 'Animation'");
return {};
}
auto maybe___holdTime = IPC::ReadParam<::mozilla::TimeDuration>(aReader);
if (!maybe___holdTime) {
aReader->FatalError("Error deserializing 'holdTime' (TimeDuration) member of 'Animation'");
return {};
}
auto& _holdTime = *maybe___holdTime;
// Sentinel = 'holdTime'
if ((!((aReader)->ReadSentinel(244777783)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'holdTime' (TimeDuration) member of 'Animation'");
return {};
}
auto maybe___duration = IPC::ReadParam<::mozilla::TimeDuration>(aReader);
if (!maybe___duration) {
aReader->FatalError("Error deserializing 'duration' (TimeDuration) member of 'Animation'");
return {};
}
auto& _duration = *maybe___duration;
// Sentinel = 'duration'
if ((!((aReader)->ReadSentinel(256050023)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'duration' (TimeDuration) member of 'Animation'");
return {};
}
auto maybe___segments = IPC::ReadParam<nsTArray<::mozilla::layers::AnimationSegment>>(aReader);
if (!maybe___segments) {
aReader->FatalError("Error deserializing 'segments' (AnimationSegment[]) member of 'Animation'");
return {};
}
auto& _segments = *maybe___segments;
// Sentinel = 'segments'
if ((!((aReader)->ReadSentinel(254215015)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'segments' (AnimationSegment[]) member of 'Animation'");
return {};
}
auto maybe___property = IPC::ReadParam<::nsCSSPropertyID>(aReader);
if (!maybe___property) {
aReader->FatalError("Error deserializing 'property' (nsCSSPropertyID) member of 'Animation'");
return {};
}
auto& _property = *maybe___property;
// Sentinel = 'property'
if ((!((aReader)->ReadSentinel(263914374)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'property' (nsCSSPropertyID) member of 'Animation'");
return {};
}
auto maybe___easingFunction = IPC::ReadParam<mozilla::Maybe<::mozilla::StyleComputedTimingFunction>>(aReader);
if (!maybe___easingFunction) {
aReader->FatalError("Error deserializing 'easingFunction' (StyleComputedTimingFunction?) member of 'Animation'");
return {};
}
auto& _easingFunction = *maybe___easingFunction;
// Sentinel = 'easingFunction'
if ((!((aReader)->ReadSentinel(714081726)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'easingFunction' (StyleComputedTimingFunction?) member of 'Animation'");
return {};
}
auto maybe___isNotPlaying = IPC::ReadParam<bool>(aReader);
if (!maybe___isNotPlaying) {
aReader->FatalError("Error deserializing 'isNotPlaying' (bool) member of 'Animation'");
return {};
}
auto& _isNotPlaying = *maybe___isNotPlaying;
// Sentinel = 'isNotPlaying'
if ((!((aReader)->ReadSentinel(528155874)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isNotPlaying' (bool) member of 'Animation'");
return {};
}
auto maybe___isNotAnimating = IPC::ReadParam<bool>(aReader);
if (!maybe___isNotAnimating) {
aReader->FatalError("Error deserializing 'isNotAnimating' (bool) member of 'Animation'");
return {};
}
auto& _isNotAnimating = *maybe___isNotAnimating;
// Sentinel = 'isNotAnimating'
if ((!((aReader)->ReadSentinel(703661478)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isNotAnimating' (bool) member of 'Animation'");
return {};
}
auto maybe___baseStyle = IPC::ReadParam<::mozilla::layers::Animatable>(aReader);
if (!maybe___baseStyle) {
aReader->FatalError("Error deserializing 'baseStyle' (Animatable) member of 'Animation'");
return {};
}
auto& _baseStyle = *maybe___baseStyle;
// Sentinel = 'baseStyle'
if ((!((aReader)->ReadSentinel(303891373)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'baseStyle' (Animatable) member of 'Animation'");
return {};
}
auto maybe___transformData = IPC::ReadParam<mozilla::Maybe<::mozilla::layers::TransformData>>(aReader);
if (!maybe___transformData) {
aReader->FatalError("Error deserializing 'transformData' (TransformData?) member of 'Animation'");
return {};
}
auto& _transformData = *maybe___transformData;
// Sentinel = 'transformData'
if ((!((aReader)->ReadSentinel(642581847)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'transformData' (TransformData?) member of 'Animation'");
return {};
}
auto maybe___replacedTransitionId = IPC::ReadParam<mozilla::Maybe<::uint64_t>>(aReader);
if (!maybe___replacedTransitionId) {
aReader->FatalError("Error deserializing 'replacedTransitionId' (uint64_t?) member of 'Animation'");
return {};
}
auto& _replacedTransitionId = *maybe___replacedTransitionId;
// Sentinel = 'replacedTransitionId'
if ((!((aReader)->ReadSentinel(1437861913)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'replacedTransitionId' (uint64_t?) member of 'Animation'");
return {};
}
auto maybe___scrollTimelineOptions = IPC::ReadParam<mozilla::Maybe<::mozilla::layers::ScrollTimelineOptions>>(aReader);
if (!maybe___scrollTimelineOptions) {
aReader->FatalError("Error deserializing 'scrollTimelineOptions' (ScrollTimelineOptions?) member of 'Animation'");
return {};
}
auto& _scrollTimelineOptions = *maybe___scrollTimelineOptions;
// Sentinel = 'scrollTimelineOptions'
if ((!((aReader)->ReadSentinel(1601177779)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'scrollTimelineOptions' (ScrollTimelineOptions?) member of 'Animation'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_originTime),
std::move(_startTime),
std::move(_delay),
std::move(_endDelay),
std::move(_holdTime),
std::move(_duration),
std::move(_segments),
float{0},
float{0},
::uint8_t{0},
::uint8_t{0},
std::move(_property),
float{0},
float{0},
std::move(_easingFunction),
::uint8_t{0},
std::move(_isNotPlaying),
std::move(_isNotAnimating),
std::move(_baseStyle),
std::move(_transformData),
std::move(_replacedTransitionId),
std::move(_scrollTimelineOptions)};
if ((!((aReader)->ReadBytesInto((&((result__)->iterations())), 16)))) {
aReader->FatalError("Error bulk reading fields from float");
return {};
}
// Sentinel = 'iterations | iterationStart | playbackRate | previousPlaybackRate'
if ((!((aReader)->ReadSentinel(1175198039)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from float");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->direction())), 3)))) {
aReader->FatalError("Error bulk reading fields from uint8_t");
return {};
}
// Sentinel = 'direction | fillMode | iterationComposite'
if ((!((aReader)->ReadSentinel(1216810984)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint8_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CompositorAnimations|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::CompositorAnimations>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).animations());
// Sentinel = 'animations'
(aWriter)->WriteSentinel(381617204);
(aWriter)->WriteBytes((&((aVar).id())), 8);
// Sentinel = 'id'
(aWriter)->WriteSentinel(20447438);
}
auto ParamTraits<::mozilla::layers::CompositorAnimations>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___animations = IPC::ReadParam<nsTArray<::mozilla::layers::Animation>>(aReader);
if (!maybe___animations) {
aReader->FatalError("Error deserializing 'animations' (Animation[]) member of 'CompositorAnimations'");
return {};
}
auto& _animations = *maybe___animations;
// Sentinel = 'animations'
if ((!((aReader)->ReadSentinel(381617204)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'animations' (Animation[]) member of 'CompositorAnimations'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_animations),
::uint64_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->id())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'id'
if ((!((aReader)->ReadSentinel(20447438)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct UntrustedShmemSection|
//
namespace mozilla {
namespace layers {
auto UntrustedShmemSection::StaticAssertions() const -> void
{
static_assert(
(offsetof(UntrustedShmemSection, size_) - offsetof(UntrustedShmemSection, offset_)) == 4,
"Bad assumptions about field layout!");
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::UntrustedShmemSection>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, std::move((aVar).shmem()));
// Sentinel = 'shmem'
(aWriter)->WriteSentinel(107086363);
(aWriter)->WriteBytes((&((aVar).offset())), 8);
// Sentinel = 'offset | size'
(aWriter)->WriteSentinel(592250111);
}
auto ParamTraits<::mozilla::layers::UntrustedShmemSection>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___shmem = IPC::ReadParam<::mozilla::ipc::Shmem>(aReader);
if (!maybe___shmem) {
aReader->FatalError("Error deserializing 'shmem' (Shmem) member of 'UntrustedShmemSection'");
return {};
}
auto& _shmem = *maybe___shmem;
// Sentinel = 'shmem'
if ((!((aReader)->ReadSentinel(107086363)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'shmem' (Shmem) member of 'UntrustedShmemSection'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_shmem),
::uint32_t{0},
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->offset())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'offset | size'
if ((!((aReader)->ReadSentinel(592250111)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CrossProcessSemaphoreDescriptor|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::CrossProcessSemaphoreDescriptor>::Write(
IPC::MessageWriter* aWriter,
paramType&& aVar) -> void
{
IPC::WriteParam(aWriter, std::move((aVar).sem()));
// Sentinel = 'sem'
(aWriter)->WriteSentinel(43188550);
}
auto ParamTraits<::mozilla::layers::CrossProcessSemaphoreDescriptor>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___sem = IPC::ReadParam<::mozilla::CrossProcessSemaphoreHandle>(aReader);
if (!maybe___sem) {
aReader->FatalError("Error deserializing 'sem' (CrossProcessSemaphoreHandle) member of 'CrossProcessSemaphoreDescriptor'");
return {};
}
auto& _sem = *maybe___sem;
// Sentinel = 'sem'
if ((!((aReader)->ReadSentinel(43188550)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'sem' (CrossProcessSemaphoreHandle) member of 'CrossProcessSemaphoreDescriptor'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_sem)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ReadLockDescriptor|
//
namespace mozilla {
namespace layers {
auto ReadLockDescriptor::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TUntrustedShmemSection:
{
(ptr_UntrustedShmemSection())->~UntrustedShmemSection__tdef();
break;
}
case TCrossProcessSemaphoreDescriptor:
{
(ptr_CrossProcessSemaphoreDescriptor())->~CrossProcessSemaphoreDescriptor__tdef();
break;
}
case Tuintptr_t:
{
(ptr_uintptr_t())->~uintptr_t__tdef();
break;
}
case Tnull_t:
{
(ptr_null_t())->~null_t__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(const UntrustedShmemSection& aOther)
{
new (mozilla::KnownNotNull, ptr_UntrustedShmemSection()) UntrustedShmemSection(aOther);
mType = TUntrustedShmemSection;
}
MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(UntrustedShmemSection&& aOther)
{
new (mozilla::KnownNotNull, ptr_UntrustedShmemSection()) UntrustedShmemSection(std::move(aOther));
mType = TUntrustedShmemSection;
}
MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(CrossProcessSemaphoreDescriptor&& aOther)
{
new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor(std::move(aOther));
mType = TCrossProcessSemaphoreDescriptor;
}
MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(const uintptr_t& aOther)
{
new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t(aOther);
mType = Tuintptr_t;
}
MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(uintptr_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t(std::move(aOther));
mType = Tuintptr_t;
}
MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(const null_t& aOther)
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
mType = Tnull_t;
}
MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(null_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aOther));
mType = Tnull_t;
}
MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(ReadLockDescriptor&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TUntrustedShmemSection:
{
new (mozilla::KnownNotNull, ptr_UntrustedShmemSection()) UntrustedShmemSection(std::move((aOther).get_UntrustedShmemSection()));
(aOther).MaybeDestroy();
break;
}
case TCrossProcessSemaphoreDescriptor:
{
new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor(std::move((aOther).get_CrossProcessSemaphoreDescriptor()));
(aOther).MaybeDestroy();
break;
}
case Tuintptr_t:
{
new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t(std::move((aOther).get_uintptr_t()));
(aOther).MaybeDestroy();
break;
}
case Tnull_t:
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_t()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
ReadLockDescriptor::~ReadLockDescriptor()
{
MaybeDestroy();
}
auto ReadLockDescriptor::operator=(const UntrustedShmemSection& aRhs) -> ReadLockDescriptor&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_UntrustedShmemSection()) UntrustedShmemSection(aRhs);
mType = TUntrustedShmemSection;
return (*(this));
}
auto ReadLockDescriptor::operator=(UntrustedShmemSection&& aRhs) -> ReadLockDescriptor&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_UntrustedShmemSection()) UntrustedShmemSection(std::move(aRhs));
mType = TUntrustedShmemSection;
return (*(this));
}
auto ReadLockDescriptor::operator=(CrossProcessSemaphoreDescriptor&& aRhs) -> ReadLockDescriptor&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor(std::move(aRhs));
mType = TCrossProcessSemaphoreDescriptor;
return (*(this));
}
auto ReadLockDescriptor::operator=(const uintptr_t& aRhs) -> ReadLockDescriptor&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t(aRhs);
mType = Tuintptr_t;
return (*(this));
}
auto ReadLockDescriptor::operator=(uintptr_t&& aRhs) -> ReadLockDescriptor&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t(std::move(aRhs));
mType = Tuintptr_t;
return (*(this));
}
auto ReadLockDescriptor::operator=(const null_t& aRhs) -> ReadLockDescriptor&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t(aRhs);
mType = Tnull_t;
return (*(this));
}
auto ReadLockDescriptor::operator=(null_t&& aRhs) -> ReadLockDescriptor&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aRhs));
mType = Tnull_t;
return (*(this));
}
auto ReadLockDescriptor::operator=(ReadLockDescriptor&& aRhs) -> ReadLockDescriptor&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TUntrustedShmemSection:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_UntrustedShmemSection()) UntrustedShmemSection(std::move((aRhs).get_UntrustedShmemSection()));
(aRhs).MaybeDestroy();
break;
}
case TCrossProcessSemaphoreDescriptor:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor(std::move((aRhs).get_CrossProcessSemaphoreDescriptor()));
(aRhs).MaybeDestroy();
break;
}
case Tuintptr_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t(std::move((aRhs).get_uintptr_t()));
(aRhs).MaybeDestroy();
break;
}
case Tnull_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aRhs).get_null_t()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::ReadLockDescriptor>::Write(
IPC::MessageWriter* aWriter,
paramType&& aVar) -> void
{
typedef ::mozilla::layers::ReadLockDescriptor union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'ReadLockDescriptor'
(aWriter)->WriteSentinel(1093011237);
switch (type) {
case union__::TUntrustedShmemSection:
{
IPC::WriteParam(aWriter, (aVar).get_UntrustedShmemSection());
// Sentinel = 'TUntrustedShmemSection'
(aWriter)->WriteSentinel(1716914418);
return;
}
case union__::TCrossProcessSemaphoreDescriptor:
{
IPC::WriteParam(aWriter, std::move((aVar).get_CrossProcessSemaphoreDescriptor()));
// Sentinel = 'TCrossProcessSemaphoreDescriptor'
(aWriter)->WriteSentinel(3536981249);
return;
}
case union__::Tuintptr_t:
{
IPC::WriteParam(aWriter, (aVar).get_uintptr_t());
// Sentinel = 'Tuintptr_t'
(aWriter)->WriteSentinel(385418302);
return;
}
case union__::Tnull_t:
{
IPC::WriteParam(aWriter, (aVar).get_null_t());
// Sentinel = 'Tnull_t'
(aWriter)->WriteSentinel(190186211);
return;
}
default:
{
aWriter->FatalError("unknown variant of union ReadLockDescriptor");
return;
}
}
}
auto ParamTraits<::mozilla::layers::ReadLockDescriptor>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::layers::ReadLockDescriptor union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union ReadLockDescriptor");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'ReadLockDescriptor'
if ((!((aReader)->ReadSentinel(1093011237)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union ReadLockDescriptor");
return {};
}
switch (type) {
case union__::TUntrustedShmemSection:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::layers::UntrustedShmemSection>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TUntrustedShmemSection of union ReadLockDescriptor");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TUntrustedShmemSection'
if ((!((aReader)->ReadSentinel(1716914418)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TUntrustedShmemSection of union ReadLockDescriptor");
return {};
}
return std::move(tmp);
}
case union__::TCrossProcessSemaphoreDescriptor:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::layers::CrossProcessSemaphoreDescriptor>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCrossProcessSemaphoreDescriptor of union ReadLockDescriptor");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCrossProcessSemaphoreDescriptor'
if ((!((aReader)->ReadSentinel(3536981249)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCrossProcessSemaphoreDescriptor of union ReadLockDescriptor");
return {};
}
return std::move(tmp);
}
case union__::Tuintptr_t:
{
auto maybe__tmp = IPC::ReadParam<::uintptr_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tuintptr_t of union ReadLockDescriptor");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tuintptr_t'
if ((!((aReader)->ReadSentinel(385418302)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tuintptr_t of union ReadLockDescriptor");
return {};
}
return std::move(tmp);
}
case union__::Tnull_t:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::null_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnull_t of union ReadLockDescriptor");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnull_t'
if ((!((aReader)->ReadSentinel(190186211)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union ReadLockDescriptor");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union ReadLockDescriptor");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpRemoveTexture|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::OpRemoveTexture>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).texture());
// Sentinel = 'texture'
(aWriter)->WriteSentinel(207684370);
}
auto ParamTraits<::mozilla::layers::OpRemoveTexture>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___texture = IPC::ReadParam<mozilla::NotNull<::mozilla::ipc::SideVariant<::mozilla::layers::PTextureParent*, ::mozilla::layers::PTextureChild*>>>(aReader);
if (!maybe___texture) {
aReader->FatalError("Error deserializing 'texture' (NotNull<PTexture>) member of 'OpRemoveTexture'");
return {};
}
auto& _texture = *maybe___texture;
// Sentinel = 'texture'
if ((!((aReader)->ReadSentinel(207684370)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'texture' (NotNull<PTexture>) member of 'OpRemoveTexture'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_texture)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct TimedTexture|
//
namespace mozilla {
namespace layers {
auto TimedTexture::StaticAssertions() const -> void
{
static_assert(
(offsetof(TimedTexture, producerID_) - offsetof(TimedTexture, frameID_)) == 4,
"Bad assumptions about field layout!");
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::TimedTexture>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).texture());
// Sentinel = 'texture'
(aWriter)->WriteSentinel(207684370);
IPC::WriteParam(aWriter, (aVar).timeStamp());
// Sentinel = 'timeStamp'
(aWriter)->WriteSentinel(312083381);
IPC::WriteParam(aWriter, (aVar).picture());
// Sentinel = 'picture'
(aWriter)->WriteSentinel(200540925);
IPC::WriteParam(aWriter, (aVar).readLocked());
// Sentinel = 'readLocked'
(aWriter)->WriteSentinel(364708847);
(aWriter)->WriteBytes((&((aVar).frameID())), 8);
// Sentinel = 'frameID | producerID'
(aWriter)->WriteSentinel(1286801222);
}
auto ParamTraits<::mozilla::layers::TimedTexture>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___texture = IPC::ReadParam<mozilla::NotNull<::mozilla::ipc::SideVariant<::mozilla::layers::PTextureParent*, ::mozilla::layers::PTextureChild*>>>(aReader);
if (!maybe___texture) {
aReader->FatalError("Error deserializing 'texture' (NotNull<PTexture>) member of 'TimedTexture'");
return {};
}
auto& _texture = *maybe___texture;
// Sentinel = 'texture'
if ((!((aReader)->ReadSentinel(207684370)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'texture' (NotNull<PTexture>) member of 'TimedTexture'");
return {};
}
auto maybe___timeStamp = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___timeStamp) {
aReader->FatalError("Error deserializing 'timeStamp' (TimeStamp) member of 'TimedTexture'");
return {};
}
auto& _timeStamp = *maybe___timeStamp;
// Sentinel = 'timeStamp'
if ((!((aReader)->ReadSentinel(312083381)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'timeStamp' (TimeStamp) member of 'TimedTexture'");
return {};
}
auto maybe___picture = IPC::ReadParam<::mozilla::gfx::IntRect>(aReader);
if (!maybe___picture) {
aReader->FatalError("Error deserializing 'picture' (IntRect) member of 'TimedTexture'");
return {};
}
auto& _picture = *maybe___picture;
// Sentinel = 'picture'
if ((!((aReader)->ReadSentinel(200540925)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'picture' (IntRect) member of 'TimedTexture'");
return {};
}
auto maybe___readLocked = IPC::ReadParam<bool>(aReader);
if (!maybe___readLocked) {
aReader->FatalError("Error deserializing 'readLocked' (bool) member of 'TimedTexture'");
return {};
}
auto& _readLocked = *maybe___readLocked;
// Sentinel = 'readLocked'
if ((!((aReader)->ReadSentinel(364708847)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'readLocked' (bool) member of 'TimedTexture'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_texture),
std::move(_timeStamp),
std::move(_picture),
::uint32_t{0},
::uint32_t{0},
std::move(_readLocked)};
if ((!((aReader)->ReadBytesInto((&((result__)->frameID())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'frameID | producerID'
if ((!((aReader)->ReadSentinel(1286801222)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpUseTexture|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::OpUseTexture>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).textures());
// Sentinel = 'textures'
(aWriter)->WriteSentinel(266732421);
}
auto ParamTraits<::mozilla::layers::OpUseTexture>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___textures = IPC::ReadParam<nsTArray<::mozilla::layers::TimedTexture>>(aReader);
if (!maybe___textures) {
aReader->FatalError("Error deserializing 'textures' (TimedTexture[]) member of 'OpUseTexture'");
return {};
}
auto& _textures = *maybe___textures;
// Sentinel = 'textures'
if ((!((aReader)->ReadSentinel(266732421)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'textures' (TimedTexture[]) member of 'OpUseTexture'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_textures)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpUseRemoteTexture|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::OpUseRemoteTexture>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).textureId());
// Sentinel = 'textureId'
(aWriter)->WriteSentinel(326828991);
IPC::WriteParam(aWriter, (aVar).ownerId());
// Sentinel = 'ownerId'
(aWriter)->WriteSentinel(199230169);
IPC::WriteParam(aWriter, (aVar).size());
// Sentinel = 'size'
(aWriter)->WriteSentinel(73662908);
IPC::WriteParam(aWriter, (aVar).textureFlags());
// Sentinel = 'textureFlags'
(aWriter)->WriteSentinel(556598527);
}
auto ParamTraits<::mozilla::layers::OpUseRemoteTexture>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___textureId = IPC::ReadParam<::mozilla::layers::RemoteTextureId>(aReader);
if (!maybe___textureId) {
aReader->FatalError("Error deserializing 'textureId' (RemoteTextureId) member of 'OpUseRemoteTexture'");
return {};
}
auto& _textureId = *maybe___textureId;
// Sentinel = 'textureId'
if ((!((aReader)->ReadSentinel(326828991)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'textureId' (RemoteTextureId) member of 'OpUseRemoteTexture'");
return {};
}
auto maybe___ownerId = IPC::ReadParam<::mozilla::layers::RemoteTextureOwnerId>(aReader);
if (!maybe___ownerId) {
aReader->FatalError("Error deserializing 'ownerId' (RemoteTextureOwnerId) member of 'OpUseRemoteTexture'");
return {};
}
auto& _ownerId = *maybe___ownerId;
// Sentinel = 'ownerId'
if ((!((aReader)->ReadSentinel(199230169)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ownerId' (RemoteTextureOwnerId) member of 'OpUseRemoteTexture'");
return {};
}
auto maybe___size = IPC::ReadParam<::mozilla::gfx::IntSize>(aReader);
if (!maybe___size) {
aReader->FatalError("Error deserializing 'size' (IntSize) member of 'OpUseRemoteTexture'");
return {};
}
auto& _size = *maybe___size;
// Sentinel = 'size'
if ((!((aReader)->ReadSentinel(73662908)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'OpUseRemoteTexture'");
return {};
}
auto maybe___textureFlags = IPC::ReadParam<::mozilla::layers::TextureFlags>(aReader);
if (!maybe___textureFlags) {
aReader->FatalError("Error deserializing 'textureFlags' (TextureFlags) member of 'OpUseRemoteTexture'");
return {};
}
auto& _textureFlags = *maybe___textureFlags;
// Sentinel = 'textureFlags'
if ((!((aReader)->ReadSentinel(556598527)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'textureFlags' (TextureFlags) member of 'OpUseRemoteTexture'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_textureId),
std::move(_ownerId),
std::move(_size),
std::move(_textureFlags)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpEnableRemoteTexturePushCallback|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::OpEnableRemoteTexturePushCallback>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).ownerId());
// Sentinel = 'ownerId'
(aWriter)->WriteSentinel(199230169);
IPC::WriteParam(aWriter, (aVar).size());
// Sentinel = 'size'
(aWriter)->WriteSentinel(73662908);
IPC::WriteParam(aWriter, (aVar).textureFlags());
// Sentinel = 'textureFlags'
(aWriter)->WriteSentinel(556598527);
}
auto ParamTraits<::mozilla::layers::OpEnableRemoteTexturePushCallback>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___ownerId = IPC::ReadParam<::mozilla::layers::RemoteTextureOwnerId>(aReader);
if (!maybe___ownerId) {
aReader->FatalError("Error deserializing 'ownerId' (RemoteTextureOwnerId) member of 'OpEnableRemoteTexturePushCallback'");
return {};
}
auto& _ownerId = *maybe___ownerId;
// Sentinel = 'ownerId'
if ((!((aReader)->ReadSentinel(199230169)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ownerId' (RemoteTextureOwnerId) member of 'OpEnableRemoteTexturePushCallback'");
return {};
}
auto maybe___size = IPC::ReadParam<::mozilla::gfx::IntSize>(aReader);
if (!maybe___size) {
aReader->FatalError("Error deserializing 'size' (IntSize) member of 'OpEnableRemoteTexturePushCallback'");
return {};
}
auto& _size = *maybe___size;
// Sentinel = 'size'
if ((!((aReader)->ReadSentinel(73662908)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'OpEnableRemoteTexturePushCallback'");
return {};
}
auto maybe___textureFlags = IPC::ReadParam<::mozilla::layers::TextureFlags>(aReader);
if (!maybe___textureFlags) {
aReader->FatalError("Error deserializing 'textureFlags' (TextureFlags) member of 'OpEnableRemoteTexturePushCallback'");
return {};
}
auto& _textureFlags = *maybe___textureFlags;
// Sentinel = 'textureFlags'
if ((!((aReader)->ReadSentinel(556598527)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'textureFlags' (TextureFlags) member of 'OpEnableRemoteTexturePushCallback'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_ownerId),
std::move(_size),
std::move(_textureFlags)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpNotifyNotUsed|
//
namespace mozilla {
namespace layers {
auto OpNotifyNotUsed::StaticAssertions() const -> void
{
static_assert(
(offsetof(OpNotifyNotUsed, fwdTransactionId_) - offsetof(OpNotifyNotUsed, TextureId_)) == 8,
"Bad assumptions about field layout!");
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::OpNotifyNotUsed>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
(aWriter)->WriteBytes((&((aVar).TextureId())), 16);
// Sentinel = 'TextureId | fwdTransactionId'
(aWriter)->WriteSentinel(2613906127);
}
auto ParamTraits<::mozilla::layers::OpNotifyNotUsed>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{
std::in_place,
::uint64_t{0},
::uint64_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->TextureId())), 16)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'TextureId | fwdTransactionId'
if ((!((aReader)->ReadSentinel(2613906127)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union CompositableOperationDetail|
//
namespace mozilla {
namespace layers {
auto CompositableOperationDetail::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TOpRemoveTexture:
{
(ptr_OpRemoveTexture())->~OpRemoveTexture__tdef();
break;
}
case TOpUseTexture:
{
(ptr_OpUseTexture())->~OpUseTexture__tdef();
break;
}
case TOpUseRemoteTexture:
{
(ptr_OpUseRemoteTexture())->~OpUseRemoteTexture__tdef();
break;
}
case TOpEnableRemoteTexturePushCallback:
{
(ptr_OpEnableRemoteTexturePushCallback())->~OpEnableRemoteTexturePushCallback__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpRemoveTexture& aOther)
{
new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture(aOther);
mType = TOpRemoveTexture;
}
MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(OpRemoveTexture&& aOther)
{
new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture(std::move(aOther));
mType = TOpRemoveTexture;
}
MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpUseTexture& aOther)
{
new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture(aOther);
mType = TOpUseTexture;
}
MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(OpUseTexture&& aOther)
{
new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture(std::move(aOther));
mType = TOpUseTexture;
}
MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpUseRemoteTexture& aOther)
{
new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture(aOther);
mType = TOpUseRemoteTexture;
}
MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(OpUseRemoteTexture&& aOther)
{
new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture(std::move(aOther));
mType = TOpUseRemoteTexture;
}
MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpEnableRemoteTexturePushCallback& aOther)
{
new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback(aOther);
mType = TOpEnableRemoteTexturePushCallback;
}
MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(OpEnableRemoteTexturePushCallback&& aOther)
{
new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback(std::move(aOther));
mType = TOpEnableRemoteTexturePushCallback;
}
MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const CompositableOperationDetail& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TOpRemoveTexture:
{
new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture((aOther).get_OpRemoveTexture());
break;
}
case TOpUseTexture:
{
new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture((aOther).get_OpUseTexture());
break;
}
case TOpUseRemoteTexture:
{
new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture((aOther).get_OpUseRemoteTexture());
break;
}
case TOpEnableRemoteTexturePushCallback:
{
new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback((aOther).get_OpEnableRemoteTexturePushCallback());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(CompositableOperationDetail&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TOpRemoveTexture:
{
new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture(std::move((aOther).get_OpRemoveTexture()));
(aOther).MaybeDestroy();
break;
}
case TOpUseTexture:
{
new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture(std::move((aOther).get_OpUseTexture()));
(aOther).MaybeDestroy();
break;
}
case TOpUseRemoteTexture:
{
new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture(std::move((aOther).get_OpUseRemoteTexture()));
(aOther).MaybeDestroy();
break;
}
case TOpEnableRemoteTexturePushCallback:
{
new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback(std::move((aOther).get_OpEnableRemoteTexturePushCallback()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
CompositableOperationDetail::~CompositableOperationDetail()
{
MaybeDestroy();
}
auto CompositableOperationDetail::operator=(const OpRemoveTexture& aRhs) -> CompositableOperationDetail&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture(aRhs);
mType = TOpRemoveTexture;
return (*(this));
}
auto CompositableOperationDetail::operator=(OpRemoveTexture&& aRhs) -> CompositableOperationDetail&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture(std::move(aRhs));
mType = TOpRemoveTexture;
return (*(this));
}
auto CompositableOperationDetail::operator=(const OpUseTexture& aRhs) -> CompositableOperationDetail&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture(aRhs);
mType = TOpUseTexture;
return (*(this));
}
auto CompositableOperationDetail::operator=(OpUseTexture&& aRhs) -> CompositableOperationDetail&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture(std::move(aRhs));
mType = TOpUseTexture;
return (*(this));
}
auto CompositableOperationDetail::operator=(const OpUseRemoteTexture& aRhs) -> CompositableOperationDetail&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture(aRhs);
mType = TOpUseRemoteTexture;
return (*(this));
}
auto CompositableOperationDetail::operator=(OpUseRemoteTexture&& aRhs) -> CompositableOperationDetail&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture(std::move(aRhs));
mType = TOpUseRemoteTexture;
return (*(this));
}
auto CompositableOperationDetail::operator=(const OpEnableRemoteTexturePushCallback& aRhs) -> CompositableOperationDetail&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback(aRhs);
mType = TOpEnableRemoteTexturePushCallback;
return (*(this));
}
auto CompositableOperationDetail::operator=(OpEnableRemoteTexturePushCallback&& aRhs) -> CompositableOperationDetail&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback(std::move(aRhs));
mType = TOpEnableRemoteTexturePushCallback;
return (*(this));
}
auto CompositableOperationDetail::operator=(const CompositableOperationDetail& aRhs) -> CompositableOperationDetail&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TOpRemoveTexture:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture((aRhs).get_OpRemoveTexture());
break;
}
case TOpUseTexture:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture((aRhs).get_OpUseTexture());
break;
}
case TOpUseRemoteTexture:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture((aRhs).get_OpUseRemoteTexture());
break;
}
case TOpEnableRemoteTexturePushCallback:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback((aRhs).get_OpEnableRemoteTexturePushCallback());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto CompositableOperationDetail::operator=(CompositableOperationDetail&& aRhs) -> CompositableOperationDetail&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TOpRemoveTexture:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture(std::move((aRhs).get_OpRemoveTexture()));
(aRhs).MaybeDestroy();
break;
}
case TOpUseTexture:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture(std::move((aRhs).get_OpUseTexture()));
(aRhs).MaybeDestroy();
break;
}
case TOpUseRemoteTexture:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpUseRemoteTexture()) OpUseRemoteTexture(std::move((aRhs).get_OpUseRemoteTexture()));
(aRhs).MaybeDestroy();
break;
}
case TOpEnableRemoteTexturePushCallback:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpEnableRemoteTexturePushCallback()) OpEnableRemoteTexturePushCallback(std::move((aRhs).get_OpEnableRemoteTexturePushCallback()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::CompositableOperationDetail>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::layers::CompositableOperationDetail union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'CompositableOperationDetail'
(aWriter)->WriteSentinel(2559314663);
switch (type) {
case union__::TOpRemoveTexture:
{
IPC::WriteParam(aWriter, (aVar).get_OpRemoveTexture());
// Sentinel = 'TOpRemoveTexture'
(aWriter)->WriteSentinel(885261939);
return;
}
case union__::TOpUseTexture:
{
IPC::WriteParam(aWriter, (aVar).get_OpUseTexture());
// Sentinel = 'TOpUseTexture'
(aWriter)->WriteSentinel(584320306);
return;
}
case union__::TOpUseRemoteTexture:
{
IPC::WriteParam(aWriter, (aVar).get_OpUseRemoteTexture());
// Sentinel = 'TOpUseRemoteTexture'
(aWriter)->WriteSentinel(1233192862);
return;
}
case union__::TOpEnableRemoteTexturePushCallback:
{
IPC::WriteParam(aWriter, (aVar).get_OpEnableRemoteTexturePushCallback());
// Sentinel = 'TOpEnableRemoteTexturePushCallback'
(aWriter)->WriteSentinel(3879472485);
return;
}
default:
{
aWriter->FatalError("unknown variant of union CompositableOperationDetail");
return;
}
}
}
auto ParamTraits<::mozilla::layers::CompositableOperationDetail>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::layers::CompositableOperationDetail union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union CompositableOperationDetail");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'CompositableOperationDetail'
if ((!((aReader)->ReadSentinel(2559314663)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union CompositableOperationDetail");
return {};
}
switch (type) {
case union__::TOpRemoveTexture:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::layers::OpRemoveTexture>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TOpRemoveTexture of union CompositableOperationDetail");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TOpRemoveTexture'
if ((!((aReader)->ReadSentinel(885261939)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TOpRemoveTexture of union CompositableOperationDetail");
return {};
}
return std::move(tmp);
}
case union__::TOpUseTexture:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::layers::OpUseTexture>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TOpUseTexture of union CompositableOperationDetail");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TOpUseTexture'
if ((!((aReader)->ReadSentinel(584320306)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TOpUseTexture of union CompositableOperationDetail");
return {};
}
return std::move(tmp);
}
case union__::TOpUseRemoteTexture:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::layers::OpUseRemoteTexture>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TOpUseRemoteTexture of union CompositableOperationDetail");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TOpUseRemoteTexture'
if ((!((aReader)->ReadSentinel(1233192862)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TOpUseRemoteTexture of union CompositableOperationDetail");
return {};
}
return std::move(tmp);
}
case union__::TOpEnableRemoteTexturePushCallback:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::layers::OpEnableRemoteTexturePushCallback>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TOpEnableRemoteTexturePushCallback of union CompositableOperationDetail");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TOpEnableRemoteTexturePushCallback'
if ((!((aReader)->ReadSentinel(3879472485)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TOpEnableRemoteTexturePushCallback of union CompositableOperationDetail");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union CompositableOperationDetail");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CompositableOperation|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::CompositableOperation>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).compositable());
// Sentinel = 'compositable'
(aWriter)->WriteSentinel(551879939);
IPC::WriteParam(aWriter, (aVar).detail());
// Sentinel = 'detail'
(aWriter)->WriteSentinel(143131252);
}
auto ParamTraits<::mozilla::layers::CompositableOperation>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___compositable = IPC::ReadParam<::mozilla::layers::CompositableHandle>(aReader);
if (!maybe___compositable) {
aReader->FatalError("Error deserializing 'compositable' (CompositableHandle) member of 'CompositableOperation'");
return {};
}
auto& _compositable = *maybe___compositable;
// Sentinel = 'compositable'
if ((!((aReader)->ReadSentinel(551879939)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'compositable' (CompositableHandle) member of 'CompositableOperation'");
return {};
}
auto maybe___detail = IPC::ReadParam<::mozilla::layers::CompositableOperationDetail>(aReader);
if (!maybe___detail) {
aReader->FatalError("Error deserializing 'detail' (CompositableOperationDetail) member of 'CompositableOperation'");
return {};
}
auto& _detail = *maybe___detail;
// Sentinel = 'detail'
if ((!((aReader)->ReadSentinel(143131252)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'detail' (CompositableOperationDetail) member of 'CompositableOperation'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_compositable),
std::move(_detail)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union OpDestroy|
//
namespace mozilla {
namespace layers {
auto OpDestroy::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TPTexture:
{
(ptr_PTexture())->~PTexture__tdef();
break;
}
case TCompositableHandle:
{
(ptr_CompositableHandle())->~CompositableHandle__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT OpDestroy::OpDestroy(const mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>& aOther)
{
new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>(aOther);
mType = TPTexture;
}
MOZ_IMPLICIT OpDestroy::OpDestroy(mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>&& aOther)
{
new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>(std::move(aOther));
mType = TPTexture;
}
MOZ_IMPLICIT OpDestroy::OpDestroy(const CompositableHandle& aOther)
{
new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle(aOther);
mType = TCompositableHandle;
}
MOZ_IMPLICIT OpDestroy::OpDestroy(CompositableHandle&& aOther)
{
new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle(std::move(aOther));
mType = TCompositableHandle;
}
MOZ_IMPLICIT OpDestroy::OpDestroy(const OpDestroy& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TPTexture:
{
new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>((aOther).get_PTexture());
break;
}
case TCompositableHandle:
{
new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle((aOther).get_CompositableHandle());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT OpDestroy::OpDestroy(OpDestroy&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TPTexture:
{
new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>(std::move((aOther).get_PTexture()));
(aOther).MaybeDestroy();
break;
}
case TCompositableHandle:
{
new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle(std::move((aOther).get_CompositableHandle()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
OpDestroy::~OpDestroy()
{
MaybeDestroy();
}
auto OpDestroy::operator=(const mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>& aRhs) -> OpDestroy&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>(aRhs);
mType = TPTexture;
return (*(this));
}
auto OpDestroy::operator=(mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>&& aRhs) -> OpDestroy&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>(std::move(aRhs));
mType = TPTexture;
return (*(this));
}
auto OpDestroy::operator=(const CompositableHandle& aRhs) -> OpDestroy&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle(aRhs);
mType = TCompositableHandle;
return (*(this));
}
auto OpDestroy::operator=(CompositableHandle&& aRhs) -> OpDestroy&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle(std::move(aRhs));
mType = TCompositableHandle;
return (*(this));
}
auto OpDestroy::operator=(const OpDestroy& aRhs) -> OpDestroy&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TPTexture:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>((aRhs).get_PTexture());
break;
}
case TCompositableHandle:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle((aRhs).get_CompositableHandle());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto OpDestroy::operator=(OpDestroy&& aRhs) -> OpDestroy&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TPTexture:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_PTexture()) mozilla::NotNull<::mozilla::ipc::SideVariant<PTextureParent*, PTextureChild*>>(std::move((aRhs).get_PTexture()));
(aRhs).MaybeDestroy();
break;
}
case TCompositableHandle:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle(std::move((aRhs).get_CompositableHandle()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::OpDestroy>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::layers::OpDestroy union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'OpDestroy'
(aWriter)->WriteSentinel(289801130);
switch (type) {
case union__::TPTexture:
{
IPC::WriteParam(aWriter, (aVar).get_PTexture());
// Sentinel = 'TPTexture'
(aWriter)->WriteSentinel(284623766);
return;
}
case union__::TCompositableHandle:
{
IPC::WriteParam(aWriter, (aVar).get_CompositableHandle());
// Sentinel = 'TCompositableHandle'
(aWriter)->WriteSentinel(1252657027);
return;
}
default:
{
aWriter->FatalError("unknown variant of union OpDestroy");
return;
}
}
}
auto ParamTraits<::mozilla::layers::OpDestroy>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::layers::OpDestroy union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union OpDestroy");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'OpDestroy'
if ((!((aReader)->ReadSentinel(289801130)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union OpDestroy");
return {};
}
switch (type) {
case union__::TPTexture:
{
auto maybe__tmp = IPC::ReadParam<mozilla::NotNull<::mozilla::ipc::SideVariant<::mozilla::layers::PTextureParent*, ::mozilla::layers::PTextureChild*>>>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TPTexture of union OpDestroy");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TPTexture'
if ((!((aReader)->ReadSentinel(284623766)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TPTexture of union OpDestroy");
return {};
}
return std::move(tmp);
}
case union__::TCompositableHandle:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::layers::CompositableHandle>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCompositableHandle of union OpDestroy");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCompositableHandle'
if ((!((aReader)->ReadSentinel(1252657027)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCompositableHandle of union OpDestroy");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union OpDestroy");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OpContentBufferSwap|
//
namespace mozilla {
namespace layers {
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::OpContentBufferSwap>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).compositable());
// Sentinel = 'compositable'
(aWriter)->WriteSentinel(551879939);
IPC::WriteParam(aWriter, (aVar).frontUpdatedRegion());
// Sentinel = 'frontUpdatedRegion'
(aWriter)->WriteSentinel(1177618261);
}
auto ParamTraits<::mozilla::layers::OpContentBufferSwap>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___compositable = IPC::ReadParam<::mozilla::layers::CompositableHandle>(aReader);
if (!maybe___compositable) {
aReader->FatalError("Error deserializing 'compositable' (CompositableHandle) member of 'OpContentBufferSwap'");
return {};
}
auto& _compositable = *maybe___compositable;
// Sentinel = 'compositable'
if ((!((aReader)->ReadSentinel(551879939)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'compositable' (CompositableHandle) member of 'OpContentBufferSwap'");
return {};
}
auto maybe___frontUpdatedRegion = IPC::ReadParam<::nsIntRegion>(aReader);
if (!maybe___frontUpdatedRegion) {
aReader->FatalError("Error deserializing 'frontUpdatedRegion' (nsIntRegion) member of 'OpContentBufferSwap'");
return {};
}
auto& _frontUpdatedRegion = *maybe___frontUpdatedRegion;
// Sentinel = 'frontUpdatedRegion'
if ((!((aReader)->ReadSentinel(1177618261)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'frontUpdatedRegion' (nsIntRegion) member of 'OpContentBufferSwap'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_compositable),
std::move(_frontUpdatedRegion)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ImageCompositeNotification|
//
namespace mozilla {
namespace layers {
auto ImageCompositeNotification::StaticAssertions() const -> void
{
static_assert(
(offsetof(ImageCompositeNotification, producerID_) - offsetof(ImageCompositeNotification, frameID_)) == 4,
"Bad assumptions about field layout!");
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::ImageCompositeNotification>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).compositable());
// Sentinel = 'compositable'
(aWriter)->WriteSentinel(551879939);
IPC::WriteParam(aWriter, (aVar).imageTimeStamp());
// Sentinel = 'imageTimeStamp'
(aWriter)->WriteSentinel(699467160);
IPC::WriteParam(aWriter, (aVar).firstCompositeTimeStamp());
// Sentinel = 'firstCompositeTimeStamp'
(aWriter)->WriteSentinel(1910638960);
(aWriter)->WriteBytes((&((aVar).frameID())), 8);
// Sentinel = 'frameID | producerID'
(aWriter)->WriteSentinel(1286801222);
}
auto ParamTraits<::mozilla::layers::ImageCompositeNotification>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___compositable = IPC::ReadParam<::mozilla::layers::CompositableHandle>(aReader);
if (!maybe___compositable) {
aReader->FatalError("Error deserializing 'compositable' (CompositableHandle) member of 'ImageCompositeNotification'");
return {};
}
auto& _compositable = *maybe___compositable;
// Sentinel = 'compositable'
if ((!((aReader)->ReadSentinel(551879939)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'compositable' (CompositableHandle) member of 'ImageCompositeNotification'");
return {};
}
auto maybe___imageTimeStamp = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___imageTimeStamp) {
aReader->FatalError("Error deserializing 'imageTimeStamp' (TimeStamp) member of 'ImageCompositeNotification'");
return {};
}
auto& _imageTimeStamp = *maybe___imageTimeStamp;
// Sentinel = 'imageTimeStamp'
if ((!((aReader)->ReadSentinel(699467160)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'imageTimeStamp' (TimeStamp) member of 'ImageCompositeNotification'");
return {};
}
auto maybe___firstCompositeTimeStamp = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
if (!maybe___firstCompositeTimeStamp) {
aReader->FatalError("Error deserializing 'firstCompositeTimeStamp' (TimeStamp) member of 'ImageCompositeNotification'");
return {};
}
auto& _firstCompositeTimeStamp = *maybe___firstCompositeTimeStamp;
// Sentinel = 'firstCompositeTimeStamp'
if ((!((aReader)->ReadSentinel(1910638960)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'firstCompositeTimeStamp' (TimeStamp) member of 'ImageCompositeNotification'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_compositable),
std::move(_imageTimeStamp),
std::move(_firstCompositeTimeStamp),
::uint32_t{0},
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->frameID())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'frameID | producerID'
if ((!((aReader)->ReadSentinel(1286801222)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union AsyncParentMessageData|
//
namespace mozilla {
namespace layers {
auto AsyncParentMessageData::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TOpNotifyNotUsed:
{
(ptr_OpNotifyNotUsed())->~OpNotifyNotUsed__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT AsyncParentMessageData::AsyncParentMessageData(const OpNotifyNotUsed& aOther)
{
new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed(aOther);
mType = TOpNotifyNotUsed;
}
MOZ_IMPLICIT AsyncParentMessageData::AsyncParentMessageData(OpNotifyNotUsed&& aOther)
{
new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed(std::move(aOther));
mType = TOpNotifyNotUsed;
}
MOZ_IMPLICIT AsyncParentMessageData::AsyncParentMessageData(const AsyncParentMessageData& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TOpNotifyNotUsed:
{
new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed((aOther).get_OpNotifyNotUsed());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT AsyncParentMessageData::AsyncParentMessageData(AsyncParentMessageData&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TOpNotifyNotUsed:
{
new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed(std::move((aOther).get_OpNotifyNotUsed()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
AsyncParentMessageData::~AsyncParentMessageData()
{
MaybeDestroy();
}
auto AsyncParentMessageData::operator=(const OpNotifyNotUsed& aRhs) -> AsyncParentMessageData&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed(aRhs);
mType = TOpNotifyNotUsed;
return (*(this));
}
auto AsyncParentMessageData::operator=(OpNotifyNotUsed&& aRhs) -> AsyncParentMessageData&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed(std::move(aRhs));
mType = TOpNotifyNotUsed;
return (*(this));
}
auto AsyncParentMessageData::operator=(const AsyncParentMessageData& aRhs) -> AsyncParentMessageData&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TOpNotifyNotUsed:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed((aRhs).get_OpNotifyNotUsed());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto AsyncParentMessageData::operator=(AsyncParentMessageData&& aRhs) -> AsyncParentMessageData&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TOpNotifyNotUsed:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed(std::move((aRhs).get_OpNotifyNotUsed()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::AsyncParentMessageData>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::layers::AsyncParentMessageData union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'AsyncParentMessageData'
(aWriter)->WriteSentinel(1672677544);
switch (type) {
case union__::TOpNotifyNotUsed:
{
IPC::WriteParam(aWriter, (aVar).get_OpNotifyNotUsed());
// Sentinel = 'TOpNotifyNotUsed'
(aWriter)->WriteSentinel(881460815);
return;
}
default:
{
aWriter->FatalError("unknown variant of union AsyncParentMessageData");
return;
}
}
}
auto ParamTraits<::mozilla::layers::AsyncParentMessageData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::layers::AsyncParentMessageData union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union AsyncParentMessageData");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'AsyncParentMessageData'
if ((!((aReader)->ReadSentinel(1672677544)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union AsyncParentMessageData");
return {};
}
switch (type) {
case union__::TOpNotifyNotUsed:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::layers::OpNotifyNotUsed>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TOpNotifyNotUsed of union AsyncParentMessageData");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TOpNotifyNotUsed'
if ((!((aReader)->ReadSentinel(881460815)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TOpNotifyNotUsed of union AsyncParentMessageData");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union AsyncParentMessageData");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union OMTAValue|
//
namespace mozilla {
namespace layers {
auto OMTAValue::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnull_t:
{
(ptr_null_t())->~null_t__tdef();
break;
}
case Tnscolor:
{
(ptr_nscolor())->~nscolor__tdef();
break;
}
case Tfloat:
{
(ptr_float())->~float__tdef();
break;
}
case TMatrix4x4:
{
(ptr_Matrix4x4())->~Matrix4x4__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT OMTAValue::OMTAValue(const null_t& aOther)
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
mType = Tnull_t;
}
MOZ_IMPLICIT OMTAValue::OMTAValue(null_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aOther));
mType = Tnull_t;
}
MOZ_IMPLICIT OMTAValue::OMTAValue(const nscolor& aOther)
{
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(aOther);
mType = Tnscolor;
}
MOZ_IMPLICIT OMTAValue::OMTAValue(nscolor&& aOther)
{
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move(aOther));
mType = Tnscolor;
}
MOZ_IMPLICIT OMTAValue::OMTAValue(const float& aOther)
{
new (mozilla::KnownNotNull, ptr_float()) float(aOther);
mType = Tfloat;
}
MOZ_IMPLICIT OMTAValue::OMTAValue(float&& aOther)
{
new (mozilla::KnownNotNull, ptr_float()) float(std::move(aOther));
mType = Tfloat;
}
MOZ_IMPLICIT OMTAValue::OMTAValue(const Matrix4x4& aOther)
{
new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4(aOther);
mType = TMatrix4x4;
}
MOZ_IMPLICIT OMTAValue::OMTAValue(Matrix4x4&& aOther)
{
new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4(std::move(aOther));
mType = TMatrix4x4;
}
MOZ_IMPLICIT OMTAValue::OMTAValue(const OMTAValue& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tnull_t:
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
break;
}
case Tnscolor:
{
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor((aOther).get_nscolor());
break;
}
case Tfloat:
{
new (mozilla::KnownNotNull, ptr_float()) float((aOther).get_float());
break;
}
case TMatrix4x4:
{
new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4((aOther).get_Matrix4x4());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT OMTAValue::OMTAValue(OMTAValue&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tnull_t:
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_t()));
(aOther).MaybeDestroy();
break;
}
case Tnscolor:
{
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move((aOther).get_nscolor()));
(aOther).MaybeDestroy();
break;
}
case Tfloat:
{
new (mozilla::KnownNotNull, ptr_float()) float(std::move((aOther).get_float()));
(aOther).MaybeDestroy();
break;
}
case TMatrix4x4:
{
new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4(std::move((aOther).get_Matrix4x4()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
OMTAValue::~OMTAValue()
{
MaybeDestroy();
}
auto OMTAValue::operator=(const null_t& aRhs) -> OMTAValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t(aRhs);
mType = Tnull_t;
return (*(this));
}
auto OMTAValue::operator=(null_t&& aRhs) -> OMTAValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aRhs));
mType = Tnull_t;
return (*(this));
}
auto OMTAValue::operator=(const nscolor& aRhs) -> OMTAValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(aRhs);
mType = Tnscolor;
return (*(this));
}
auto OMTAValue::operator=(nscolor&& aRhs) -> OMTAValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move(aRhs));
mType = Tnscolor;
return (*(this));
}
auto OMTAValue::operator=(const float& aRhs) -> OMTAValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_float()) float(aRhs);
mType = Tfloat;
return (*(this));
}
auto OMTAValue::operator=(float&& aRhs) -> OMTAValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_float()) float(std::move(aRhs));
mType = Tfloat;
return (*(this));
}
auto OMTAValue::operator=(const Matrix4x4& aRhs) -> OMTAValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4(aRhs);
mType = TMatrix4x4;
return (*(this));
}
auto OMTAValue::operator=(Matrix4x4&& aRhs) -> OMTAValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4(std::move(aRhs));
mType = TMatrix4x4;
return (*(this));
}
auto OMTAValue::operator=(const OMTAValue& aRhs) -> OMTAValue&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnull_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t((aRhs).get_null_t());
break;
}
case Tnscolor:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor((aRhs).get_nscolor());
break;
}
case Tfloat:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_float()) float((aRhs).get_float());
break;
}
case TMatrix4x4:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4((aRhs).get_Matrix4x4());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto OMTAValue::operator=(OMTAValue&& aRhs) -> OMTAValue&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnull_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aRhs).get_null_t()));
(aRhs).MaybeDestroy();
break;
}
case Tnscolor:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nscolor()) nscolor(std::move((aRhs).get_nscolor()));
(aRhs).MaybeDestroy();
break;
}
case Tfloat:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_float()) float(std::move((aRhs).get_float()));
(aRhs).MaybeDestroy();
break;
}
case TMatrix4x4:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4(std::move((aRhs).get_Matrix4x4()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::OMTAValue>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::layers::OMTAValue union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'OMTAValue'
(aWriter)->WriteSentinel(248447791);
switch (type) {
case union__::Tnull_t:
{
IPC::WriteParam(aWriter, (aVar).get_null_t());
// Sentinel = 'Tnull_t'
(aWriter)->WriteSentinel(190186211);
return;
}
case union__::Tnscolor:
{
IPC::WriteParam(aWriter, (aVar).get_nscolor());
// Sentinel = 'Tnscolor'
(aWriter)->WriteSentinel(245039957);
return;
}
case union__::Tfloat:
{
IPC::WriteParam(aWriter, (aVar).get_float());
// Sentinel = 'Tfloat'
(aWriter)->WriteSentinel(137298539);
return;
}
case union__::TMatrix4x4:
{
IPC::WriteParam(aWriter, (aVar).get_Matrix4x4());
// Sentinel = 'TMatrix4x4'
(aWriter)->WriteSentinel(345244586);
return;
}
default:
{
aWriter->FatalError("unknown variant of union OMTAValue");
return;
}
}
}
auto ParamTraits<::mozilla::layers::OMTAValue>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::layers::OMTAValue union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union OMTAValue");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'OMTAValue'
if ((!((aReader)->ReadSentinel(248447791)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union OMTAValue");
return {};
}
switch (type) {
case union__::Tnull_t:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::null_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnull_t of union OMTAValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnull_t'
if ((!((aReader)->ReadSentinel(190186211)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union OMTAValue");
return {};
}
return std::move(tmp);
}
case union__::Tnscolor:
{
auto maybe__tmp = IPC::ReadParam<::nscolor>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnscolor of union OMTAValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnscolor'
if ((!((aReader)->ReadSentinel(245039957)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnscolor of union OMTAValue");
return {};
}
return std::move(tmp);
}
case union__::Tfloat:
{
auto maybe__tmp = IPC::ReadParam<float>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tfloat of union OMTAValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tfloat'
if ((!((aReader)->ReadSentinel(137298539)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tfloat of union OMTAValue");
return {};
}
return std::move(tmp);
}
case union__::TMatrix4x4:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::gfx::Matrix4x4>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TMatrix4x4 of union OMTAValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TMatrix4x4'
if ((!((aReader)->ReadSentinel(345244586)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TMatrix4x4 of union OMTAValue");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union OMTAValue");
return {};
}
}
}
} // namespace IPC