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

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


#include "mozilla/GfxMessageUtils.h"
#include "mozilla/layers/WebRenderMessageUtils.h"
#include "mozilla/layers/PCompositorBridgeParent.h"
#include "mozilla/layers/PCompositorBridgeChild.h"
#include "mozilla/layers/PCompositorManager.h"

namespace mozilla {
namespace layers {
namespace PCompositorManager {

nsresult
CreateEndpoints(
        base::ProcessId aParentDestPid,
        base::ProcessId aChildDestPid,
        mozilla::ipc::Endpoint<mozilla::layers::PCompositorManagerParent>* aParent,
        mozilla::ipc::Endpoint<mozilla::layers::PCompositorManagerChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(mozilla::ipc::PrivateIPDLInterface(), aParentDestPid, aChildDestPid, aParent, aChild);
}
IPC::Message*
Msg_PCompositorBridgeConstructor(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_PCompositorBridgeConstructor__ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::NOT_REPLY));
}
IPC::Message*
Reply_PCompositorBridgeConstructor(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_PCompositorBridgeConstructor__ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::REPLY));
}
IPC::Message*
Msg_AddSharedSurface(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_AddSharedSurface__ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::NOT_REPLY));
}
IPC::Message*
Msg_RemoveSharedSurface(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_RemoveSharedSurface__ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::NOT_REPLY));
}
IPC::Message*
Msg_NotifyMemoryPressure(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_NotifyMemoryPressure__ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::NOT_REPLY));
}
IPC::Message*
Msg_ReportMemory(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_ReportMemory__ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::NOT_REPLY));
}
IPC::Message*
Reply_ReportMemory(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_ReportMemory__ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::REPLY));
}

} // namespace PCompositorManager
} // namespace layers
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::WidgetCompositorOptions>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).scale());
    // Sentinel = 'scale'
    (aMsg)->WriteSentinel(590599843);
    WriteIPDLParam(aMsg, aActor, (aVar).vsyncRate());
    // Sentinel = 'vsyncRate'
    (aMsg)->WriteSentinel(1568351920);
    WriteIPDLParam(aMsg, aActor, (aVar).options());
    // Sentinel = 'options'
    (aMsg)->WriteSentinel(33222909);
    WriteIPDLParam(aMsg, aActor, (aVar).useExternalSurfaceSize());
    // Sentinel = 'useExternalSurfaceSize'
    (aMsg)->WriteSentinel(778777080);
    WriteIPDLParam(aMsg, aActor, (aVar).surfaceSize());
    // Sentinel = 'surfaceSize'
    (aMsg)->WriteSentinel(87441173);
}

auto IPDLParamTraits<mozilla::layers::WidgetCompositorOptions>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->scale())))))) {
        (aActor)->FatalError("Error deserializing 'scale' (CSSToLayoutDeviceScale) member of 'WidgetCompositorOptions'");
        return false;
    }
    // Sentinel = 'scale'
    if ((!((aMsg)->ReadSentinel(aIter, 590599843)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scale' (CSSToLayoutDeviceScale) member of 'WidgetCompositorOptions'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->vsyncRate())))))) {
        (aActor)->FatalError("Error deserializing 'vsyncRate' (TimeDuration) member of 'WidgetCompositorOptions'");
        return false;
    }
    // Sentinel = 'vsyncRate'
    if ((!((aMsg)->ReadSentinel(aIter, 1568351920)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'vsyncRate' (TimeDuration) member of 'WidgetCompositorOptions'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->options())))))) {
        (aActor)->FatalError("Error deserializing 'options' (CompositorOptions) member of 'WidgetCompositorOptions'");
        return false;
    }
    // Sentinel = 'options'
    if ((!((aMsg)->ReadSentinel(aIter, 33222909)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'options' (CompositorOptions) member of 'WidgetCompositorOptions'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->useExternalSurfaceSize())))))) {
        (aActor)->FatalError("Error deserializing 'useExternalSurfaceSize' (bool) member of 'WidgetCompositorOptions'");
        return false;
    }
    // Sentinel = 'useExternalSurfaceSize'
    if ((!((aMsg)->ReadSentinel(aIter, 778777080)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'useExternalSurfaceSize' (bool) member of 'WidgetCompositorOptions'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->surfaceSize())))))) {
        (aActor)->FatalError("Error deserializing 'surfaceSize' (IntSize) member of 'WidgetCompositorOptions'");
        return false;
    }
    // Sentinel = 'surfaceSize'
    if ((!((aMsg)->ReadSentinel(aIter, 87441173)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'surfaceSize' (IntSize) member of 'WidgetCompositorOptions'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace layers
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union CompositorBridgeOptions|
//
namespace mozilla {
namespace layers {
auto CompositorBridgeOptions::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TContentCompositorOptions:
        {
            (ptr_ContentCompositorOptions())->~ContentCompositorOptions__tdef();
            break;
        }
    case TWidgetCompositorOptions:
        {
            (ptr_WidgetCompositorOptions())->~WidgetCompositorOptions__tdef();
            break;
        }
    case TSameProcessWidgetCompositorOptions:
        {
            (ptr_SameProcessWidgetCompositorOptions())->~SameProcessWidgetCompositorOptions__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT CompositorBridgeOptions::CompositorBridgeOptions(const ContentCompositorOptions& aOther)
{
    new (mozilla::KnownNotNull, ptr_ContentCompositorOptions()) ContentCompositorOptions(aOther);
    mType = TContentCompositorOptions;
}

MOZ_IMPLICIT CompositorBridgeOptions::CompositorBridgeOptions(ContentCompositorOptions&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ContentCompositorOptions()) ContentCompositorOptions(std::move(aOther));
    mType = TContentCompositorOptions;
}

MOZ_IMPLICIT CompositorBridgeOptions::CompositorBridgeOptions(const WidgetCompositorOptions& aOther)
{
    new (mozilla::KnownNotNull, ptr_WidgetCompositorOptions()) WidgetCompositorOptions(aOther);
    mType = TWidgetCompositorOptions;
}

MOZ_IMPLICIT CompositorBridgeOptions::CompositorBridgeOptions(WidgetCompositorOptions&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WidgetCompositorOptions()) WidgetCompositorOptions(std::move(aOther));
    mType = TWidgetCompositorOptions;
}

MOZ_IMPLICIT CompositorBridgeOptions::CompositorBridgeOptions(const SameProcessWidgetCompositorOptions& aOther)
{
    new (mozilla::KnownNotNull, ptr_SameProcessWidgetCompositorOptions()) SameProcessWidgetCompositorOptions(aOther);
    mType = TSameProcessWidgetCompositorOptions;
}

MOZ_IMPLICIT CompositorBridgeOptions::CompositorBridgeOptions(SameProcessWidgetCompositorOptions&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SameProcessWidgetCompositorOptions()) SameProcessWidgetCompositorOptions(std::move(aOther));
    mType = TSameProcessWidgetCompositorOptions;
}

MOZ_IMPLICIT CompositorBridgeOptions::CompositorBridgeOptions(const CompositorBridgeOptions& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TContentCompositorOptions:
        {
            new (mozilla::KnownNotNull, ptr_ContentCompositorOptions()) ContentCompositorOptions((aOther).get_ContentCompositorOptions());
            break;
        }
    case TWidgetCompositorOptions:
        {
            new (mozilla::KnownNotNull, ptr_WidgetCompositorOptions()) WidgetCompositorOptions((aOther).get_WidgetCompositorOptions());
            break;
        }
    case TSameProcessWidgetCompositorOptions:
        {
            new (mozilla::KnownNotNull, ptr_SameProcessWidgetCompositorOptions()) SameProcessWidgetCompositorOptions((aOther).get_SameProcessWidgetCompositorOptions());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT CompositorBridgeOptions::CompositorBridgeOptions(CompositorBridgeOptions&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TContentCompositorOptions:
        {
            new (mozilla::KnownNotNull, ptr_ContentCompositorOptions()) ContentCompositorOptions(std::move((aOther).get_ContentCompositorOptions()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TWidgetCompositorOptions:
        {
            new (mozilla::KnownNotNull, ptr_WidgetCompositorOptions()) WidgetCompositorOptions(std::move((aOther).get_WidgetCompositorOptions()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TSameProcessWidgetCompositorOptions:
        {
            new (mozilla::KnownNotNull, ptr_SameProcessWidgetCompositorOptions()) SameProcessWidgetCompositorOptions(std::move((aOther).get_SameProcessWidgetCompositorOptions()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto CompositorBridgeOptions::operator=(const ContentCompositorOptions& aRhs) -> CompositorBridgeOptions&
{
    if (MaybeDestroy(TContentCompositorOptions)) {
        new (mozilla::KnownNotNull, ptr_ContentCompositorOptions()) ContentCompositorOptions;
    }
    (*(ptr_ContentCompositorOptions())) = aRhs;
    mType = TContentCompositorOptions;
    return (*(this));
}

auto CompositorBridgeOptions::operator=(ContentCompositorOptions&& aRhs) -> CompositorBridgeOptions&
{
    if (MaybeDestroy(TContentCompositorOptions)) {
        new (mozilla::KnownNotNull, ptr_ContentCompositorOptions()) ContentCompositorOptions;
    }
    (*(ptr_ContentCompositorOptions())) = std::move(aRhs);
    mType = TContentCompositorOptions;
    return (*(this));
}

auto CompositorBridgeOptions::operator=(const WidgetCompositorOptions& aRhs) -> CompositorBridgeOptions&
{
    if (MaybeDestroy(TWidgetCompositorOptions)) {
        new (mozilla::KnownNotNull, ptr_WidgetCompositorOptions()) WidgetCompositorOptions;
    }
    (*(ptr_WidgetCompositorOptions())) = aRhs;
    mType = TWidgetCompositorOptions;
    return (*(this));
}

auto CompositorBridgeOptions::operator=(WidgetCompositorOptions&& aRhs) -> CompositorBridgeOptions&
{
    if (MaybeDestroy(TWidgetCompositorOptions)) {
        new (mozilla::KnownNotNull, ptr_WidgetCompositorOptions()) WidgetCompositorOptions;
    }
    (*(ptr_WidgetCompositorOptions())) = std::move(aRhs);
    mType = TWidgetCompositorOptions;
    return (*(this));
}

auto CompositorBridgeOptions::operator=(const SameProcessWidgetCompositorOptions& aRhs) -> CompositorBridgeOptions&
{
    if (MaybeDestroy(TSameProcessWidgetCompositorOptions)) {
        new (mozilla::KnownNotNull, ptr_SameProcessWidgetCompositorOptions()) SameProcessWidgetCompositorOptions;
    }
    (*(ptr_SameProcessWidgetCompositorOptions())) = aRhs;
    mType = TSameProcessWidgetCompositorOptions;
    return (*(this));
}

auto CompositorBridgeOptions::operator=(SameProcessWidgetCompositorOptions&& aRhs) -> CompositorBridgeOptions&
{
    if (MaybeDestroy(TSameProcessWidgetCompositorOptions)) {
        new (mozilla::KnownNotNull, ptr_SameProcessWidgetCompositorOptions()) SameProcessWidgetCompositorOptions;
    }
    (*(ptr_SameProcessWidgetCompositorOptions())) = std::move(aRhs);
    mType = TSameProcessWidgetCompositorOptions;
    return (*(this));
}

auto CompositorBridgeOptions::operator=(const CompositorBridgeOptions& aRhs) -> CompositorBridgeOptions&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TContentCompositorOptions:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ContentCompositorOptions()) ContentCompositorOptions;
            }
            (*(ptr_ContentCompositorOptions())) = (aRhs).get_ContentCompositorOptions();
            break;
        }
    case TWidgetCompositorOptions:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_WidgetCompositorOptions()) WidgetCompositorOptions;
            }
            (*(ptr_WidgetCompositorOptions())) = (aRhs).get_WidgetCompositorOptions();
            break;
        }
    case TSameProcessWidgetCompositorOptions:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SameProcessWidgetCompositorOptions()) SameProcessWidgetCompositorOptions;
            }
            (*(ptr_SameProcessWidgetCompositorOptions())) = (aRhs).get_SameProcessWidgetCompositorOptions();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto CompositorBridgeOptions::operator=(CompositorBridgeOptions&& aRhs) -> CompositorBridgeOptions&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TContentCompositorOptions:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ContentCompositorOptions()) ContentCompositorOptions;
            }
            (*(ptr_ContentCompositorOptions())) = std::move((aRhs).get_ContentCompositorOptions());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TWidgetCompositorOptions:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_WidgetCompositorOptions()) WidgetCompositorOptions;
            }
            (*(ptr_WidgetCompositorOptions())) = std::move((aRhs).get_WidgetCompositorOptions());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TSameProcessWidgetCompositorOptions:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_SameProcessWidgetCompositorOptions()) SameProcessWidgetCompositorOptions;
            }
            (*(ptr_SameProcessWidgetCompositorOptions())) = std::move((aRhs).get_SameProcessWidgetCompositorOptions());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto CompositorBridgeOptions::operator==(const ContentCompositorOptions& aRhs) const -> bool
{
    return (get_ContentCompositorOptions()) == (aRhs);
}

auto CompositorBridgeOptions::operator==(const WidgetCompositorOptions& aRhs) const -> bool
{
    return (get_WidgetCompositorOptions()) == (aRhs);
}

auto CompositorBridgeOptions::operator==(const SameProcessWidgetCompositorOptions& aRhs) const -> bool
{
    return (get_SameProcessWidgetCompositorOptions()) == (aRhs);
}

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

    switch (type()) {
    case TContentCompositorOptions:
        {
            return (get_ContentCompositorOptions()) == ((aRhs).get_ContentCompositorOptions());
        }
    case TWidgetCompositorOptions:
        {
            return (get_WidgetCompositorOptions()) == ((aRhs).get_WidgetCompositorOptions());
        }
    case TSameProcessWidgetCompositorOptions:
        {
            return (get_SameProcessWidgetCompositorOptions()) == ((aRhs).get_SameProcessWidgetCompositorOptions());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto CompositorBridgeOptions::get(ContentCompositorOptions* aOutValue) const -> void
{
    (*(aOutValue)) = get_ContentCompositorOptions();
}

auto CompositorBridgeOptions::get(WidgetCompositorOptions* aOutValue) const -> void
{
    (*(aOutValue)) = get_WidgetCompositorOptions();
}

auto CompositorBridgeOptions::get(SameProcessWidgetCompositorOptions* aOutValue) const -> void
{
    (*(aOutValue)) = get_SameProcessWidgetCompositorOptions();
}

} // namespace layers
} // namespace mozilla

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

    switch (type) {
    case union__::TContentCompositorOptions:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ContentCompositorOptions());
            // Sentinel = 'TContentCompositorOptions'
            (aMsg)->WriteSentinel(660265439);
            return;
        }
    case union__::TWidgetCompositorOptions:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_WidgetCompositorOptions());
            // Sentinel = 'TWidgetCompositorOptions'
            (aMsg)->WriteSentinel(1740490067);
            return;
        }
    case union__::TSameProcessWidgetCompositorOptions:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_SameProcessWidgetCompositorOptions());
            // Sentinel = 'TSameProcessWidgetCompositorOptions'
            (aMsg)->WriteSentinel(3995034615);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TContentCompositorOptions:
        {
            mozilla::layers::ContentCompositorOptions tmp = mozilla::layers::ContentCompositorOptions();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ContentCompositorOptions())))))) {
                (aActor)->FatalError("Error deserializing variant TContentCompositorOptions of union CompositorBridgeOptions");
                return false;
            }
            // Sentinel = 'TContentCompositorOptions'
            if ((!((aMsg)->ReadSentinel(aIter, 660265439)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TContentCompositorOptions of union CompositorBridgeOptions");
                return false;
            }
            return true;
        }
    case union__::TWidgetCompositorOptions:
        {
            mozilla::layers::WidgetCompositorOptions tmp = mozilla::layers::WidgetCompositorOptions();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_WidgetCompositorOptions())))))) {
                (aActor)->FatalError("Error deserializing variant TWidgetCompositorOptions of union CompositorBridgeOptions");
                return false;
            }
            // Sentinel = 'TWidgetCompositorOptions'
            if ((!((aMsg)->ReadSentinel(aIter, 1740490067)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TWidgetCompositorOptions of union CompositorBridgeOptions");
                return false;
            }
            return true;
        }
    case union__::TSameProcessWidgetCompositorOptions:
        {
            mozilla::layers::SameProcessWidgetCompositorOptions tmp = mozilla::layers::SameProcessWidgetCompositorOptions();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_SameProcessWidgetCompositorOptions())))))) {
                (aActor)->FatalError("Error deserializing variant TSameProcessWidgetCompositorOptions of union CompositorBridgeOptions");
                return false;
            }
            // Sentinel = 'TSameProcessWidgetCompositorOptions'
            if ((!((aMsg)->ReadSentinel(aIter, 3995034615)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSameProcessWidgetCompositorOptions of union CompositorBridgeOptions");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53