Other Tools

//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/layers/PCompositorBridgeParent.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/ipc/IPCCore.h"
#include "mozilla/layers/CompositorBridgeParent.h"
#include "mozilla/layers/CompositorTypes.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/layers/LayersTypes.h"
#include "mozilla/layers/ScrollableLayerGuid.h"
#include "mozilla/layers/WebRenderMessageUtils.h"
#include "mozilla/layers/PAPZParent.h"
#include "mozilla/layers/PAPZCTreeManagerParent.h"
#include "mozilla/dom/PBrowserParent.h"
#include "mozilla/layers/PCanvasParent.h"
#include "mozilla/layers/PCompositorManagerParent.h"
#include "mozilla/widget/PCompositorWidgetParent.h"
#include "mozilla/layers/PTextureParent.h"
#include "mozilla/layers/PWebRenderBridgeParent.h"
#include "mozilla/webgpu/PWebGPUParent.h"
#include "ipc/IPCMessageUtils.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"
namespace mozilla {
namespace layers {
auto PCompositorBridgeParent::Recv__delete__() -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PCompositorBridgeParent::RecvPCompositorWidgetConstructor(
PCompositorWidgetParent* actor,
const CompositorWidgetInitData& aInitData) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PCompositorBridgeParent::RecvPAPZConstructor(
PAPZParent* actor,
const LayersId& layersId) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PCompositorBridgeParent::RecvPAPZCTreeManagerConstructor(
PAPZCTreeManagerParent* actor,
const LayersId& layersId) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PCompositorBridgeParent::RecvPWebGPUConstructor(PWebGPUParent* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PCompositorBridgeParent::RecvPTextureConstructor(
PTextureParent* actor,
const SurfaceDescriptor& aSharedData,
ReadLockDescriptor&& aReadLock,
const LayersBackend& aBackend,
const TextureFlags& aTextureFlags,
const LayersId& id,
const uint64_t& aSerial,
const MaybeExternalImageId& aExternalImageId) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PCompositorBridgeParent::RecvPWebRenderBridgeConstructor(
PWebRenderBridgeParent* actor,
const PipelineId& pipelineId,
const LayoutDeviceIntSize& aSize,
const WindowKind& aKind) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
MOZ_IMPLICIT PCompositorBridgeParent::PCompositorBridgeParent() :
mozilla::ipc::IProtocol(PCompositorBridgeMsgStart, mozilla::ipc::ParentSide)
{
MOZ_COUNT_CTOR(PCompositorBridgeParent);
}
PCompositorBridgeParent::~PCompositorBridgeParent()
{
MOZ_COUNT_DTOR(PCompositorBridgeParent);
}
auto PCompositorBridgeParent::OtherPid() const -> ::base::ProcessId
{
::base::ProcessId pid =
::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherPidMaybeInvalid();
MOZ_RELEASE_ASSERT(pid != ::base::kInvalidProcessId);
return pid;
}
auto PCompositorBridgeParent::Manager() const -> PCompositorManagerParent*
{
return static_cast<PCompositorManagerParent*>(IProtocol::Manager());
}
auto PCompositorBridgeParent::ManagedPAPZParent(nsTArray<PAPZParent*>& aArr) const -> void
{
mManagedPAPZParent.ToArray(aArr);
}
auto PCompositorBridgeParent::ManagedPAPZParent() const -> const ManagedContainer<PAPZParent>&
{
return mManagedPAPZParent;
}
auto PCompositorBridgeParent::ManagedPAPZCTreeManagerParent(nsTArray<PAPZCTreeManagerParent*>& aArr) const -> void
{
mManagedPAPZCTreeManagerParent.ToArray(aArr);
}
auto PCompositorBridgeParent::ManagedPAPZCTreeManagerParent() const -> const ManagedContainer<PAPZCTreeManagerParent>&
{
return mManagedPAPZCTreeManagerParent;
}
auto PCompositorBridgeParent::ManagedPTextureParent(nsTArray<PTextureParent*>& aArr) const -> void
{
mManagedPTextureParent.ToArray(aArr);
}
auto PCompositorBridgeParent::ManagedPTextureParent() const -> const ManagedContainer<PTextureParent>&
{
return mManagedPTextureParent;
}
auto PCompositorBridgeParent::ManagedPCompositorWidgetParent(nsTArray<PCompositorWidgetParent*>& aArr) const -> void
{
mManagedPCompositorWidgetParent.ToArray(aArr);
}
auto PCompositorBridgeParent::ManagedPCompositorWidgetParent() const -> const ManagedContainer<PCompositorWidgetParent>&
{
return mManagedPCompositorWidgetParent;
}
auto PCompositorBridgeParent::ManagedPWebRenderBridgeParent(nsTArray<PWebRenderBridgeParent*>& aArr) const -> void
{
mManagedPWebRenderBridgeParent.ToArray(aArr);
}
auto PCompositorBridgeParent::ManagedPWebRenderBridgeParent() const -> const ManagedContainer<PWebRenderBridgeParent>&
{
return mManagedPWebRenderBridgeParent;
}
auto PCompositorBridgeParent::ManagedPWebGPUParent(nsTArray<PWebGPUParent*>& aArr) const -> void
{
mManagedPWebGPUParent.ToArray(aArr);
}
auto PCompositorBridgeParent::ManagedPWebGPUParent() const -> const ManagedContainer<PWebGPUParent>&
{
return mManagedPWebGPUParent;
}
auto PCompositorBridgeParent::AllManagedActors(nsTArray<RefPtr<mozilla::ipc::ActorLifecycleProxy>>& arr__) const -> void
{
uint32_t total = 0;
total += mManagedPAPZParent.Count();
total += mManagedPAPZCTreeManagerParent.Count();
total += mManagedPTextureParent.Count();
total += mManagedPCompositorWidgetParent.Count();
total += mManagedPWebRenderBridgeParent.Count();
total += mManagedPWebGPUParent.Count();
arr__.SetCapacity(total);
for (auto* key : mManagedPAPZParent) {
arr__.AppendElement(key->GetLifecycleProxy());
}
for (auto* key : mManagedPAPZCTreeManagerParent) {
arr__.AppendElement(key->GetLifecycleProxy());
}
for (auto* key : mManagedPTextureParent) {
arr__.AppendElement(key->GetLifecycleProxy());
}
for (auto* key : mManagedPCompositorWidgetParent) {
arr__.AppendElement(key->GetLifecycleProxy());
}
for (auto* key : mManagedPWebRenderBridgeParent) {
arr__.AppendElement(key->GetLifecycleProxy());
}
for (auto* key : mManagedPWebGPUParent) {
arr__.AppendElement(key->GetLifecycleProxy());
}
}
auto PCompositorBridgeParent::OpenPAPZEndpoint(PAPZParent* aActor) -> ManagedEndpoint<PAPZChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PAPZParent actor");
return ManagedEndpoint<PAPZChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPAPZParent.Insert(aActor);
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PAPZChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PCompositorBridgeParent::BindPAPZEndpoint(
ManagedEndpoint<PAPZParent> aEndpoint,
PAPZParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPAPZParent);
}
auto PCompositorBridgeParent::OpenPAPZCTreeManagerEndpoint(PAPZCTreeManagerParent* aActor) -> ManagedEndpoint<PAPZCTreeManagerChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PAPZCTreeManagerParent actor");
return ManagedEndpoint<PAPZCTreeManagerChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPAPZCTreeManagerParent.Insert(aActor);
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PAPZCTreeManagerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PCompositorBridgeParent::BindPAPZCTreeManagerEndpoint(
ManagedEndpoint<PAPZCTreeManagerParent> aEndpoint,
PAPZCTreeManagerParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPAPZCTreeManagerParent);
}
auto PCompositorBridgeParent::OpenPTextureEndpoint(PTextureParent* aActor) -> ManagedEndpoint<PTextureChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PTextureParent actor");
return ManagedEndpoint<PTextureChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPTextureParent.Insert(aActor);
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PTextureChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PCompositorBridgeParent::BindPTextureEndpoint(
ManagedEndpoint<PTextureParent> aEndpoint,
PTextureParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPTextureParent);
}
auto PCompositorBridgeParent::OpenPCompositorWidgetEndpoint(PCompositorWidgetParent* aActor) -> ManagedEndpoint<PCompositorWidgetChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PCompositorWidgetParent actor");
return ManagedEndpoint<PCompositorWidgetChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPCompositorWidgetParent.Insert(aActor);
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PCompositorWidgetChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PCompositorBridgeParent::BindPCompositorWidgetEndpoint(
ManagedEndpoint<PCompositorWidgetParent> aEndpoint,
PCompositorWidgetParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPCompositorWidgetParent);
}
auto PCompositorBridgeParent::OpenPWebRenderBridgeEndpoint(PWebRenderBridgeParent* aActor) -> ManagedEndpoint<PWebRenderBridgeChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWebRenderBridgeParent actor");
return ManagedEndpoint<PWebRenderBridgeChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPWebRenderBridgeParent.Insert(aActor);
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PWebRenderBridgeChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PCompositorBridgeParent::BindPWebRenderBridgeEndpoint(
ManagedEndpoint<PWebRenderBridgeParent> aEndpoint,
PWebRenderBridgeParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPWebRenderBridgeParent);
}
auto PCompositorBridgeParent::OpenPWebGPUEndpoint(PWebGPUParent* aActor) -> ManagedEndpoint<PWebGPUChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWebGPUParent actor");
return ManagedEndpoint<PWebGPUChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPWebGPUParent.Insert(aActor);
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PWebGPUChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PCompositorBridgeParent::BindPWebGPUEndpoint(
ManagedEndpoint<PWebGPUParent> aEndpoint,
PWebGPUParent* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPWebGPUParent);
}
auto PCompositorBridgeParent::SendInvalidateLayers(const LayersId& layersId) -> bool
{
IPC::Message* msg__ = PCompositorBridge::Msg_InvalidateLayers(Id());
WriteIPDLParam(msg__, this, layersId);
// Sentinel = 'layersId'
(msg__)->WriteSentinel(250938174);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_InvalidateLayers", OTHER);
bool sendok__ = ChannelSend(msg__);
return sendok__;
}
auto PCompositorBridgeParent::SendDidComposite(
const LayersId& id,
const nsTArray<TransactionId>& transactionId,
const TimeStamp& compositeStart,
const TimeStamp& compositeEnd) -> bool
{
IPC::Message* msg__ = PCompositorBridge::Msg_DidComposite(Id());
WriteIPDLParam(msg__, this, id);
// Sentinel = 'id'
(msg__)->WriteSentinel(20447438);
WriteIPDLParam(msg__, this, transactionId);
// Sentinel = 'transactionId'
(msg__)->WriteSentinel(642319700);
WriteIPDLParam(msg__, this, compositeStart);
// Sentinel = 'compositeStart'
(msg__)->WriteSentinel(740558306);
WriteIPDLParam(msg__, this, compositeEnd);
// Sentinel = 'compositeEnd'
(msg__)->WriteSentinel(547423467);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_DidComposite", OTHER);
bool sendok__ = ChannelSend(msg__);
return sendok__;
}
auto PCompositorBridgeParent::SendNotifyFrameStats(const nsTArray<FrameStats>& aFrameStats) -> bool
{
IPC::Message* msg__ = PCompositorBridge::Msg_NotifyFrameStats(Id());
WriteIPDLParam(msg__, this, aFrameStats);
// Sentinel = 'aFrameStats'
(msg__)->WriteSentinel(423756892);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_NotifyFrameStats", OTHER);
bool sendok__ = ChannelSend(msg__);
return sendok__;
}
auto PCompositorBridgeParent::SendParentAsyncMessages(const nsTArray<AsyncParentMessageData>& aMessages) -> bool
{
IPC::Message* msg__ = PCompositorBridge::Msg_ParentAsyncMessages(Id());
WriteIPDLParam(msg__, this, aMessages);
// Sentinel = 'aMessages'
(msg__)->WriteSentinel(293864346);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_ParentAsyncMessages", OTHER);
bool sendok__ = ChannelSend(msg__);
return sendok__;
}
auto PCompositorBridgeParent::SendObserveLayersUpdate(
const LayersId& aLayersId,
const LayersObserverEpoch& aEpoch,
const bool& aActive) -> bool
{
IPC::Message* msg__ = PCompositorBridge::Msg_ObserveLayersUpdate(Id());
WriteIPDLParam(msg__, this, aLayersId);
// Sentinel = 'aLayersId'
(msg__)->WriteSentinel(291439487);
WriteIPDLParam(msg__, this, aEpoch);
// Sentinel = 'aEpoch'
(msg__)->WriteSentinel(132121169);
WriteIPDLParam(msg__, this, aActive);
// Sentinel = 'aActive'
(msg__)->WriteSentinel(176095934);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_ObserveLayersUpdate", OTHER);
bool sendok__ = ChannelSend(msg__);
return sendok__;
}
auto PCompositorBridgeParent::SendCompositorOptionsChanged(
const LayersId& id,
const CompositorOptions& newOptions) -> bool
{
IPC::Message* msg__ = PCompositorBridge::Msg_CompositorOptionsChanged(Id());
WriteIPDLParam(msg__, this, id);
// Sentinel = 'id'
(msg__)->WriteSentinel(20447438);
WriteIPDLParam(msg__, this, newOptions);
// Sentinel = 'newOptions'
(msg__)->WriteSentinel(384304183);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_CompositorOptionsChanged", OTHER);
bool sendok__ = ChannelSend(msg__);
return sendok__;
}
auto PCompositorBridgeParent::SendNotifyJankedAnimations(
const LayersId& id,
const nsTArray<uint64_t>& aJankedAnimations) -> bool
{
IPC::Message* msg__ = PCompositorBridge::Msg_NotifyJankedAnimations(Id());
WriteIPDLParam(msg__, this, id);
// Sentinel = 'id'
(msg__)->WriteSentinel(20447438);
WriteIPDLParam(msg__, this, aJankedAnimations);
// Sentinel = 'aJankedAnimations'
(msg__)->WriteSentinel(985728706);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_NotifyJankedAnimations", OTHER);
bool sendok__ = ChannelSend(msg__);
return sendok__;
}
auto PCompositorBridgeParent::RemoveManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
switch (aProtocolId) {
case PAPZMsgStart:
{
PAPZParent* actor = static_cast<PAPZParent*>(aListener);
const bool removed = mManagedPAPZParent.EnsureRemoved(actor);
MOZ_RELEASE_ASSERT(removed, "actor not managed by this!");
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PAPZCTreeManagerMsgStart:
{
PAPZCTreeManagerParent* actor = static_cast<PAPZCTreeManagerParent*>(aListener);
const bool removed = mManagedPAPZCTreeManagerParent.EnsureRemoved(actor);
MOZ_RELEASE_ASSERT(removed, "actor not managed by this!");
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PTextureMsgStart:
{
PTextureParent* actor = static_cast<PTextureParent*>(aListener);
const bool removed = mManagedPTextureParent.EnsureRemoved(actor);
MOZ_RELEASE_ASSERT(removed, "actor not managed by this!");
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PCompositorWidgetMsgStart:
{
PCompositorWidgetParent* actor = static_cast<PCompositorWidgetParent*>(aListener);
const bool removed = mManagedPCompositorWidgetParent.EnsureRemoved(actor);
MOZ_RELEASE_ASSERT(removed, "actor not managed by this!");
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PWebRenderBridgeMsgStart:
{
PWebRenderBridgeParent* actor = static_cast<PWebRenderBridgeParent*>(aListener);
const bool removed = mManagedPWebRenderBridgeParent.EnsureRemoved(actor);
MOZ_RELEASE_ASSERT(removed, "actor not managed by this!");
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PWebGPUMsgStart:
{
PWebGPUParent* actor = static_cast<PWebGPUParent*>(aListener);
const bool removed = mManagedPWebGPUParent.EnsureRemoved(actor);
MOZ_RELEASE_ASSERT(removed, "actor not managed by this!");
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} default:
FatalError("unreached");
return; }
}
auto PCompositorBridgeParent::DeallocManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
switch (aProtocolId) {
case PAPZMsgStart:
static_cast<CompositorBridgeParentBase*>(this)->DeallocPAPZParent(static_cast<PAPZParent*>(aListener));
return;
case PAPZCTreeManagerMsgStart:
static_cast<CompositorBridgeParentBase*>(this)->DeallocPAPZCTreeManagerParent(static_cast<PAPZCTreeManagerParent*>(aListener));
return;
case PTextureMsgStart:
static_cast<CompositorBridgeParentBase*>(this)->DeallocPTextureParent(static_cast<PTextureParent*>(aListener));
return;
case PCompositorWidgetMsgStart:
static_cast<CompositorBridgeParentBase*>(this)->DeallocPCompositorWidgetParent(static_cast<PCompositorWidgetParent*>(aListener));
return;
case PWebRenderBridgeMsgStart:
static_cast<CompositorBridgeParentBase*>(this)->DeallocPWebRenderBridgeParent(static_cast<PWebRenderBridgeParent*>(aListener));
return;
case PWebGPUMsgStart:
static_cast<CompositorBridgeParentBase*>(this)->DeallocPWebGPUParent(static_cast<PWebGPUParent*>(aListener));
return;
default:
FatalError("unreached");
return;
}
}
auto PCompositorBridgeParent::OnMessageReceived(const Message& msg__) -> PCompositorBridgeParent::Result
{
switch (msg__.type()) {
case MANAGED_ENDPOINT_BOUND_MESSAGE_TYPE:
{
if (!mAwaitingManagedEndpointBind) {
NS_WARNING("Unexpected managed endpoint lifecycle message after actor bound!");
return MsgNotAllowed;
}
mAwaitingManagedEndpointBind = false;
return MsgProcessed;
}
case MANAGED_ENDPOINT_DROPPED_MESSAGE_TYPE:
{
if (!mAwaitingManagedEndpointBind) {
NS_WARNING("Unexpected managed endpoint lifecycle message after actor bound!");
return MsgNotAllowed;
}
mAwaitingManagedEndpointBind = false;
IProtocol* mgr = this->Manager();
this->DestroySubtree(ManagedEndpointDropped);
this->ClearSubtree();
mgr->RemoveManagee(PCompositorBridgeMsgStart, this);
return MsgProcessed;
}
case PCompositorBridge::Msg___delete____ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg___delete__", OTHER);
PickleIterator iter__{msg__};
PCompositorBridgeParent* actor{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(actor)))))) {
FatalError("Error deserializing 'PCompositorBridge'");
return MsgValueError;
}
if ((!((*((&(actor))))))) {
FatalError("Error deserializing 'PCompositorBridge'");
return MsgValueError;
}
// Sentinel = 'actor'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PCompositorBridge'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
if ((!((static_cast<CompositorBridgeParentBase*>(this))->Recv__delete__()))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
IProtocol* mgr = actor->Manager();
actor->DestroySubtree(Deletion);
actor->ClearSubtree();
mgr->RemoveManagee(PCompositorBridgeMsgStart, actor);
return MsgProcessed;
}
case PCompositorBridge::Msg_PCompositorWidgetConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PCompositorWidgetConstructor", OTHER);
PickleIterator iter__{msg__};
ActorHandle handle__{};
CompositorWidgetInitData aInitData{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
// Sentinel = 'actor'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aInitData)))))) {
FatalError("Error deserializing 'CompositorWidgetInitData'");
return MsgValueError;
}
// Sentinel = 'aInitData'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 284296048)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'CompositorWidgetInitData'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
PCompositorWidgetParent* actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPCompositorWidgetParent(aInitData);
if (!actor) {
NS_WARNING("Cannot bind null PCompositorWidgetParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPCompositorWidgetParent.Insert(actor);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPCompositorWidgetConstructor(std::move(actor), std::move(aInitData))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_PAPZConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PAPZConstructor", OTHER);
PickleIterator iter__{msg__};
ActorHandle handle__{};
LayersId layersId{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
// Sentinel = 'actor'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(layersId)))))) {
FatalError("Error deserializing 'LayersId'");
return MsgValueError;
}
// Sentinel = 'layersId'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 250938174)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
PAPZParent* actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPAPZParent(layersId);
if (!actor) {
NS_WARNING("Cannot bind null PAPZParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPAPZParent.Insert(actor);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPAPZConstructor(std::move(actor), std::move(layersId))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_PAPZCTreeManagerConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PAPZCTreeManagerConstructor", OTHER);
PickleIterator iter__{msg__};
ActorHandle handle__{};
LayersId layersId{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
// Sentinel = 'actor'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(layersId)))))) {
FatalError("Error deserializing 'LayersId'");
return MsgValueError;
}
// Sentinel = 'layersId'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 250938174)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
PAPZCTreeManagerParent* actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPAPZCTreeManagerParent(layersId);
if (!actor) {
NS_WARNING("Cannot bind null PAPZCTreeManagerParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPAPZCTreeManagerParent.Insert(actor);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPAPZCTreeManagerConstructor(std::move(actor), std::move(layersId))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_PWebGPUConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PWebGPUConstructor", OTHER);
PickleIterator iter__{msg__};
ActorHandle handle__{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
// Sentinel = 'actor'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
PWebGPUParent* actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPWebGPUParent();
if (!actor) {
NS_WARNING("Cannot bind null PWebGPUParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPWebGPUParent.Insert(actor);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPWebGPUConstructor(std::move(actor))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_ResumeAsync__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_ResumeAsync", OTHER);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvResumeAsync()))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_AdoptChild__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_AdoptChild", OTHER);
PickleIterator iter__{msg__};
LayersId id{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(id)))))) {
FatalError("Error deserializing 'LayersId'");
return MsgValueError;
}
// Sentinel = 'id'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 20447438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvAdoptChild(std::move(id))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_FlushRenderingAsync__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_FlushRenderingAsync", OTHER);
PickleIterator iter__{msg__};
RenderReasons aReasons{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aReasons)))))) {
FatalError("Error deserializing 'RenderReasons'");
return MsgValueError;
}
// Sentinel = 'aReasons'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 234423101)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'RenderReasons'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvFlushRenderingAsync(std::move(aReasons))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_ForcePresent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_ForcePresent", OTHER);
PickleIterator iter__{msg__};
RenderReasons aReasons{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aReasons)))))) {
FatalError("Error deserializing 'RenderReasons'");
return MsgValueError;
}
// Sentinel = 'aReasons'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 234423101)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'RenderReasons'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvForcePresent(std::move(aReasons))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_PTextureConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PTextureConstructor", OTHER);
PickleIterator iter__{msg__};
ActorHandle handle__{};
SurfaceDescriptor aSharedData{};
ReadLockDescriptor aReadLock{};
LayersBackend aBackend{};
TextureFlags aTextureFlags{};
LayersId id{};
uint64_t aSerial{};
MaybeExternalImageId aExternalImageId{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
// Sentinel = 'actor'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aSharedData)))))) {
FatalError("Error deserializing 'SurfaceDescriptor'");
return MsgValueError;
}
// Sentinel = 'aSharedData'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 420480051)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'SurfaceDescriptor'");
return MsgValueError;
}
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aReadLock)))))) {
FatalError("Error deserializing 'ReadLockDescriptor'");
return MsgValueError;
}
// Sentinel = 'aReadLock'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 279774055)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ReadLockDescriptor'");
return MsgValueError;
}
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aBackend)))))) {
FatalError("Error deserializing 'LayersBackend'");
return MsgValueError;
}
// Sentinel = 'aBackend'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 221119242)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayersBackend'");
return MsgValueError;
}
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aTextureFlags)))))) {
FatalError("Error deserializing 'TextureFlags'");
return MsgValueError;
}
// Sentinel = 'aTextureFlags'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 614139200)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TextureFlags'");
return MsgValueError;
}
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(id)))))) {
FatalError("Error deserializing 'LayersId'");
return MsgValueError;
}
// Sentinel = 'id'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 20447438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
return MsgValueError;
}
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aSerial)))))) {
FatalError("Error deserializing 'uint64_t'");
return MsgValueError;
}
// Sentinel = 'aSerial'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 181011138)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
return MsgValueError;
}
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aExternalImageId)))))) {
FatalError("Error deserializing 'MaybeExternalImageId'");
return MsgValueError;
}
// Sentinel = 'aExternalImageId'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 898172469)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeExternalImageId'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
PTextureParent* actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPTextureParent(aSharedData, aReadLock, aBackend, aTextureFlags, id, aSerial, aExternalImageId);
if (!actor) {
NS_WARNING("Cannot bind null PTextureParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPTextureParent.Insert(actor);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPTextureConstructor(std::move(actor), std::move(aSharedData), std::move(aReadLock), std::move(aBackend), std::move(aTextureFlags), std::move(id), std::move(aSerial), std::move(aExternalImageId))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_InitPCanvasParent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_InitPCanvasParent", OTHER);
PickleIterator iter__{msg__};
Endpoint<mozilla::layers::PCanvasParent> aEndpoint{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aEndpoint)))))) {
FatalError("Error deserializing 'Endpoint<mozilla::layers::PCanvasParent>'");
return MsgValueError;
}
// Sentinel = 'aEndpoint'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 292225955)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<mozilla::layers::PCanvasParent>'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvInitPCanvasParent(std::move(aEndpoint))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_ReleasePCanvasParent__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_ReleasePCanvasParent", OTHER);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvReleasePCanvasParent()))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_PWebRenderBridgeConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PWebRenderBridgeConstructor", OTHER);
PickleIterator iter__{msg__};
ActorHandle handle__{};
PipelineId pipelineId{};
LayoutDeviceIntSize aSize{};
WindowKind aKind{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
// Sentinel = 'actor'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(pipelineId)))))) {
FatalError("Error deserializing 'PipelineId'");
return MsgValueError;
}
// Sentinel = 'pipelineId'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 382731268)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'PipelineId'");
return MsgValueError;
}
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aSize)))))) {
FatalError("Error deserializing 'LayoutDeviceIntSize'");
return MsgValueError;
}
// Sentinel = 'aSize'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 97124861)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntSize'");
return MsgValueError;
}
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aKind)))))) {
FatalError("Error deserializing 'WindowKind'");
return MsgValueError;
}
// Sentinel = 'aKind'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 93389288)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'WindowKind'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
PWebRenderBridgeParent* actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPWebRenderBridgeParent(pipelineId, aSize, aKind);
if (!actor) {
NS_WARNING("Cannot bind null PWebRenderBridgeParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPWebRenderBridgeParent.Insert(actor);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPWebRenderBridgeConstructor(std::move(actor), std::move(pipelineId), std::move(aSize), std::move(aKind))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_BeginRecording__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_BeginRecording", OTHER);
PickleIterator iter__{msg__};
TimeStamp aRecordingStart{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aRecordingStart)))))) {
FatalError("Error deserializing 'TimeStamp'");
return MsgValueError;
}
// Sentinel = 'aRecordingStart'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 794428941)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'TimeStamp'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PCompositorBridge::Reply_BeginRecording(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
BeginRecordingResolver resolver = [resolver__ = std::move(resolver__)](const bool& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
WriteIPDLParam(reply__, self__, aParam);
// Sentinel = 'success'
(reply__)->WriteSentinel(200082170);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvBeginRecording(std::move(aRecordingStart), std::move(resolver))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_EndRecordingToDisk__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_EndRecordingToDisk", OTHER);
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PCompositorBridge::Reply_EndRecordingToDisk(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
EndRecordingToDiskResolver resolver = [resolver__ = std::move(resolver__)](const bool& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
WriteIPDLParam(reply__, self__, aParam);
// Sentinel = 'success'
(reply__)->WriteSentinel(200082170);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvEndRecordingToDisk(std::move(resolver))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_EndRecordingToMemory__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_EndRecordingToMemory", OTHER);
int32_t id__ = Id();
UniquePtr<IPC::Message> reply__(PCompositorBridge::Reply_EndRecordingToMemory(id__));
reply__->set_seqno(msg__.seqno());
RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);
EndRecordingToMemoryResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<CollectedFramesParams>& aParam) {
resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
WriteIPDLParam(reply__, self__, aParam);
// Sentinel = 'frames'
(reply__)->WriteSentinel(145490559);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
});
};
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvEndRecordingToMemory(std::move(resolver))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_RequestFxrOutput__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_RequestFxrOutput", OTHER);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvRequestFxrOutput()))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
default:
return MsgNotKnown;
}
}
auto PCompositorBridgeParent::OnMessageReceived(
const Message& msg__,
Message*& reply__) -> PCompositorBridgeParent::Result
{
switch (msg__.type()) {
case PCompositorBridge::Msg_Initialize__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_Initialize", OTHER);
PickleIterator iter__{msg__};
LayersId rootLayerTreeId{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(rootLayerTreeId)))))) {
FatalError("Error deserializing 'LayersId'");
return MsgValueError;
}
// Sentinel = 'rootLayerTreeId'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 828507647)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
int32_t id__ = Id();
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvInitialize(std::move(rootLayerTreeId))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PCompositorBridge::Reply_Initialize(id__);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_WillClose__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_WillClose", OTHER);
int32_t id__ = Id();
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvWillClose()))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PCompositorBridge::Reply_WillClose(id__);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_Pause__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_Pause", OTHER);
int32_t id__ = Id();
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPause()))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PCompositorBridge::Reply_Pause(id__);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_Resume__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_Resume", OTHER);
int32_t id__ = Id();
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvResume()))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PCompositorBridge::Reply_Resume(id__);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_NotifyChildCreated__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_NotifyChildCreated", OTHER);
PickleIterator iter__{msg__};
LayersId id{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(id)))))) {
FatalError("Error deserializing 'LayersId'");
return MsgValueError;
}
// Sentinel = 'id'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 20447438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
int32_t id__ = Id();
CompositorOptions compositorOptions{};
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvNotifyChildCreated(std::move(id), (&(compositorOptions)))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PCompositorBridge::Reply_NotifyChildCreated(id__);
WriteIPDLParam(reply__, this, compositorOptions);
// Sentinel = 'compositorOptions'
(reply__)->WriteSentinel(1089275708);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_MapAndNotifyChildCreated__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_MapAndNotifyChildCreated", OTHER);
PickleIterator iter__{msg__};
LayersId id{};
ProcessId owner{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(id)))))) {
FatalError("Error deserializing 'LayersId'");
return MsgValueError;
}
// Sentinel = 'id'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 20447438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
return MsgValueError;
}
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(owner)))))) {
FatalError("Error deserializing 'ProcessId'");
return MsgValueError;
}
// Sentinel = 'owner'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 110232108)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ProcessId'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
int32_t id__ = Id();
CompositorOptions compositorOptions{};
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvMapAndNotifyChildCreated(std::move(id), std::move(owner), (&(compositorOptions)))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PCompositorBridge::Reply_MapAndNotifyChildCreated(id__);
WriteIPDLParam(reply__, this, compositorOptions);
// Sentinel = 'compositorOptions'
(reply__)->WriteSentinel(1089275708);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_NotifyChildRecreated__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_NotifyChildRecreated", OTHER);
PickleIterator iter__{msg__};
LayersId id{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(id)))))) {
FatalError("Error deserializing 'LayersId'");
return MsgValueError;
}
// Sentinel = 'id'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 20447438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
int32_t id__ = Id();
CompositorOptions compositorOptions{};
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvNotifyChildRecreated(std::move(id), (&(compositorOptions)))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PCompositorBridge::Reply_NotifyChildRecreated(id__);
WriteIPDLParam(reply__, this, compositorOptions);
// Sentinel = 'compositorOptions'
(reply__)->WriteSentinel(1089275708);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_FlushRendering__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_FlushRendering", OTHER);
PickleIterator iter__{msg__};
RenderReasons aReasons{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aReasons)))))) {
FatalError("Error deserializing 'RenderReasons'");
return MsgValueError;
}
// Sentinel = 'aReasons'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 234423101)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'RenderReasons'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
int32_t id__ = Id();
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvFlushRendering(std::move(aReasons))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PCompositorBridge::Reply_FlushRendering(id__);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_WaitOnTransactionProcessed__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_WaitOnTransactionProcessed", OTHER);
int32_t id__ = Id();
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvWaitOnTransactionProcessed()))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PCompositorBridge::Reply_WaitOnTransactionProcessed(id__);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_StartFrameTimeRecording__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_StartFrameTimeRecording", OTHER);
PickleIterator iter__{msg__};
int32_t bufferSize{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(bufferSize)))))) {
FatalError("Error deserializing 'int32_t'");
return MsgValueError;
}
// Sentinel = 'bufferSize'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 376243222)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
int32_t id__ = Id();
uint32_t startIndex{};
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvStartFrameTimeRecording(std::move(bufferSize), (&(startIndex)))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PCompositorBridge::Reply_StartFrameTimeRecording(id__);
WriteIPDLParam(reply__, this, startIndex);
// Sentinel = 'startIndex'
(reply__)->WriteSentinel(386728999);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_StopFrameTimeRecording__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_StopFrameTimeRecording", OTHER);
PickleIterator iter__{msg__};
uint32_t startIndex{};
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(startIndex)))))) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
// Sentinel = 'startIndex'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 386728999)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
int32_t id__ = Id();
nsTArray<float> intervals{};
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvStopFrameTimeRecording(std::move(startIndex), (&(intervals)))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PCompositorBridge::Reply_StopFrameTimeRecording(id__);
WriteIPDLParam(reply__, this, intervals);
// Sentinel = 'intervals'
(reply__)->WriteSentinel(322175961);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_SyncWithCompositor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_SyncWithCompositor", OTHER);
int32_t id__ = Id();
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvSyncWithCompositor()))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PCompositorBridge::Reply_SyncWithCompositor(id__);