Other Tools

//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/layers/PCompositorBridgeParent.h"
#include "ipc/IPCMessageUtils.h"
#include "mozilla/D3DMessageUtils.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/layers/CompositorBridgeParent.h"
#include "mozilla/layers/CompositorTypes.h"
#include "mozilla/layers/FrameUniformityData.h"
#include "mozilla/layers/LayersTypes.h"
#include "mozilla/layers/ScrollableLayerGuid.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/PLayerTransactionParent.h"
#include "mozilla/layers/PTextureParent.h"
#include "mozilla/dom/PWebGLParent.h"
#include "mozilla/layers/PWebRenderBridgeParent.h"
#include "mozilla/webgpu/PWebGPUParent.h"
#include "nsIFile.h"
#include "GeckoProfiler.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::RecvPLayerTransactionConstructor(
PLayerTransactionParent* actor,
nsTArray<LayersBackend>&& layersBackendHints,
const LayersId& id) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PCompositorBridgeParent::RecvPTextureConstructor(
PTextureParent* actor,
const SurfaceDescriptor& aSharedData,
const 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) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PCompositorBridgeParent::RecvPWebGLConstructor(PWebGLParent* actor) -> 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::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::ManagedPLayerTransactionParent(nsTArray<PLayerTransactionParent*>& aArr) const -> void
{
mManagedPLayerTransactionParent.ToArray(aArr);
}
auto PCompositorBridgeParent::ManagedPLayerTransactionParent() const -> const ManagedContainer<PLayerTransactionParent>&
{
return mManagedPLayerTransactionParent;
}
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::ManagedPWebGLParent(nsTArray<PWebGLParent*>& aArr) const -> void
{
mManagedPWebGLParent.ToArray(aArr);
}
auto PCompositorBridgeParent::ManagedPWebGLParent() const -> const ManagedContainer<PWebGLParent>&
{
return mManagedPWebGLParent;
}
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 += mManagedPLayerTransactionParent.Count();
total += mManagedPTextureParent.Count();
total += mManagedPCompositorWidgetParent.Count();
total += mManagedPWebRenderBridgeParent.Count();
total += mManagedPWebGLParent.Count();
total += mManagedPWebGPUParent.Count();
arr__.SetCapacity(total);
for (auto it = mManagedPAPZParent.ConstIter(); !it.Done(); it.Next()) {
arr__.AppendElement(it.Get()->GetKey()->GetLifecycleProxy());
}
for (auto it = mManagedPAPZCTreeManagerParent.ConstIter(); !it.Done(); it.Next()) {
arr__.AppendElement(it.Get()->GetKey()->GetLifecycleProxy());
}
for (auto it = mManagedPLayerTransactionParent.ConstIter(); !it.Done(); it.Next()) {
arr__.AppendElement(it.Get()->GetKey()->GetLifecycleProxy());
}
for (auto it = mManagedPTextureParent.ConstIter(); !it.Done(); it.Next()) {
arr__.AppendElement(it.Get()->GetKey()->GetLifecycleProxy());
}
for (auto it = mManagedPCompositorWidgetParent.ConstIter(); !it.Done(); it.Next()) {
arr__.AppendElement(it.Get()->GetKey()->GetLifecycleProxy());
}
for (auto it = mManagedPWebRenderBridgeParent.ConstIter(); !it.Done(); it.Next()) {
arr__.AppendElement(it.Get()->GetKey()->GetLifecycleProxy());
}
for (auto it = mManagedPWebGLParent.ConstIter(); !it.Done(); it.Next()) {
arr__.AppendElement(it.Get()->GetKey()->GetLifecycleProxy());
}
for (auto it = mManagedPWebGPUParent.ConstIter(); !it.Done(); it.Next()) {
arr__.AppendElement(it.Get()->GetKey()->GetLifecycleProxy());
}
}
auto PCompositorBridgeParent::OpenPAPZEndpoint(PAPZParent* aActor) -> ManagedEndpoint<PAPZChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PAPZParent actor");
return ManagedEndpoint<PAPZChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPAPZParent.PutEntry(aActor);
return ManagedEndpoint<PAPZChild>(mozilla::ipc::PrivateIPDLInterface(), aActor->Id());
}
auto PCompositorBridgeParent::BindPAPZEndpoint(
ManagedEndpoint<PAPZParent> aEndpoint,
PAPZParent* aActor) -> bool
{
MOZ_RELEASE_ASSERT(aEndpoint.ActorId(), "Invalid Endpoint!");
if (!aActor) {
NS_WARNING("Cannot bind null PAPZParent actor");
return false;
}
aActor->SetManagerAndRegister(this, *aEndpoint.ActorId());
mManagedPAPZParent.PutEntry(aActor);
return true;
}
auto PCompositorBridgeParent::OpenPAPZCTreeManagerEndpoint(PAPZCTreeManagerParent* aActor) -> ManagedEndpoint<PAPZCTreeManagerChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PAPZCTreeManagerParent actor");
return ManagedEndpoint<PAPZCTreeManagerChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPAPZCTreeManagerParent.PutEntry(aActor);
return ManagedEndpoint<PAPZCTreeManagerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor->Id());
}
auto PCompositorBridgeParent::BindPAPZCTreeManagerEndpoint(
ManagedEndpoint<PAPZCTreeManagerParent> aEndpoint,
PAPZCTreeManagerParent* aActor) -> bool
{
MOZ_RELEASE_ASSERT(aEndpoint.ActorId(), "Invalid Endpoint!");
if (!aActor) {
NS_WARNING("Cannot bind null PAPZCTreeManagerParent actor");
return false;
}
aActor->SetManagerAndRegister(this, *aEndpoint.ActorId());
mManagedPAPZCTreeManagerParent.PutEntry(aActor);
return true;
}
auto PCompositorBridgeParent::OpenPLayerTransactionEndpoint(PLayerTransactionParent* aActor) -> ManagedEndpoint<PLayerTransactionChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PLayerTransactionParent actor");
return ManagedEndpoint<PLayerTransactionChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPLayerTransactionParent.PutEntry(aActor);
return ManagedEndpoint<PLayerTransactionChild>(mozilla::ipc::PrivateIPDLInterface(), aActor->Id());
}
auto PCompositorBridgeParent::BindPLayerTransactionEndpoint(
ManagedEndpoint<PLayerTransactionParent> aEndpoint,
PLayerTransactionParent* aActor) -> bool
{
MOZ_RELEASE_ASSERT(aEndpoint.ActorId(), "Invalid Endpoint!");
if (!aActor) {
NS_WARNING("Cannot bind null PLayerTransactionParent actor");
return false;
}
aActor->SetManagerAndRegister(this, *aEndpoint.ActorId());
mManagedPLayerTransactionParent.PutEntry(aActor);
return true;
}
auto PCompositorBridgeParent::OpenPTextureEndpoint(PTextureParent* aActor) -> ManagedEndpoint<PTextureChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PTextureParent actor");
return ManagedEndpoint<PTextureChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPTextureParent.PutEntry(aActor);
return ManagedEndpoint<PTextureChild>(mozilla::ipc::PrivateIPDLInterface(), aActor->Id());
}
auto PCompositorBridgeParent::BindPTextureEndpoint(
ManagedEndpoint<PTextureParent> aEndpoint,
PTextureParent* aActor) -> bool
{
MOZ_RELEASE_ASSERT(aEndpoint.ActorId(), "Invalid Endpoint!");
if (!aActor) {
NS_WARNING("Cannot bind null PTextureParent actor");
return false;
}
aActor->SetManagerAndRegister(this, *aEndpoint.ActorId());
mManagedPTextureParent.PutEntry(aActor);
return true;
}
auto PCompositorBridgeParent::OpenPCompositorWidgetEndpoint(PCompositorWidgetParent* aActor) -> ManagedEndpoint<PCompositorWidgetChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PCompositorWidgetParent actor");
return ManagedEndpoint<PCompositorWidgetChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPCompositorWidgetParent.PutEntry(aActor);
return ManagedEndpoint<PCompositorWidgetChild>(mozilla::ipc::PrivateIPDLInterface(), aActor->Id());
}
auto PCompositorBridgeParent::BindPCompositorWidgetEndpoint(
ManagedEndpoint<PCompositorWidgetParent> aEndpoint,
PCompositorWidgetParent* aActor) -> bool
{
MOZ_RELEASE_ASSERT(aEndpoint.ActorId(), "Invalid Endpoint!");
if (!aActor) {
NS_WARNING("Cannot bind null PCompositorWidgetParent actor");
return false;
}
aActor->SetManagerAndRegister(this, *aEndpoint.ActorId());
mManagedPCompositorWidgetParent.PutEntry(aActor);
return true;
}
auto PCompositorBridgeParent::OpenPWebRenderBridgeEndpoint(PWebRenderBridgeParent* aActor) -> ManagedEndpoint<PWebRenderBridgeChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWebRenderBridgeParent actor");
return ManagedEndpoint<PWebRenderBridgeChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPWebRenderBridgeParent.PutEntry(aActor);
return ManagedEndpoint<PWebRenderBridgeChild>(mozilla::ipc::PrivateIPDLInterface(), aActor->Id());
}
auto PCompositorBridgeParent::BindPWebRenderBridgeEndpoint(
ManagedEndpoint<PWebRenderBridgeParent> aEndpoint,
PWebRenderBridgeParent* aActor) -> bool
{
MOZ_RELEASE_ASSERT(aEndpoint.ActorId(), "Invalid Endpoint!");
if (!aActor) {
NS_WARNING("Cannot bind null PWebRenderBridgeParent actor");
return false;
}
aActor->SetManagerAndRegister(this, *aEndpoint.ActorId());
mManagedPWebRenderBridgeParent.PutEntry(aActor);
return true;
}
auto PCompositorBridgeParent::OpenPWebGLEndpoint(PWebGLParent* aActor) -> ManagedEndpoint<PWebGLChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWebGLParent actor");
return ManagedEndpoint<PWebGLChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPWebGLParent.PutEntry(aActor);
return ManagedEndpoint<PWebGLChild>(mozilla::ipc::PrivateIPDLInterface(), aActor->Id());
}
auto PCompositorBridgeParent::BindPWebGLEndpoint(
ManagedEndpoint<PWebGLParent> aEndpoint,
PWebGLParent* aActor) -> bool
{
MOZ_RELEASE_ASSERT(aEndpoint.ActorId(), "Invalid Endpoint!");
if (!aActor) {
NS_WARNING("Cannot bind null PWebGLParent actor");
return false;
}
aActor->SetManagerAndRegister(this, *aEndpoint.ActorId());
mManagedPWebGLParent.PutEntry(aActor);
return true;
}
auto PCompositorBridgeParent::OpenPWebGPUEndpoint(PWebGPUParent* aActor) -> ManagedEndpoint<PWebGPUChild>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWebGPUParent actor");
return ManagedEndpoint<PWebGPUChild>();
}
aActor->SetManagerAndRegister(this);
mManagedPWebGPUParent.PutEntry(aActor);
return ManagedEndpoint<PWebGPUChild>(mozilla::ipc::PrivateIPDLInterface(), aActor->Id());
}
auto PCompositorBridgeParent::BindPWebGPUEndpoint(
ManagedEndpoint<PWebGPUParent> aEndpoint,
PWebGPUParent* aActor) -> bool
{
MOZ_RELEASE_ASSERT(aEndpoint.ActorId(), "Invalid Endpoint!");
if (!aActor) {
NS_WARNING("Cannot bind null PWebGPUParent actor");
return false;
}
aActor->SetManagerAndRegister(this, *aEndpoint.ActorId());
mManagedPWebGPUParent.PutEntry(aActor);
return true;
}
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",
OtherPid(),
"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 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",
OtherPid(),
"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",
OtherPid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_NotifyFrameStats", OTHER);
bool sendok__ = ChannelSend(msg__);
return sendok__;
}
auto PCompositorBridgeParent::SendRemotePaintIsReady() -> bool
{
IPC::Message* msg__ = PCompositorBridge::Msg_RemotePaintIsReady(Id());
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_RemotePaintIsReady", OTHER);
bool sendok__ = ChannelSend(msg__);
return sendok__;
}
auto PCompositorBridgeParent::SendUpdatePluginConfigurations(
const LayoutDeviceIntPoint& aContentOffset,
const LayoutDeviceIntRegion& aVisibleRegion,
const nsTArray<PluginWindowData>& aPlugins) -> bool
{
IPC::Message* msg__ = PCompositorBridge::Msg_UpdatePluginConfigurations(Id());
WriteIPDLParam(msg__, this, aContentOffset);
// Sentinel = 'aContentOffset'
(msg__)->WriteSentinel(694748580);
WriteIPDLParam(msg__, this, aVisibleRegion);
// Sentinel = 'aVisibleRegion'
(msg__)->WriteSentinel(692979092);
WriteIPDLParam(msg__, this, aPlugins);
// Sentinel = 'aPlugins'
(msg__)->WriteSentinel(238486340);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_UpdatePluginConfigurations", OTHER);
bool sendok__ = ChannelSend(msg__);
return sendok__;
}
auto PCompositorBridgeParent::SendCaptureAllPlugins(const uintptr_t& aParentWidget) -> bool
{
IPC::Message* msg__ = PCompositorBridge::Msg_CaptureAllPlugins(Id());
WriteIPDLParam(msg__, this, aParentWidget);
// Sentinel = 'aParentWidget'
(msg__)->WriteSentinel(597427504);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_CaptureAllPlugins", OTHER);
bool sendok__ = ChannelSend(msg__);
return sendok__;
}
auto PCompositorBridgeParent::SendHideAllPlugins(const uintptr_t& aParentWidget) -> bool
{
IPC::Message* msg__ = PCompositorBridge::Msg_HideAllPlugins(Id());
WriteIPDLParam(msg__, this, aParentWidget);
// Sentinel = 'aParentWidget'
(msg__)->WriteSentinel(597427504);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_HideAllPlugins", 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",
OtherPid(),
"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",
OtherPid(),
"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",
OtherPid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_CompositorOptionsChanged", OTHER);
bool sendok__ = ChannelSend(msg__);
return sendok__;
}
auto PCompositorBridgeParent::SendSharedCompositorFrameMetrics(
const Handle& metrics,
const CrossProcessMutexHandle& mutex,
const LayersId& aLayersId,
const uint32_t& aAPZCId) -> bool
{
IPC::Message* msg__ = PCompositorBridge::Msg_SharedCompositorFrameMetrics(Id());
WriteIPDLParam(msg__, this, metrics);
// Sentinel = 'metrics'
(msg__)->WriteSentinel(199230200);
WriteIPDLParam(msg__, this, mutex);
// Sentinel = 'mutex'
(msg__)->WriteSentinel(110625332);
WriteIPDLParam(msg__, this, aLayersId);
// Sentinel = 'aLayersId'
(msg__)->WriteSentinel(291439487);
WriteIPDLParam(msg__, this, aAPZCId);
// Sentinel = 'aAPZCId'
(msg__)->WriteSentinel(149619261);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_SharedCompositorFrameMetrics", OTHER);
bool sendok__ = ChannelSend(msg__);
return sendok__;
}
auto PCompositorBridgeParent::SendReleaseSharedCompositorFrameMetrics(
const ViewID& aId,
const uint32_t& aAPZCId) -> bool
{
IPC::Message* msg__ = PCompositorBridge::Msg_ReleaseSharedCompositorFrameMetrics(Id());
WriteIPDLParam(msg__, this, aId);
// Sentinel = 'aId'
(msg__)->WriteSentinel(35389711);
WriteIPDLParam(msg__, this, aAPZCId);
// Sentinel = 'aAPZCId'
(msg__)->WriteSentinel(149619261);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_ReleaseSharedCompositorFrameMetrics", 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);
auto& container = mManagedPAPZParent;
// Use a temporary variable here so all the assertion expressions
// in the MOZ_RELEASE_ASSERT call below are textually identical;
// the linker can then merge the strings from the assertion macro(s).
MOZ_RELEASE_ASSERT(container.Contains(actor),
"actor not managed by this!");
container.RemoveEntry(actor);
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PAPZCTreeManagerMsgStart:
{
PAPZCTreeManagerParent* actor = static_cast<PAPZCTreeManagerParent*>(aListener);
auto& container = mManagedPAPZCTreeManagerParent;
// Use a temporary variable here so all the assertion expressions
// in the MOZ_RELEASE_ASSERT call below are textually identical;
// the linker can then merge the strings from the assertion macro(s).
MOZ_RELEASE_ASSERT(container.Contains(actor),
"actor not managed by this!");
container.RemoveEntry(actor);
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PLayerTransactionMsgStart:
{
PLayerTransactionParent* actor = static_cast<PLayerTransactionParent*>(aListener);
auto& container = mManagedPLayerTransactionParent;
// Use a temporary variable here so all the assertion expressions
// in the MOZ_RELEASE_ASSERT call below are textually identical;
// the linker can then merge the strings from the assertion macro(s).
MOZ_RELEASE_ASSERT(container.Contains(actor),
"actor not managed by this!");
container.RemoveEntry(actor);
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PTextureMsgStart:
{
PTextureParent* actor = static_cast<PTextureParent*>(aListener);
auto& container = mManagedPTextureParent;
// Use a temporary variable here so all the assertion expressions
// in the MOZ_RELEASE_ASSERT call below are textually identical;
// the linker can then merge the strings from the assertion macro(s).
MOZ_RELEASE_ASSERT(container.Contains(actor),
"actor not managed by this!");
container.RemoveEntry(actor);
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PCompositorWidgetMsgStart:
{
PCompositorWidgetParent* actor = static_cast<PCompositorWidgetParent*>(aListener);
auto& container = mManagedPCompositorWidgetParent;
// Use a temporary variable here so all the assertion expressions
// in the MOZ_RELEASE_ASSERT call below are textually identical;
// the linker can then merge the strings from the assertion macro(s).
MOZ_RELEASE_ASSERT(container.Contains(actor),
"actor not managed by this!");
container.RemoveEntry(actor);
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PWebRenderBridgeMsgStart:
{
PWebRenderBridgeParent* actor = static_cast<PWebRenderBridgeParent*>(aListener);
auto& container = mManagedPWebRenderBridgeParent;
// Use a temporary variable here so all the assertion expressions
// in the MOZ_RELEASE_ASSERT call below are textually identical;
// the linker can then merge the strings from the assertion macro(s).
MOZ_RELEASE_ASSERT(container.Contains(actor),
"actor not managed by this!");
container.RemoveEntry(actor);
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PWebGLMsgStart:
{
PWebGLParent* actor = static_cast<PWebGLParent*>(aListener);
auto& container = mManagedPWebGLParent;
// Use a temporary variable here so all the assertion expressions
// in the MOZ_RELEASE_ASSERT call below are textually identical;
// the linker can then merge the strings from the assertion macro(s).
MOZ_RELEASE_ASSERT(container.Contains(actor),
"actor not managed by this!");
container.RemoveEntry(actor);
auto* proxy = actor->GetLifecycleProxy();
NS_IF_RELEASE(proxy);
return;
} case PWebGPUMsgStart:
{
PWebGPUParent* actor = static_cast<PWebGPUParent*>(aListener);
auto& container = mManagedPWebGPUParent;
// Use a temporary variable here so all the assertion expressions
// in the MOZ_RELEASE_ASSERT call below are textually identical;
// the linker can then merge the strings from the assertion macro(s).
MOZ_RELEASE_ASSERT(container.Contains(actor),
"actor not managed by this!");
container.RemoveEntry(actor);
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 PLayerTransactionMsgStart:
static_cast<CompositorBridgeParentBase*>(this)->DeallocPLayerTransactionParent(static_cast<PLayerTransactionParent*>(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 PCompositorBridge::Msg___delete____ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"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",
OtherPid(),
"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.PutEntry(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",
OtherPid(),
"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.PutEntry(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",
OtherPid(),
"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.PutEntry(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",
OtherPid(),
"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.PutEntry(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_RemotePluginsReady__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_RemotePluginsReady", OTHER);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvRemotePluginsReady()))) {
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",
OtherPid(),
"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",
OtherPid(),
"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",
OtherPid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_FlushRenderingAsync", OTHER);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvFlushRenderingAsync()))) {
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",
OtherPid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_ForcePresent", OTHER);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvForcePresent()))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_PLayerTransactionConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PLayerTransactionConstructor", OTHER);
PickleIterator iter__(msg__);
ActorHandle handle__;
nsTArray<LayersBackend> layersBackendHints;
LayersId id;
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, (&(layersBackendHints)))))) {
FatalError("Error deserializing 'LayersBackend[]'");
return MsgValueError;
}
// Sentinel = 'layersBackendHints'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1153435455)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'LayersBackend[]'");
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;
}
msg__.EndRead(iter__, msg__.type());
PLayerTransactionParent* actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPLayerTransactionParent(layersBackendHints, id);
if (!actor) {
NS_WARNING("Cannot bind null PLayerTransactionParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPLayerTransactionParent.PutEntry(actor);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPLayerTransactionConstructor(std::move(actor), std::move(layersBackendHints), std::move(id))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_NotifyRegionInvalidated__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_NotifyRegionInvalidated", OTHER);
PickleIterator iter__(msg__);
nsIntRegion region;
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(region)))))) {
FatalError("Error deserializing 'nsIntRegion'");
return MsgValueError;
}
// Sentinel = 'region'
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 147718789)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIntRegion'");
return MsgValueError;
}
msg__.EndRead(iter__, msg__.type());
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvNotifyRegionInvalidated(std::move(region))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_RequestNotifyAfterRemotePaint__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_RequestNotifyAfterRemotePaint", OTHER);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvRequestNotifyAfterRemotePaint()))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PCompositorBridge::Msg_AllPluginsCaptured__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_AllPluginsCaptured", OTHER);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvAllPluginsCaptured()))) {
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",
OtherPid(),
"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.PutEntry(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",
OtherPid(),
"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",
OtherPid(),
"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",
OtherPid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PWebRenderBridgeConstructor", OTHER);
PickleIterator iter__(msg__);
ActorHandle handle__;
PipelineId pipelineId;
LayoutDeviceIntSize aSize;
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;
}
msg__.EndRead(iter__, msg__.type());
PWebRenderBridgeParent* actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPWebRenderBridgeParent(pipelineId, aSize);
if (!actor) {
NS_WARNING("Cannot bind null PWebRenderBridgeParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPWebRenderBridgeParent.PutEntry(actor);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPWebRenderBridgeConstructor(std::move(actor), std::move(pipelineId), std::move(aSize))))) {
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",
OtherPid(),
"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();
int32_t seqno__ = (msg__).seqno();
WeakPtr<PCompositorBridgeParent> self__ = this;
BeginRecordingResolver resolver = [this, self__, id__, seqno__](const bool& aParam) {
if ((!(self__))) {
NS_WARNING("Not resolving response because actor is dead.");
return;
}
bool resolve__ = true;
bool success;
success = std::move(aParam);
IPC::Message* reply__ = PCompositorBridge::Reply_BeginRecording(id__);
WriteIPDLParam(reply__, self__, resolve__);
// Sentinel = 'resolve__'
(reply__)->WriteSentinel(322044863);
WriteIPDLParam(reply__, self__, success);
// Sentinel = 'success'
(reply__)->WriteSentinel(200082170);
(reply__)->set_seqno(seqno__);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
bool sendok__ = ChannelSend(reply__);
if ((!(sendok__))) {
NS_WARNING("Error sending reply");
}
};
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",
OtherPid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_EndRecordingToDisk", OTHER);
int32_t id__ = Id();
int32_t seqno__ = (msg__).seqno();
WeakPtr<PCompositorBridgeParent> self__ = this;
EndRecordingToDiskResolver resolver = [this, self__, id__, seqno__](const bool& aParam) {
if ((!(self__))) {
NS_WARNING("Not resolving response because actor is dead.");
return;
}
bool resolve__ = true;
bool success;
success = std::move(aParam);
IPC::Message* reply__ = PCompositorBridge::Reply_EndRecordingToDisk(id__);
WriteIPDLParam(reply__, self__, resolve__);
// Sentinel = 'resolve__'
(reply__)->WriteSentinel(322044863);
WriteIPDLParam(reply__, self__, success);
// Sentinel = 'success'
(reply__)->WriteSentinel(200082170);
(reply__)->set_seqno(seqno__);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
bool sendok__ = ChannelSend(reply__);
if ((!(sendok__))) {
NS_WARNING("Error sending reply");
}
};
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",
OtherPid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_EndRecordingToMemory", OTHER);
int32_t id__ = Id();
int32_t seqno__ = (msg__).seqno();
WeakPtr<PCompositorBridgeParent> self__ = this;
EndRecordingToMemoryResolver resolver = [this, self__, id__, seqno__](const mozilla::Maybe<CollectedFramesParams>& aParam) {
if ((!(self__))) {
NS_WARNING("Not resolving response because actor is dead.");
return;
}
bool resolve__ = true;
mozilla::Maybe<CollectedFramesParams> frames;
frames = std::move(aParam);
IPC::Message* reply__ = PCompositorBridge::Reply_EndRecordingToMemory(id__);
WriteIPDLParam(reply__, self__, resolve__);
// Sentinel = 'resolve__'
(reply__)->WriteSentinel(322044863);
WriteIPDLParam(reply__, self__, frames);
// Sentinel = 'frames'
(reply__)->WriteSentinel(145490559);
(reply__)->set_seqno(seqno__);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
bool sendok__ = ChannelSend(reply__);
if ((!(sendok__))) {
NS_WARNING("Error sending reply");
}
};
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",
OtherPid(),
"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;
}
case PCompositorBridge::Msg_PWebGLConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PWebGLConstructor", 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());
RefPtr<PWebGLParent> actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPWebGLParent();
if (!actor) {
NS_WARNING("Cannot bind null PWebGLParent actor");
return MsgValueError;
}
actor->SetManagerAndRegister(this, (handle__).mId);
mManagedPWebGLParent.PutEntry(actor);
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPWebGLConstructor(actor)))) {
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",
OtherPid(),
"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",
OtherPid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_GetFrameUniformity__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_GetFrameUniformity", OTHER);
int32_t id__ = Id();
FrameUniformityData data;
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvGetFrameUniformity((&(data)))))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
reply__ = PCompositorBridge::Reply_GetFrameUniformity(id__);
WriteIPDLParam(reply__, this, data);
// Sentinel = 'data'
(reply__)->WriteSentinel(67109275);
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_WillClose__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"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",
OtherPid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_Pause__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"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",
OtherPid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_Resume__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"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",
OtherPid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_NotifyChildCreated__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"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",
OtherPid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_MapAndNotifyChildCreated__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"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",
OtherPid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::eSending);
}
return MsgProcessed;
}
case PCompositorBridge::Msg_NotifyChildRecreated__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
mozilla::ipc::LogMessageForProtocol(
"PCompositorBridgeParent",
OtherPid(),
"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",
OtherPid(),
"Sending reply ",
reply__->type(),
mozilla::ipc::MessageDirection::